class NationalIdObject: # Indicates the national ID value - for example, a social security number id_value: str # Two-letter country code (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country: typing.Optional[str] = datafield(default=None) # Indicates the type of the ID type: typing.Optional[str] = datafield(default=None)
class CommandRequestObject: # A unique identifier for the Command. cid: str = datafield(metadata={"valid-values": UUID_REGEX}) # A string representing the type of Command contained in the request. command_type: str command: dict # pyre-ignore _ObjectType: str = datafield(default="CommandRequestObject", metadata={"valid-values": ["CommandRequestObject"]})
class PaymentActionObject: amount: int currency: str action: str = datafield(default="charge", metadata={"valid-values": ["charge"]}) # Unix timestamp (seconds) indicating the time that the payment Command was created. timestamp: int = datafield(default_factory=lambda: int(time.time()))
class PaymentActorObject: address: str = datafield(metadata={"write_once": True}) status: StatusObject kyc_data: typing.Optional[KycDataObject] = datafield( default=None, metadata={"write_once": True}) metadata: typing.Optional[typing.List[str]] = datafield(default=None) additional_kyc_data: typing.Optional[str] = datafield( default=None, metadata={"write_once": True})
class CommandResponseObject: # Either success or failure. status: str = datafield(metadata={"valid-values": [CommandResponseStatus.success, CommandResponseStatus.failure]}) # The fixed string CommandResponseObject. _ObjectType: str = datafield(default="CommandResponseObject", metadata={"valid-values": ["CommandResponseObject"]}) # Details on errors when status == "failure" error: typing.Optional[OffChainErrorObject] = datafield(default=None) # The Command identifier to which this is a response. cid: typing.Optional[str] = datafield(default=None)
class OffChainErrorObject: # Either "command_error" or "protocol_error". type: str # The error code of the corresponding error code: str # The field on which this error occurred field: typing.Optional[str] = datafield(default=None) # Additional details about this error message: typing.Optional[str] = datafield(default=None)
class Register(): """ Models a register """ name: str = "" """ The abbreviated/symbolic/accronym name for this register """ long_name: str = "" """ The non-abbreviated/spelled out name for this register """ purpose: str = "" """ A description of this register's purpose """ size: int = 64 """ The size (in bits) of this register """ arch: str = "none" """ The name of the architecture this register belongs to """ is_internal: bool = False """ True if the register is internal to a CPU """ is_optional: bool = False """ True if this register is an optional feature of the architecture """ is_indexed: bool = False """ True if the register has many instances, accessable via an index """ access_mechanisms: Dict[str, List[AbstractAccessMechanism]] \ = datafield(default_factory= lambda: {}) """ Access mechanisms by which this register is readable/writable """ fieldsets: List[Fieldset] = datafield(default_factory=lambda: []) """ List of fieldsets that define all fields/bitfields in this register """ def is_valid(self): for fs in self.fieldsets: if not fs.is_valid(): return False for am_list in self.access_mechanisms.values(): for am in am_list: if not am.is_valid(): return False return True def is_readable(self): for am_list in self.access_mechanisms.values(): for am in am_list: if am.is_read(): return True return False def is_writeable(self): for am_list in self.access_mechanisms.values(): for am in am_list: if am.is_write(): return True return False
class PaymentObject: reference_id: str = datafield(metadata={"valid-values": UUID_REGEX}) sender: PaymentActorObject receiver: PaymentActorObject action: PaymentActionObject = datafield(metadata={"write_once": True}) original_payment_reference_id: typing.Optional[str] = datafield( default=None, metadata={"immutable": True}) recipient_signature: typing.Optional[str] = datafield( default=None, metadata={"write_once": True}) description: typing.Optional[str] = datafield( default=None, metadata={"write_once": True})
class PrioritizedItem: table: str = datafield(compare=False) tuple: Any = datafield(compare=False) field: str = datafield(compare=False, default='') value: Any = datafield(compare=False, default='') schema: str = datafield(compare=False, default='experiment') replace: bool = datafield(compare=False, default=False) block: bool = datafield(compare=False, default=False) priority: int = datafield(default=50) error: bool = datafield(compare=False, default=False)
class CommandRequestObject: # A unique identifier for the Command. cid: str = datafield(metadata={"valid-values": UUID_REGEX}) # A string representing the type of Command contained in the request. command_type: str = datafield( metadata={ "valid-values": [ CommandType.PaymentCommand, CommandType.FundPullPreApprovalCommand ] }) command: PaymentCommandObject _ObjectType: str = datafield( default="CommandRequestObject", metadata={"valid-values": ["CommandRequestObject"]})
class ARMv8ARegister(Register): """ Models a register in the ARMv8-A architecture profile """ execution_state: str = None """ The execution state this register belongs to: """ """ None = no associated execution state (i.e. memory mapped) """ """ aarch32 = ARM 32-bit execution state """ """ aarch64 = ARM 64-bit execution state """ is_banked: bool = False """ True if the register is banked (has copies per exception level) """ arch: str = "armv8-a" access_mechanisms: Dict[str, List[AbstractAccessMechanism]] \ = datafield(default_factory= lambda: { "mrc": [], "mcr": [], "mrrc": [], "mcrr": [], "ldr": [], "str": [], "msr": [], "mrs_register": [], "mrs_banked": [], "msr_register": [], "msr_banked": [], "msr_immediate": [], "vmsr": [], "vmrs": [], })
class StatusObject: # Status of the payment from the perspective of this actor. Required status: str = datafield( metadata={ "valid-values": [ Status.none, Status.needs_kyc_data, Status.ready_for_settlement, Status.abort, Status.soft_match, ] }) # In the case of an abort status, this field may be used to describe the reason for the abort. abort_code: typing.Optional[str] = datafield(default=None) # Additional details about this error. To be used only when code is populated abort_message: typing.Optional[str] = datafield(default=None)
class ExecutionContext(): """ Models the context under which an instruction may be executed """ execution_state: str = "" """ The name of the execution state an instruction is executable in """ logical_inputs: List[LogicalOperand] = datafield( default_factory=lambda: []) """ List of logical values this instruction takes as inputs """ logical_ouputs: List[LogicalOperand] = datafield( default_factory=lambda: []) """ List of logical values this instruction produces as outputs """ register_operands: List[RegisterOperand] = datafield( default_factory=lambda: []) """ List of registers this instruction operates on """
class PrioritizedItem: table: str = datafield(compare=False) tuple: Any = datafield(compare=False) field: str = datafield(compare=False, default='') value: Any = datafield(compare=False, default='') schema: str = datafield(compare=False, default='lab') replace: bool = datafield(compare=False, default=False) priority: int = datafield(default=50)
class ReferenceIDCommandResultObject: # ReferenceIDCommandResponse: Receiver's onchain account identifier receiver_address: str _ObjectType: str = datafield( default=OffChainCommandResponseResultType.ReferenceIDCommandResponse, metadata={ "valid-values": [ OffChainCommandResponseResultType.ReferenceIDCommandResponse, ] }, )
class GenericRegister(Register): """ Models a generic register that does not belong to a particular """ """ microarchitecture """ arch: str = "generic" access_mechanisms: Dict[str, List[AbstractAccessMechanism]] \ = datafield(default_factory= lambda: { "read": [], "write": [], })
class x86_64Register(Register): """ Models a register in the Intel x86_64 architecture """ arch: str = "x86_64" execution_states: Dict[str, bool] \ = datafield(default_factory= lambda: { "real_mode": False, "protected_mode": False, "64bit_mode": False, "compatibility_mode": False, "virtual_8086": False, }) arch_variants: Dict[str, bool] \ = datafield(default_factory= lambda: { "skylake": False, "goldmont": False, "kaby_lake": False, "coffee_lake": False, "goldmont_plus": False, "cannon_lake": False, "whiskey_lake": False, "amber_lake": False, "cascade_lake": False, "comet_lake": False, "ice_lake": False, }) access_mechanisms: Dict[str, List[AbstractAccessMechanism]] \ = datafield(default_factory= lambda: { "mov_read": [], "mov_write": [], "cpuid": [], "rdmsr": [], "wrmsr": [], "vmread": [], "vmwrite": [], "xgetbv": [], "xsetbv": [], })
class ReferenceIDCommandObject: # Sender's full DiemID sender: str # Sender's onchain account identifier with subaddress set to `None` or the zero subaddress sender_address: str # Receiver's full DiemID receiver: str # Reference ID of this transaction reference_id: str _ObjectType: str = datafield( default=CommandType.ReferenceIDCommand, metadata={"valid-values": [CommandType.ReferenceIDCommand]} )
class Instruction(): """ Models an instruction """ name: str = "" """ The abbreviated/symbolic/accronym name for this instruction """ long_name: str = "" """ The non-abbreviated/spelled out name for this instruction """ purpose: str = "" """ A description of this instruction's purpose """ execution_contexts: List[ExecutionContext] = datafield(default_factory= lambda: []) """ List of execution contexts that define the usage of this instruction """
class KycDataObject: # Must be either “individual” or “entity”. Required. type: str = datafield(metadata={ "valid-values": [KycDataObjectType.individual, KycDataObjectType.entity] }) # Version identifier to allow modifications to KYC data Object without needing to bump version of entire API set. Set to 1 payload_version: int = datafield(default=1, metadata={"valid-values": [1]}) # Legal given name of the user for which this KYC data Object applies. given_name: typing.Optional[str] = datafield(default=None) # Legal surname of the user for which this KYC data Object applies. surname: typing.Optional[str] = datafield(default=None) # Physical address data for this account address: typing.Optional[AddressObject] = datafield(default=None) # Date of birth for the holder of this account. Specified as an ISO 8601 calendar date format: https:#en.wikipedia.org/wiki/ISO_8601 dob: typing.Optional[str] = datafield(default=None) # Place of birth for this user. line1 and line2 fields should not be populated for this usage of the address Object place_of_birth: typing.Optional[AddressObject] = datafield(default=None) # National ID information for the holder of this account national_id: typing.Optional[NationalIdObject] = datafield(default=None) # Name of the legal entity. Used when subaddress represents a legal entity rather than an individual. KycDataObject should only include one of legal_entity_name OR given_name/surname legal_entity_name: typing.Optional[str] = datafield(default=None)
class AddressObject: # The city, district, suburb, town, or village city: typing.Optional[str] = datafield(default=None) # Two-letter country code (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country: typing.Optional[str] = datafield(default=None) # Address line 1 line1: typing.Optional[str] = datafield(default=None) # Address line 2 - apartment, unit, etc. line2: typing.Optional[str] = datafield(default=None) # ZIP or postal code postal_code: typing.Optional[str] = datafield(default=None) # State, county, province, region. state: typing.Optional[str] = datafield(default=None)
class FundPullPreApprovalCommandObject: _ObjectType: str = datafield( metadata={"valid-values": [CommandType.FundPullPreApprovalCommand]})
class PaymentCommandObject: _ObjectType: str = datafield( metadata={"valid-values": [CommandType.PaymentCommand]}) payment: PaymentObject
def copyfield(data): return datafield(default_factory=lambda: copy.deepcopy(data))