Package-level declarations
The XDR type system: one Kotlin type per definition in the Stellar .x files, plus the readers, writers and extensions that move values between Kotlin, the binary XDR wire format and JSON.
Types in this package are generated from the .x sources and are not edited by hand.
Binary form
encode(writer) and Companion.decode(reader) exist on every type. The commonly exchanged types additionally have toXdrBase64() and Companion.fromXdrBase64(String) extensions, which are the pair to reach for when a value crosses a network or storage boundary.
JSON form (SEP-0051)
Every type also carries four members that convert to and from XDR-JSON, the canonical JSON rendering SEP-0051 defines:
toXdrJson(): String— the canonical document for this value.toXdrJsonElement(): JsonElement— the same document as a tree, for inspecting or building one without a second parse.Companion.fromXdrJson(json: String)— parse and decode a document.Companion.fromXdrJsonElement(element: JsonElement)— decode an already-parsed tree.
The conversion is lossless in both directions and the output is canonical: compact, with object keys in XDR declaration order, so equal values always produce byte-identical documents.
The mapping rules worth knowing before reading a document:
32-bit integers are JSON numbers; 64-bit integers are base-10 JSON strings, because a JSON number cannot carry 64 bits of precision on every platform that reads one. A 64-bit value is also accepted as a number on input.
Opaque data is a lowercase hexadecimal string, empty opaque is
"", and arrays are always present, empty ones as[].A union arm carrying no value is a bare string naming the arm; an arm carrying a value is a single-key object. An unset optional is
nullwith its key still present — which is not the same shape as a void arm.Types with a text form use it: accounts, contracts, pools, claimable balances and signer keys render as strkeys, and the 128-bit and 256-bit integer types render as one decimal string.
Decoding accepts only the spelling encoding produces — lowercase hexadecimal, lowercase \xNN escapes, plain base-10 integer literals — and raises IllegalArgumentException for every malformed input, naming the type and the offending key.
The full mapping table, the documented limitations and the input-strictness rules are in docs/sep/sep-51.md.
Types
XDR Source: union switch (int v) { case 0: void; case 2: AccountEntryExtensionV2 v2; }
XDR Source: struct AccountEntryExtensionV1 { Liabilities liabilities;
XDR Source: union switch (int v) { case 0: void; case 3: AccountEntryExtensionV3 v3; }
XDR Source: struct AccountEntryExtensionV2 { uint32 numSponsored; uint32 numSponsoring; SponsorshipDescriptor signerSponsoringIDs
XDR Source: struct AccountEntryExtensionV3 { // We can use this to add more fields, or because it is first, to // change AccountEntryExtensionV3 into a union. ExtensionPoint ext;
XDR Source: union switch (int v) { case 0: void; case 1: AccountEntryExtensionV1 v1; }
XDR Source: struct AccountEntry { AccountID accountID; // master public key for this account int64 balance; // in stroops SequenceNumber seqNum; // last sequence number used for this account uint32 numSubEntries; // number of sub-entries this account has // drives the reserve AccountID* inflationDest; // Account to vote for during inflation uint32 flags; // see AccountFlags
XDR Source: enum AccountFlags { // masks for each flag
XDR Source: typedef PublicKey AccountID;
XDR Source: enum AccountMergeResultCode { // codes considered as "success" for the operation ACCOUNT_MERGE_SUCCESS = 0, // codes considered as "failure" for the operation ACCOUNT_MERGE_MALFORMED = -1, // can't merge onto itself ACCOUNT_MERGE_NO_ACCOUNT = -2, // destination does not exist ACCOUNT_MERGE_IMMUTABLE_SET = -3, // source account has AUTH_IMMUTABLE set ACCOUNT_MERGE_HAS_SUB_ENTRIES = -4, // account has trust lines/offers ACCOUNT_MERGE_SEQNUM_TOO_FAR = -5, // sequence number is over max allowed ACCOUNT_MERGE_DEST_FULL = -6, // can't add source balance to // destination balance ACCOUNT_MERGE_IS_SPONSOR = -7 // can't merge account that is a sponsor };
XDR Source: union AccountMergeResult switch (AccountMergeResultCode code) { case ACCOUNT_MERGE_SUCCESS: int64 sourceAccountBalance; // how much got transferred from source account case ACCOUNT_MERGE_MALFORMED: case ACCOUNT_MERGE_NO_ACCOUNT: case ACCOUNT_MERGE_IMMUTABLE_SET: case ACCOUNT_MERGE_HAS_SUB_ENTRIES: case ACCOUNT_MERGE_SEQNUM_TOO_FAR: case ACCOUNT_MERGE_DEST_FULL: case ACCOUNT_MERGE_IS_SPONSOR: void; };
XDR Source: struct AllowTrustOp { AccountID trustor; AssetCode asset;
XDR Source: enum AllowTrustResultCode { // codes considered as "success" for the operation ALLOW_TRUST_SUCCESS = 0, // codes considered as "failure" for the operation ALLOW_TRUST_MALFORMED = -1, // asset is not ASSET_TYPE_ALPHANUM ALLOW_TRUST_NO_TRUST_LINE = -2, // trustor does not have a trustline // source account does not require trust ALLOW_TRUST_TRUST_NOT_REQUIRED = -3, ALLOW_TRUST_CANT_REVOKE = -4, // source account can't revoke trust, ALLOW_TRUST_SELF_NOT_ALLOWED = -5, // trusting self is not allowed ALLOW_TRUST_LOW_RESERVE = -6 // claimable balances can't be created // on revoke due to low reserves };
XDR Source: union AllowTrustResult switch (AllowTrustResultCode code) { case ALLOW_TRUST_SUCCESS: void; case ALLOW_TRUST_MALFORMED: case ALLOW_TRUST_NO_TRUST_LINE: case ALLOW_TRUST_TRUST_NOT_REQUIRED: case ALLOW_TRUST_CANT_REVOKE: case ALLOW_TRUST_SELF_NOT_ALLOWED: case ALLOW_TRUST_LOW_RESERVE: void; };
XDR Source: struct AlphaNum12 { AssetCode12 assetCode; AccountID issuer; };
XDR Source: struct AlphaNum4 { AssetCode4 assetCode; AccountID issuer; };
XDR Source: typedef opaque AssetCode1212;
XDR Source: typedef opaque AssetCode44;
XDR Source: union AssetCode switch (AssetType type) { case ASSET_TYPE_CREDIT_ALPHANUM4: AssetCode4 assetCode4;
XDR Source: enum AssetType { ASSET_TYPE_NATIVE = 0, ASSET_TYPE_CREDIT_ALPHANUM4 = 1, ASSET_TYPE_CREDIT_ALPHANUM12 = 2, ASSET_TYPE_POOL_SHARE = 3 };
XDR Source: struct BeginSponsoringFutureReservesOp { AccountID sponsoredID; };
XDR Source: enum BeginSponsoringFutureReservesResultCode { // codes considered as "success" for the operation BEGIN_SPONSORING_FUTURE_RESERVES_SUCCESS = 0,
XDR Source: union BeginSponsoringFutureReservesResult switch ( BeginSponsoringFutureReservesResultCode code) { case BEGIN_SPONSORING_FUTURE_RESERVES_SUCCESS: void; case BEGIN_SPONSORING_FUTURE_RESERVES_MALFORMED: case BEGIN_SPONSORING_FUTURE_RESERVES_ALREADY_SPONSORED: case BEGIN_SPONSORING_FUTURE_RESERVES_RECURSIVE: void; };
XDR Source: enum BinaryFuseFilterType { BINARY_FUSE_FILTER_8_BIT = 0, BINARY_FUSE_FILTER_16_BIT = 1, BINARY_FUSE_FILTER_32_BIT = 2 };
XDR Source: enum BucketEntryType { METAENTRY = -1, // At-and-after protocol 11: bucket metadata, should come first. LIVEENTRY = 0, // Before protocol 11: created-or-updated; // At-and-after protocol 11: only updated. DEADENTRY = 1, INITENTRY = 2 // At-and-after protocol 11: only created. };
XDR Source: union BucketEntry switch (BucketEntryType type) { case LIVEENTRY: case INITENTRY: LedgerEntry liveEntry;
XDR Source: enum BucketListType { LIVE = 0, HOT_ARCHIVE = 1 };
XDR Source: union switch (int v) { case 0: void; case 1: BucketListType bucketListType; }
XDR Source: struct BucketMetadata { // Indicates the protocol version used to create / merge this bucket. uint32 ledgerVersion;
XDR Source: struct BumpSequenceOp { SequenceNumber bumpTo; };
XDR Source: enum BumpSequenceResultCode { // codes considered as "success" for the operation BUMP_SEQUENCE_SUCCESS = 0, // codes considered as "failure" for the operation BUMP_SEQUENCE_BAD_SEQ = -1 // bumpTo is not within bounds };
XDR Source: union BumpSequenceResult switch (BumpSequenceResultCode code) { case BUMP_SEQUENCE_SUCCESS: void; case BUMP_SEQUENCE_BAD_SEQ: void; };
XDR Source: union ChangeTrustAsset switch (AssetType type) { case ASSET_TYPE_NATIVE: // Not credit void;
XDR Source: struct ChangeTrustOp { ChangeTrustAsset line;
XDR Source: enum ChangeTrustResultCode { // codes considered as "success" for the operation CHANGE_TRUST_SUCCESS = 0, // codes considered as "failure" for the operation CHANGE_TRUST_MALFORMED = -1, // bad input CHANGE_TRUST_NO_ISSUER = -2, // could not find issuer CHANGE_TRUST_INVALID_LIMIT = -3, // cannot drop limit below balance // cannot create with a limit of 0 CHANGE_TRUST_LOW_RESERVE = -4, // not enough funds to create a new trust line, CHANGE_TRUST_SELF_NOT_ALLOWED = -5, // trusting self is not allowed CHANGE_TRUST_TRUST_LINE_MISSING = -6, // Asset trustline is missing for pool CHANGE_TRUST_CANNOT_DELETE = -7, // Asset trustline is still referenced in a pool CHANGE_TRUST_NOT_AUTH_MAINTAIN_LIABILITIES = -8 // Asset trustline is deauthorized };
XDR Source: union ChangeTrustResult switch (ChangeTrustResultCode code) { case CHANGE_TRUST_SUCCESS: void; case CHANGE_TRUST_MALFORMED: case CHANGE_TRUST_NO_ISSUER: case CHANGE_TRUST_INVALID_LIMIT: case CHANGE_TRUST_LOW_RESERVE: case CHANGE_TRUST_SELF_NOT_ALLOWED: case CHANGE_TRUST_TRUST_LINE_MISSING: case CHANGE_TRUST_CANNOT_DELETE: case CHANGE_TRUST_NOT_AUTH_MAINTAIN_LIABILITIES: void; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct ClaimableBalanceEntryExtensionV1 { union switch (int v) { case 0: void; } ext;
XDR Source: union switch (int v) { case 0: void; case 1: ClaimableBalanceEntryExtensionV1 v1; }
XDR Source: struct ClaimableBalanceEntry { // Unique identifier for this ClaimableBalanceEntry ClaimableBalanceID balanceID;
XDR Source: enum ClaimableBalanceFlags { // If set, the issuer account of the asset held by the claimable balance may // clawback the claimable balance CLAIMABLE_BALANCE_CLAWBACK_ENABLED_FLAG = 0x1 };
XDR Source: enum ClaimableBalanceIDType { CLAIMABLE_BALANCE_ID_TYPE_V0 = 0 };
XDR Source: union ClaimableBalanceID switch (ClaimableBalanceIDType type) { case CLAIMABLE_BALANCE_ID_TYPE_V0: Hash v0; };
XDR Source: enum ClaimantType { CLAIMANT_TYPE_V0 = 0 };
XDR Source: struct { AccountID destination; // The account that can use this condition ClaimPredicate predicate; // Claimable if predicate is true }
XDR Source: union Claimant switch (ClaimantType type) { case CLAIMANT_TYPE_V0: struct { AccountID destination; // The account that can use this condition ClaimPredicate predicate; // Claimable if predicate is true } v0; };
XDR Source: enum ClaimAtomType { CLAIM_ATOM_TYPE_V0 = 0, CLAIM_ATOM_TYPE_ORDER_BOOK = 1, CLAIM_ATOM_TYPE_LIQUIDITY_POOL = 2 };
XDR Source: union ClaimAtom switch (ClaimAtomType type) { case CLAIM_ATOM_TYPE_V0: ClaimOfferAtomV0 v0; case CLAIM_ATOM_TYPE_ORDER_BOOK: ClaimOfferAtom orderBook; case CLAIM_ATOM_TYPE_LIQUIDITY_POOL: ClaimLiquidityAtom liquidityPool; };
XDR Source: struct ClaimClaimableBalanceOp { ClaimableBalanceID balanceID; };
XDR Source: enum ClaimClaimableBalanceResultCode { CLAIM_CLAIMABLE_BALANCE_SUCCESS = 0, CLAIM_CLAIMABLE_BALANCE_DOES_NOT_EXIST = -1, CLAIM_CLAIMABLE_BALANCE_CANNOT_CLAIM = -2, CLAIM_CLAIMABLE_BALANCE_LINE_FULL = -3, CLAIM_CLAIMABLE_BALANCE_NO_TRUST = -4, CLAIM_CLAIMABLE_BALANCE_NOT_AUTHORIZED = -5, CLAIM_CLAIMABLE_BALANCE_TRUSTLINE_FROZEN = -6 };
XDR Source: union ClaimClaimableBalanceResult switch (ClaimClaimableBalanceResultCode code) { case CLAIM_CLAIMABLE_BALANCE_SUCCESS: void; case CLAIM_CLAIMABLE_BALANCE_DOES_NOT_EXIST: case CLAIM_CLAIMABLE_BALANCE_CANNOT_CLAIM: case CLAIM_CLAIMABLE_BALANCE_LINE_FULL: case CLAIM_CLAIMABLE_BALANCE_NO_TRUST: case CLAIM_CLAIMABLE_BALANCE_NOT_AUTHORIZED: case CLAIM_CLAIMABLE_BALANCE_TRUSTLINE_FROZEN: void; };
XDR Source: struct ClaimOfferAtomV0 { // emitted to identify the offer uint256 sellerEd25519; // Account that owns the offer int64 offerID;
XDR Source: struct ClaimOfferAtom { // emitted to identify the offer AccountID sellerID; // Account that owns the offer int64 offerID;
XDR Source: enum ClaimPredicateType { CLAIM_PREDICATE_UNCONDITIONAL = 0, CLAIM_PREDICATE_AND = 1, CLAIM_PREDICATE_OR = 2, CLAIM_PREDICATE_NOT = 3, CLAIM_PREDICATE_BEFORE_ABSOLUTE_TIME = 4, CLAIM_PREDICATE_BEFORE_RELATIVE_TIME = 5 };
XDR Source: union ClaimPredicate switch (ClaimPredicateType type) { case CLAIM_PREDICATE_UNCONDITIONAL: void; case CLAIM_PREDICATE_AND: ClaimPredicate andPredicates<2>; case CLAIM_PREDICATE_OR: ClaimPredicate orPredicates<2>; case CLAIM_PREDICATE_NOT: ClaimPredicate* notPredicate; case CLAIM_PREDICATE_BEFORE_ABSOLUTE_TIME: int64 absBefore; // Predicate will be true if closeTime < absBefore case CLAIM_PREDICATE_BEFORE_RELATIVE_TIME: int64 relBefore; // Seconds since closeTime of the ledger in which the // ClaimableBalanceEntry was created };
XDR Source: struct ClawbackClaimableBalanceOp { ClaimableBalanceID balanceID; };
XDR Source: enum ClawbackClaimableBalanceResultCode { // codes considered as "success" for the operation CLAWBACK_CLAIMABLE_BALANCE_SUCCESS = 0,
XDR Source: union ClawbackClaimableBalanceResult switch ( ClawbackClaimableBalanceResultCode code) { case CLAWBACK_CLAIMABLE_BALANCE_SUCCESS: void; case CLAWBACK_CLAIMABLE_BALANCE_DOES_NOT_EXIST: case CLAWBACK_CLAIMABLE_BALANCE_NOT_ISSUER: case CLAWBACK_CLAIMABLE_BALANCE_NOT_CLAWBACK_ENABLED: void; };
XDR Source: struct ClawbackOp { Asset asset; MuxedAccount from; int64 amount; };
XDR Source: enum ClawbackResultCode { // codes considered as "success" for the operation CLAWBACK_SUCCESS = 0,
XDR Source: union ClawbackResult switch (ClawbackResultCode code) { case CLAWBACK_SUCCESS: void; case CLAWBACK_MALFORMED: case CLAWBACK_NOT_CLAWBACK_ENABLED: case CLAWBACK_NO_TRUST: case CLAWBACK_UNDERFUNDED: void; };
XDR Source: struct ConfigSettingContractBandwidthV0 { // Maximum sum of all transaction sizes in the ledger in bytes uint32 ledgerMaxTxsSizeBytes; // Maximum size in bytes for a transaction uint32 txMaxSizeBytes;
XDR Source: struct ConfigSettingContractComputeV0 { // Maximum instructions per ledger int64 ledgerMaxInstructions; // Maximum instructions per transaction int64 txMaxInstructions; // Cost of 10000 instructions int64 feeRatePerInstructionsIncrement;
XDR Source: struct ConfigSettingContractEventsV0 { // Maximum size of events that a contract call can emit. uint32 txMaxContractEventsSizeBytes; // Fee for generating 1KB of contract events. int64 feeContractEvents1KB; };
XDR Source: struct ConfigSettingContractExecutionLanesV0 { // maximum number of Soroban transactions per ledger uint32 ledgerMaxTxCount; };
XDR Source: struct ConfigSettingContractHistoricalDataV0 { int64 feeHistorical1KB; // Fee for storing 1KB in archives };
XDR Source: struct ConfigSettingContractLedgerCostExtV0 { // Maximum number of RO+RW entries in the transaction footprint. uint32 txMaxFootprintEntries; // Fee per 1 KB of data written to the ledger. // Unlike the rent fee, this is a flat fee that is charged for any ledger // write, independent of the type of the entry being written. int64 feeWrite1KB; };
XDR Source: struct ConfigSettingContractLedgerCostV0 { // Maximum number of disk entry read operations per ledger uint32 ledgerMaxDiskReadEntries; // Maximum number of bytes of disk reads that can be performed per ledger uint32 ledgerMaxDiskReadBytes; // Maximum number of ledger entry write operations per ledger uint32 ledgerMaxWriteLedgerEntries; // Maximum number of bytes that can be written per ledger uint32 ledgerMaxWriteBytes;
XDR Source: struct ConfigSettingContractParallelComputeV0 { // Maximum number of clusters with dependent transactions allowed in a // stage of parallel tx set component. // This effectively sets the lower bound on the number of physical threads // necessary to effectively apply transaction sets in parallel. uint32 ledgerMaxDependentTxClusters; };
XDR Source: union ConfigSettingEntry switch (ConfigSettingID configSettingID) { case CONFIG_SETTING_CONTRACT_MAX_SIZE_BYTES: uint32 contractMaxSizeBytes; case CONFIG_SETTING_CONTRACT_COMPUTE_V0: ConfigSettingContractComputeV0 contractCompute; case CONFIG_SETTING_CONTRACT_LEDGER_COST_V0: ConfigSettingContractLedgerCostV0 contractLedgerCost; case CONFIG_SETTING_CONTRACT_HISTORICAL_DATA_V0: ConfigSettingContractHistoricalDataV0 contractHistoricalData; case CONFIG_SETTING_CONTRACT_EVENTS_V0: ConfigSettingContractEventsV0 contractEvents; case CONFIG_SETTING_CONTRACT_BANDWIDTH_V0: ConfigSettingContractBandwidthV0 contractBandwidth; case CONFIG_SETTING_CONTRACT_COST_PARAMS_CPU_INSTRUCTIONS: ContractCostParams contractCostParamsCpuInsns; case CONFIG_SETTING_CONTRACT_COST_PARAMS_MEMORY_BYTES: ContractCostParams contractCostParamsMemBytes; case CONFIG_SETTING_CONTRACT_DATA_KEY_SIZE_BYTES: uint32 contractDataKeySizeBytes; case CONFIG_SETTING_CONTRACT_DATA_ENTRY_SIZE_BYTES: uint32 contractDataEntrySizeBytes; case CONFIG_SETTING_STATE_ARCHIVAL: StateArchivalSettings stateArchivalSettings; case CONFIG_SETTING_CONTRACT_EXECUTION_LANES: ConfigSettingContractExecutionLanesV0 contractExecutionLanes; case CONFIG_SETTING_LIVE_SOROBAN_STATE_SIZE_WINDOW: uint64 liveSorobanStateSizeWindow<>; case CONFIG_SETTING_EVICTION_ITERATOR: EvictionIterator evictionIterator; case CONFIG_SETTING_CONTRACT_PARALLEL_COMPUTE_V0: ConfigSettingContractParallelComputeV0 contractParallelCompute; case CONFIG_SETTING_CONTRACT_LEDGER_COST_EXT_V0: ConfigSettingContractLedgerCostExtV0 contractLedgerCostExt; case CONFIG_SETTING_SCP_TIMING: ConfigSettingSCPTiming contractSCPTiming; case CONFIG_SETTING_FROZEN_LEDGER_KEYS: FrozenLedgerKeys frozenLedgerKeys; case CONFIG_SETTING_FROZEN_LEDGER_KEYS_DELTA: FrozenLedgerKeysDelta frozenLedgerKeysDelta; case CONFIG_SETTING_FREEZE_BYPASS_TXS: FreezeBypassTxs freezeBypassTxs; case CONFIG_SETTING_FREEZE_BYPASS_TXS_DELTA: FreezeBypassTxsDelta freezeBypassTxsDelta; };
XDR Source: enum ConfigSettingID { CONFIG_SETTING_CONTRACT_MAX_SIZE_BYTES = 0, CONFIG_SETTING_CONTRACT_COMPUTE_V0 = 1, CONFIG_SETTING_CONTRACT_LEDGER_COST_V0 = 2, CONFIG_SETTING_CONTRACT_HISTORICAL_DATA_V0 = 3, CONFIG_SETTING_CONTRACT_EVENTS_V0 = 4, CONFIG_SETTING_CONTRACT_BANDWIDTH_V0 = 5, CONFIG_SETTING_CONTRACT_COST_PARAMS_CPU_INSTRUCTIONS = 6, CONFIG_SETTING_CONTRACT_COST_PARAMS_MEMORY_BYTES = 7, CONFIG_SETTING_CONTRACT_DATA_KEY_SIZE_BYTES = 8, CONFIG_SETTING_CONTRACT_DATA_ENTRY_SIZE_BYTES = 9, CONFIG_SETTING_STATE_ARCHIVAL = 10, CONFIG_SETTING_CONTRACT_EXECUTION_LANES = 11, CONFIG_SETTING_LIVE_SOROBAN_STATE_SIZE_WINDOW = 12, CONFIG_SETTING_EVICTION_ITERATOR = 13, CONFIG_SETTING_CONTRACT_PARALLEL_COMPUTE_V0 = 14, CONFIG_SETTING_CONTRACT_LEDGER_COST_EXT_V0 = 15, CONFIG_SETTING_SCP_TIMING = 16, CONFIG_SETTING_FROZEN_LEDGER_KEYS = 17, CONFIG_SETTING_FROZEN_LEDGER_KEYS_DELTA = 18, CONFIG_SETTING_FREEZE_BYPASS_TXS = 19, CONFIG_SETTING_FREEZE_BYPASS_TXS_DELTA = 20 };
XDR Source: struct ConfigSettingSCPTiming { uint32 ledgerTargetCloseTimeMilliseconds; uint32 nominationTimeoutInitialMilliseconds; uint32 nominationTimeoutIncrementMilliseconds; uint32 ballotTimeoutInitialMilliseconds; uint32 ballotTimeoutIncrementMilliseconds; };
XDR Source: struct ConfigUpgradeSetKey { ContractID contractID; Hash contentHash; };
XDR Source: struct ConfigUpgradeSet { ConfigSettingEntry updatedEntry<>; };
XDR Source: struct ContractCodeCostInputs { ExtensionPoint ext; uint32 nInstructions; uint32 nFunctions; uint32 nGlobals; uint32 nTableEntries; uint32 nTypes; uint32 nDataSegments; uint32 nElemSegments; uint32 nImports; uint32 nExports; uint32 nDataSegmentBytes; };
XDR Source: union switch (int v) { case 0: void; case 1: struct { ExtensionPoint ext; ContractCodeCostInputs costInputs; } v1; }
XDR Source: struct { ExtensionPoint ext; ContractCodeCostInputs costInputs; }
XDR Source: struct ContractCodeEntry { union switch (int v) { case 0: void; case 1: struct { ExtensionPoint ext; ContractCodeCostInputs costInputs; } v1; } ext;
XDR Source: struct ContractCostParamEntry { // use ext to add more terms (e.g. higher order polynomials) in the future ExtensionPoint ext;
XDR Source: typedef ContractCostParamEntry ContractCostParams
XDR Source: enum ContractCostType { // Cost of running 1 wasm instruction WasmInsnExec = 0, // Cost of allocating a slice of memory (in bytes) MemAlloc = 1, // Cost of copying a slice of bytes into a pre-allocated memory MemCpy = 2, // Cost of comparing two slices of memory MemCmp = 3, // Cost of a host function dispatch, not including the actual work done by // the function nor the cost of VM invocation machinary DispatchHostFunction = 4, // Cost of visiting a host object from the host object storage. Exists to // make sure some baseline cost coverage, i.e. repeatly visiting objects // by the guest will always incur some charges. VisitObject = 5, // Cost of serializing an xdr object to bytes ValSer = 6, // Cost of deserializing an xdr object from bytes ValDeser = 7, // Cost of computing the sha256 hash from bytes ComputeSha256Hash = 8, // Cost of computing the ed25519 pubkey from bytes ComputeEd25519PubKey = 9, // Cost of verifying ed25519 signature of a payload. VerifyEd25519Sig = 10, // Cost of instantiation a VM from wasm bytes code. VmInstantiation = 11, // Cost of instantiation a VM from a cached state. VmCachedInstantiation = 12, // Cost of invoking a function on the VM. If the function is a host function, // additional cost will be covered by DispatchHostFunction. InvokeVmFunction = 13, // Cost of computing a keccak256 hash from bytes. ComputeKeccak256Hash = 14, // Cost of decoding an ECDSA signature computed from a 256-bit prime modulus // curve (e.g. secp256k1 and secp256r1) DecodeEcdsaCurve256Sig = 15, // Cost of recovering an ECDSA secp256k1 key from a signature. RecoverEcdsaSecp256k1Key = 16, // Cost of int256 addition (+) and subtraction (-) operations Int256AddSub = 17, // Cost of int256 multiplication (*) operation Int256Mul = 18, // Cost of int256 division (/) operation Int256Div = 19, // Cost of int256 power (exp) operation Int256Pow = 20, // Cost of int256 shift (shl, shr) operation Int256Shift = 21, // Cost of drawing random bytes using a ChaCha20 PRNG ChaCha20DrawBytes = 22,
XDR Source: enum ContractDataDurability { TEMPORARY = 0, PERSISTENT = 1 };
XDR Source: struct ContractDataEntry { ExtensionPoint ext;
XDR Source: union switch (int v) { case 0: struct { SCVal topics<>; SCVal data; } v0; }
XDR Source: enum ContractEventType { SYSTEM = 0, CONTRACT = 1, DIAGNOSTIC = 2 };
XDR Source: struct { SCVal topics<>; SCVal data; }
XDR Source: struct ContractEvent { // We can use this to add more fields, or because it // is first, to change ContractEvent into a union. ExtensionPoint ext;
XDR Source: struct ContractExecutableExternalRef { SCAddress executable_owner; SCString tag; };
XDR Source: enum ContractExecutableType { CONTRACT_EXECUTABLE_WASM = 0, CONTRACT_EXECUTABLE_STELLAR_ASSET = 1, CONTRACT_EXECUTABLE_EXTERNAL_REF = 2 };
XDR Source: union ContractExecutable switch (ContractExecutableType type) { case CONTRACT_EXECUTABLE_WASM: Hash wasm_hash; case CONTRACT_EXECUTABLE_STELLAR_ASSET: void; case CONTRACT_EXECUTABLE_EXTERNAL_REF: ContractExecutableExternalRef external_ref; };
XDR Source: struct { SCAddress address; uint256 salt; }
XDR Source: enum ContractIDPreimageType { CONTRACT_ID_PREIMAGE_FROM_ADDRESS = 0, CONTRACT_ID_PREIMAGE_FROM_ASSET = 1 };
XDR Source: union ContractIDPreimage switch (ContractIDPreimageType type) { case CONTRACT_ID_PREIMAGE_FROM_ADDRESS: struct { SCAddress address; uint256 salt; } fromAddress; case CONTRACT_ID_PREIMAGE_FROM_ASSET: Asset fromAsset; };
XDR Source: typedef Hash ContractID;
XDR Source: struct CreateAccountOp { AccountID destination; // account to create int64 startingBalance; // amount they end up with };
XDR Source: enum CreateAccountResultCode { // codes considered as "success" for the operation CREATE_ACCOUNT_SUCCESS = 0, // account was created
XDR Source: union CreateAccountResult switch (CreateAccountResultCode code) { case CREATE_ACCOUNT_SUCCESS: void; case CREATE_ACCOUNT_MALFORMED: case CREATE_ACCOUNT_UNDERFUNDED: case CREATE_ACCOUNT_LOW_RESERVE: case CREATE_ACCOUNT_ALREADY_EXIST: void; };
XDR Source: struct CreateClaimableBalanceOp { Asset asset; int64 amount; Claimant claimants<10>; };
XDR Source: enum CreateClaimableBalanceResultCode { CREATE_CLAIMABLE_BALANCE_SUCCESS = 0, CREATE_CLAIMABLE_BALANCE_MALFORMED = -1, CREATE_CLAIMABLE_BALANCE_LOW_RESERVE = -2, CREATE_CLAIMABLE_BALANCE_NO_TRUST = -3, CREATE_CLAIMABLE_BALANCE_NOT_AUTHORIZED = -4, CREATE_CLAIMABLE_BALANCE_UNDERFUNDED = -5 };
XDR Source: union CreateClaimableBalanceResult switch ( CreateClaimableBalanceResultCode code) { case CREATE_CLAIMABLE_BALANCE_SUCCESS: ClaimableBalanceID balanceID; case CREATE_CLAIMABLE_BALANCE_MALFORMED: case CREATE_CLAIMABLE_BALANCE_LOW_RESERVE: case CREATE_CLAIMABLE_BALANCE_NO_TRUST: case CREATE_CLAIMABLE_BALANCE_NOT_AUTHORIZED: case CREATE_CLAIMABLE_BALANCE_UNDERFUNDED: void; };
XDR Source: struct CreateContractArgsV2 { ContractIDPreimage contractIDPreimage; ContractExecutable executable; // Arguments of the contract's constructor. SCVal constructorArgs<>; };
XDR Source: struct CreateContractArgs { ContractIDPreimage contractIDPreimage; ContractExecutable executable; };
XDR Source: struct CreatePassiveSellOfferOp { Asset selling; // A Asset buying; // B int64 amount; // amount taker gets Price price; // cost of A in terms of B };
XDR Source: enum CryptoKeyType { KEY_TYPE_ED25519 = 0, KEY_TYPE_PRE_AUTH_TX = 1, KEY_TYPE_HASH_X = 2, KEY_TYPE_ED25519_SIGNED_PAYLOAD = 3, // MUXED enum values for supported type are derived from the enum values // above by ORing them with 0x100 KEY_TYPE_MUXED_ED25519 = 0x100 };
XDR Source: struct Curve25519Public { opaque key32; };
XDR Source: struct Curve25519Secret { opaque key32; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct DataEntry { AccountID accountID; // account this data belongs to string64 dataName; DataValue dataValue;
XDR Source: typedef opaque DataValue<64>;
XDR Source: struct DecoratedSignature { SignatureHint hint; // last 4 bytes of the public key, used as a hint Signature signature; // actual signature };
XDR Source: typedef TransactionEnvelope DependentTxCluster<>;
XDR Source: struct DiagnosticEvent { bool inSuccessfulContractCall; ContractEvent event; };
XDR Source: typedef uint64 Duration;
XDR Source: typedef opaque EncodedLedgerKey<>;
XDR Source: enum EndSponsoringFutureReservesResultCode { // codes considered as "success" for the operation END_SPONSORING_FUTURE_RESERVES_SUCCESS = 0,
XDR Source: union EndSponsoringFutureReservesResult switch ( EndSponsoringFutureReservesResultCode code) { case END_SPONSORING_FUTURE_RESERVES_SUCCESS: void; case END_SPONSORING_FUTURE_RESERVES_NOT_SPONSORED: void; };
XDR Source: enum EnvelopeType { ENVELOPE_TYPE_TX_V0 = 0, ENVELOPE_TYPE_SCP = 1, ENVELOPE_TYPE_TX = 2, ENVELOPE_TYPE_AUTH = 3, ENVELOPE_TYPE_SCPVALUE = 4, ENVELOPE_TYPE_TX_FEE_BUMP = 5, ENVELOPE_TYPE_OP_ID = 6, ENVELOPE_TYPE_POOL_REVOKE_OP_ID = 7, ENVELOPE_TYPE_CONTRACT_ID = 8, ENVELOPE_TYPE_SOROBAN_AUTHORIZATION = 9, ENVELOPE_TYPE_SOROBAN_AUTHORIZATION_WITH_ADDRESS = 10 };
XDR Source: struct EvictionIterator { uint32 bucketListLevel; bool isCurrBucket; uint64 bucketFileOffset; };
XDR Source: struct ExtendFootprintTTLOp { ExtensionPoint ext; uint32 extendTo; };
XDR Source: enum ExtendFootprintTTLResultCode { // codes considered as "success" for the operation EXTEND_FOOTPRINT_TTL_SUCCESS = 0,
XDR Source: union ExtendFootprintTTLResult switch (ExtendFootprintTTLResultCode code) { case EXTEND_FOOTPRINT_TTL_SUCCESS: void; case EXTEND_FOOTPRINT_TTL_MALFORMED: case EXTEND_FOOTPRINT_TTL_RESOURCE_LIMIT_EXCEEDED: case EXTEND_FOOTPRINT_TTL_INSUFFICIENT_REFUNDABLE_FEE: void; };
XDR Source: union ExtensionPoint switch (int v) { case 0: void; };
XDR Source: struct FeeBumpTransactionEnvelope { FeeBumpTransaction tx; /* Each decorated signature is a signature over the SHA256 hash of * a TransactionSignaturePayload */ DecoratedSignature signatures<20>; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: union switch (EnvelopeType type) { case ENVELOPE_TYPE_TX: TransactionV1Envelope v1; }
XDR Source: struct FeeBumpTransaction { MuxedAccount feeSource; int64 fee; union switch (EnvelopeType type) { case ENVELOPE_TYPE_TX: TransactionV1Envelope v1; } innerTx; union switch (int v) { case 0: void; } ext; };
XDR Source: struct FreezeBypassTxsDelta { Hash addTxs<>; Hash removeTxs<>; };
XDR Source: struct FreezeBypassTxs { Hash txHashes<>; };
XDR Source: struct FrozenLedgerKeysDelta { EncodedLedgerKey keysToFreeze<>; EncodedLedgerKey keysToUnfreeze<>; };
XDR Source: struct FrozenLedgerKeys { EncodedLedgerKey keys<>; };
XDR Source: union GeneralizedTransactionSet switch (int v) { // We consider the legacy TransactionSet to be v0. case 1: TransactionSetV1 v1TxSet; };
XDR Source: struct { Hash networkID; ContractIDPreimage contractIDPreimage; }
XDR Source: struct { AccountID sourceAccount; SequenceNumber seqNum; uint32 opNum; }
XDR Source: struct { AccountID sourceAccount; SequenceNumber seqNum; uint32 opNum; PoolID liquidityPoolID; Asset asset; }
XDR Source: struct { Hash networkID; int64 nonce; uint32 signatureExpirationLedger; SCAddress address; SorobanAuthorizedInvocation invocation; }
XDR Source: struct { Hash networkID; int64 nonce; uint32 signatureExpirationLedger; SorobanAuthorizedInvocation invocation; }
XDR Source: union HashIDPreimage switch (EnvelopeType type) { case ENVELOPE_TYPE_OP_ID: struct { AccountID sourceAccount; SequenceNumber seqNum; uint32 opNum; } operationID; case ENVELOPE_TYPE_POOL_REVOKE_OP_ID: struct { AccountID sourceAccount; SequenceNumber seqNum; uint32 opNum; PoolID liquidityPoolID; Asset asset; } revokeID; case ENVELOPE_TYPE_CONTRACT_ID: struct { Hash networkID; ContractIDPreimage contractIDPreimage; } contractID; case ENVELOPE_TYPE_SOROBAN_AUTHORIZATION: struct { Hash networkID; int64 nonce; uint32 signatureExpirationLedger; SorobanAuthorizedInvocation invocation; } sorobanAuthorization; case ENVELOPE_TYPE_SOROBAN_AUTHORIZATION_WITH_ADDRESS: struct { Hash networkID; int64 nonce; uint32 signatureExpirationLedger; SCAddress address; SorobanAuthorizedInvocation invocation; } sorobanAuthorizationWithAddress; };
XDR Source: struct HmacSha256Key { opaque key32; };
XDR Source: struct HmacSha256Mac { opaque mac32; };
XDR Source: enum HostFunctionType { HOST_FUNCTION_TYPE_INVOKE_CONTRACT = 0, HOST_FUNCTION_TYPE_CREATE_CONTRACT = 1, HOST_FUNCTION_TYPE_UPLOAD_CONTRACT_WASM = 2, HOST_FUNCTION_TYPE_CREATE_CONTRACT_V2 = 3 };
XDR Source: union HostFunction switch (HostFunctionType type) { case HOST_FUNCTION_TYPE_INVOKE_CONTRACT: InvokeContractArgs invokeContract; case HOST_FUNCTION_TYPE_CREATE_CONTRACT: CreateContractArgs createContract; case HOST_FUNCTION_TYPE_UPLOAD_CONTRACT_WASM: opaque wasm<>; case HOST_FUNCTION_TYPE_CREATE_CONTRACT_V2: CreateContractArgsV2 createContractV2; };
XDR Source: enum HotArchiveBucketEntryType { HOT_ARCHIVE_METAENTRY = -1, // Bucket metadata, should come first. HOT_ARCHIVE_ARCHIVED = 0, // Entry is Archived HOT_ARCHIVE_LIVE = 1 // Entry was previously HOT_ARCHIVE_ARCHIVED, but // has been added back to the live BucketList. // Does not need to be persisted. };
XDR Source: union HotArchiveBucketEntry switch (HotArchiveBucketEntryType type) { case HOT_ARCHIVE_ARCHIVED: LedgerEntry archivedEntry;
XDR Source: struct InflationPayout // or use PaymentResultAtom to limit types? { AccountID destination; int64 amount; };
XDR Source: enum InflationResultCode { // codes considered as "success" for the operation INFLATION_SUCCESS = 0, // codes considered as "failure" for the operation INFLATION_NOT_TIME = -1 };
XDR Source: union InflationResult switch (InflationResultCode code) { case INFLATION_SUCCESS: InflationPayout payouts<>; case INFLATION_NOT_TIME: void; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct InnerTransactionResultPair { Hash transactionHash; // hash of the inner transaction InnerTransactionResult result; // result for the inner transaction };
XDR Source: union switch (TransactionResultCode code) { // txFEE_BUMP_INNER_SUCCESS is not included case txSUCCESS: case txFAILED: OperationResult results<>; case txTOO_EARLY: case txTOO_LATE: case txMISSING_OPERATION: case txBAD_SEQ: case txBAD_AUTH: case txINSUFFICIENT_BALANCE: case txNO_ACCOUNT: case txINSUFFICIENT_FEE: case txBAD_AUTH_EXTRA: case txINTERNAL_ERROR: case txNOT_SUPPORTED: // txFEE_BUMP_INNER_FAILED is not included case txBAD_SPONSORSHIP: case txBAD_MIN_SEQ_AGE_OR_GAP: case txMALFORMED: case txSOROBAN_INVALID: case txFROZEN_KEY_ACCESSED: void; }
XDR Source: struct InnerTransactionResult { // Always 0. Here for binary compatibility. int64 feeCharged;
XDR Source: struct Int128Parts { int64 hi; uint64 lo; };
XDR Source: struct Int256Parts { int64 hi_hi; uint64 hi_lo; uint64 lo_hi; uint64 lo_lo; };
XDR Source: struct InvokeContractArgs { SCAddress contractAddress; SCSymbol functionName; SCVal args<>; };
XDR Source: struct InvokeHostFunctionOp { // Host function to invoke. HostFunction hostFunction; // Per-address authorizations for this host function. SorobanAuthorizationEntry auth<>; };
XDR Source: enum InvokeHostFunctionResultCode { // codes considered as "success" for the operation INVOKE_HOST_FUNCTION_SUCCESS = 0,
XDR Source: union InvokeHostFunctionResult switch (InvokeHostFunctionResultCode code) { case INVOKE_HOST_FUNCTION_SUCCESS: Hash success; // sha256(InvokeHostFunctionSuccessPreImage) case INVOKE_HOST_FUNCTION_MALFORMED: case INVOKE_HOST_FUNCTION_TRAPPED: case INVOKE_HOST_FUNCTION_RESOURCE_LIMIT_EXCEEDED: case INVOKE_HOST_FUNCTION_ENTRY_ARCHIVED: case INVOKE_HOST_FUNCTION_INSUFFICIENT_REFUNDABLE_FEE: void; };
XDR Source: struct InvokeHostFunctionSuccessPreImage { SCVal returnValue; ContractEvent events<>; };
XDR Source: struct LedgerBounds { uint32 minLedger; uint32 maxLedger; // 0 here means no maxLedger };
XDR Source: struct LedgerCloseMetaExtV1 { ExtensionPoint ext; int64 sorobanFeeWrite1KB; };
XDR Source: union LedgerCloseMetaExt switch (int v) { case 0: void; case 1: LedgerCloseMetaExtV1 v1; };
XDR Source: struct LedgerCloseMetaV0 { LedgerHeaderHistoryEntry ledgerHeader; // NB: txSet is sorted in "Hash order" TransactionSet txSet;
XDR Source: struct LedgerCloseMetaV1 { LedgerCloseMetaExt ext;
XDR Source: struct LedgerCloseMetaV2 { LedgerCloseMetaExt ext;
XDR Source: union LedgerCloseMeta switch (int v) { case 0: LedgerCloseMetaV0 v0; case 1: LedgerCloseMetaV1 v1; case 2: LedgerCloseMetaV2 v2; };
XDR Source: struct LedgerCloseValueSignature { NodeID nodeID; // which node introduced the value Signature signature; // nodeID's signature };
XDR Source: typedef LedgerEntryChange LedgerEntryChanges<>;
XDR Source: enum LedgerEntryChangeType { LEDGER_ENTRY_CREATED = 0, // entry was added to the ledger LEDGER_ENTRY_UPDATED = 1, // entry was modified in the ledger LEDGER_ENTRY_REMOVED = 2, // entry was removed from the ledger LEDGER_ENTRY_STATE = 3, // value of the entry LEDGER_ENTRY_RESTORED = 4 // archived entry was restored in the ledger };
XDR Source: union LedgerEntryChange switch (LedgerEntryChangeType type) { case LEDGER_ENTRY_CREATED: LedgerEntry created; case LEDGER_ENTRY_UPDATED: LedgerEntry updated; case LEDGER_ENTRY_REMOVED: LedgerKey removed; case LEDGER_ENTRY_STATE: LedgerEntry state; case LEDGER_ENTRY_RESTORED: LedgerEntry restored; };
XDR Source: union switch (LedgerEntryType type) { case ACCOUNT: AccountEntry account; case TRUSTLINE: TrustLineEntry trustLine; case OFFER: OfferEntry offer; case DATA: DataEntry data; case CLAIMABLE_BALANCE: ClaimableBalanceEntry claimableBalance; case LIQUIDITY_POOL: LiquidityPoolEntry liquidityPool; case CONTRACT_DATA: ContractDataEntry contractData; case CONTRACT_CODE: ContractCodeEntry contractCode; case CONFIG_SETTING: ConfigSettingEntry configSetting; case TTL: TTLEntry ttl; }
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct LedgerEntryExtensionV1 { SponsorshipDescriptor sponsoringID;
XDR Source: union switch (int v) { case 0: void; case 1: LedgerEntryExtensionV1 v1; }
XDR Source: enum LedgerEntryType { ACCOUNT = 0, TRUSTLINE = 1, OFFER = 2, DATA = 3, CLAIMABLE_BALANCE = 4, LIQUIDITY_POOL = 5, CONTRACT_DATA = 6, CONTRACT_CODE = 7, CONFIG_SETTING = 8, TTL = 9 };
XDR Source: struct LedgerEntry { uint32 lastModifiedLedgerSeq; // ledger the LedgerEntry was last changed
XDR Source: struct LedgerFootprint { LedgerKey readOnly<>; LedgerKey readWrite<>; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct LedgerHeaderExtensionV1 { uint32 flags; // LedgerHeaderFlags
XDR Source: union switch (int v) { case 0: void; case 1: LedgerHeaderExtensionV1 v1; }
XDR Source: enum LedgerHeaderFlags { DISABLE_LIQUIDITY_POOL_TRADING_FLAG = 0x1, DISABLE_LIQUIDITY_POOL_DEPOSIT_FLAG = 0x2, DISABLE_LIQUIDITY_POOL_WITHDRAWAL_FLAG = 0x4 };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct LedgerHeaderHistoryEntry { Hash hash; LedgerHeader header;
XDR Source: struct LedgerHeader { uint32 ledgerVersion; // the protocol version of the ledger Hash previousLedgerHash; // hash of the previous ledger header StellarValue scpValue; // what consensus agreed to Hash txSetResultHash; // the TransactionResultSet that led to this ledger Hash bucketListHash; // hash of the ledger state
XDR Source: struct { AccountID accountID; }
XDR Source: struct { ClaimableBalanceID balanceID; }
XDR Source: struct { ConfigSettingID configSettingID; }
XDR Source: struct { Hash hash; }
XDR Source: struct { SCAddress contract; SCVal key; ContractDataDurability durability; }
XDR Source: struct { AccountID accountID; string64 dataName; }
XDR Source: struct { PoolID liquidityPoolID; }
XDR Source: struct { AccountID sellerID; int64 offerID; }
XDR Source: struct { AccountID accountID; TrustLineAsset asset; }
XDR Source: struct { // Hash of the LedgerKey that is associated with this TTLEntry Hash keyHash; }
XDR Source: union LedgerKey switch (LedgerEntryType type) { case ACCOUNT: struct { AccountID accountID; } account;
XDR Source: struct LedgerSCPMessages { uint32 ledgerSeq; SCPEnvelope messages<>; };
XDR Source: enum LedgerUpgradeType { LEDGER_UPGRADE_VERSION = 1, LEDGER_UPGRADE_BASE_FEE = 2, LEDGER_UPGRADE_MAX_TX_SET_SIZE = 3, LEDGER_UPGRADE_BASE_RESERVE = 4, LEDGER_UPGRADE_FLAGS = 5, LEDGER_UPGRADE_CONFIG = 6, LEDGER_UPGRADE_MAX_SOROBAN_TX_SET_SIZE = 7 };
XDR Source: union LedgerUpgrade switch (LedgerUpgradeType type) { case LEDGER_UPGRADE_VERSION: uint32 newLedgerVersion; // update ledgerVersion case LEDGER_UPGRADE_BASE_FEE: uint32 newBaseFee; // update baseFee case LEDGER_UPGRADE_MAX_TX_SET_SIZE: uint32 newMaxTxSetSize; // update maxTxSetSize case LEDGER_UPGRADE_BASE_RESERVE: uint32 newBaseReserve; // update baseReserve case LEDGER_UPGRADE_FLAGS: uint32 newFlags; // update flags case LEDGER_UPGRADE_CONFIG: // Update arbitrary ConfigSetting entries identified by the key. ConfigUpgradeSetKey newConfig; case LEDGER_UPGRADE_MAX_SOROBAN_TX_SET_SIZE: // Update ConfigSettingContractExecutionLanesV0.ledgerMaxTxCount without // using LEDGER_UPGRADE_CONFIG. uint32 newMaxSorobanTxSetSize; };
XDR Source: struct Liabilities { int64 buying; int64 selling; };
XDR Source: struct LiquidityPoolConstantProductParameters { Asset assetA; // assetA < assetB Asset assetB; int32 fee; // Fee is in basis points, so the actual rate is (fee/100)% };
XDR Source: struct LiquidityPoolDepositOp { PoolID liquidityPoolID; int64 maxAmountA; // maximum amount of first asset to deposit int64 maxAmountB; // maximum amount of second asset to deposit Price minPrice; // minimum depositA/depositB Price maxPrice; // maximum depositA/depositB };
XDR Source: enum LiquidityPoolDepositResultCode { // codes considered as "success" for the operation LIQUIDITY_POOL_DEPOSIT_SUCCESS = 0,
XDR Source: union LiquidityPoolDepositResult switch (LiquidityPoolDepositResultCode code) { case LIQUIDITY_POOL_DEPOSIT_SUCCESS: void; case LIQUIDITY_POOL_DEPOSIT_MALFORMED: case LIQUIDITY_POOL_DEPOSIT_NO_TRUST: case LIQUIDITY_POOL_DEPOSIT_NOT_AUTHORIZED: case LIQUIDITY_POOL_DEPOSIT_UNDERFUNDED: case LIQUIDITY_POOL_DEPOSIT_LINE_FULL: case LIQUIDITY_POOL_DEPOSIT_BAD_PRICE: case LIQUIDITY_POOL_DEPOSIT_POOL_FULL: case LIQUIDITY_POOL_DEPOSIT_TRUSTLINE_FROZEN: void; };
XDR Source: union switch (LiquidityPoolType type) { case LIQUIDITY_POOL_CONSTANT_PRODUCT: struct { LiquidityPoolConstantProductParameters params;
XDR Source: struct { LiquidityPoolConstantProductParameters params;
XDR Source: struct LiquidityPoolEntry { PoolID liquidityPoolID;
XDR Source: union LiquidityPoolParameters switch (LiquidityPoolType type) { case LIQUIDITY_POOL_CONSTANT_PRODUCT: LiquidityPoolConstantProductParameters constantProduct; };
XDR Source: enum LiquidityPoolType { LIQUIDITY_POOL_CONSTANT_PRODUCT = 0 };
XDR Source: struct LiquidityPoolWithdrawOp { PoolID liquidityPoolID; int64 amount; // amount of pool shares to withdraw int64 minAmountA; // minimum amount of first asset to withdraw int64 minAmountB; // minimum amount of second asset to withdraw };
XDR Source: enum LiquidityPoolWithdrawResultCode { // codes considered as "success" for the operation LIQUIDITY_POOL_WITHDRAW_SUCCESS = 0,
XDR Source: union LiquidityPoolWithdrawResult switch (LiquidityPoolWithdrawResultCode code) { case LIQUIDITY_POOL_WITHDRAW_SUCCESS: void; case LIQUIDITY_POOL_WITHDRAW_MALFORMED: case LIQUIDITY_POOL_WITHDRAW_NO_TRUST: case LIQUIDITY_POOL_WITHDRAW_UNDERFUNDED: case LIQUIDITY_POOL_WITHDRAW_LINE_FULL: case LIQUIDITY_POOL_WITHDRAW_UNDER_MINIMUM: case LIQUIDITY_POOL_WITHDRAW_TRUSTLINE_FROZEN: void; };
XDR Source: struct ManageBuyOfferOp { Asset selling; Asset buying; int64 buyAmount; // amount being bought. if set to 0, delete the offer Price price; // price of thing being bought in terms of what you are // selling
XDR Source: enum ManageBuyOfferResultCode { // codes considered as "success" for the operation MANAGE_BUY_OFFER_SUCCESS = 0,
XDR Source: union ManageBuyOfferResult switch (ManageBuyOfferResultCode code) { case MANAGE_BUY_OFFER_SUCCESS: ManageOfferSuccessResult success; case MANAGE_BUY_OFFER_MALFORMED: case MANAGE_BUY_OFFER_SELL_NO_TRUST: case MANAGE_BUY_OFFER_BUY_NO_TRUST: case MANAGE_BUY_OFFER_SELL_NOT_AUTHORIZED: case MANAGE_BUY_OFFER_BUY_NOT_AUTHORIZED: case MANAGE_BUY_OFFER_LINE_FULL: case MANAGE_BUY_OFFER_UNDERFUNDED: case MANAGE_BUY_OFFER_CROSS_SELF: case MANAGE_BUY_OFFER_SELL_NO_ISSUER: case MANAGE_BUY_OFFER_BUY_NO_ISSUER: case MANAGE_BUY_OFFER_NOT_FOUND: case MANAGE_BUY_OFFER_LOW_RESERVE: void; };
XDR Source: struct ManageDataOp { string64 dataName; DataValue* dataValue; // set to null to clear };
XDR Source: enum ManageDataResultCode { // codes considered as "success" for the operation MANAGE_DATA_SUCCESS = 0, // codes considered as "failure" for the operation MANAGE_DATA_NOT_SUPPORTED_YET = -1, // The network hasn't moved to this protocol change yet MANAGE_DATA_NAME_NOT_FOUND = -2, // Trying to remove a Data Entry that isn't there MANAGE_DATA_LOW_RESERVE = -3, // not enough funds to create a new Data Entry MANAGE_DATA_INVALID_NAME = -4 // Name not a valid string };
XDR Source: union ManageDataResult switch (ManageDataResultCode code) { case MANAGE_DATA_SUCCESS: void; case MANAGE_DATA_NOT_SUPPORTED_YET: case MANAGE_DATA_NAME_NOT_FOUND: case MANAGE_DATA_LOW_RESERVE: case MANAGE_DATA_INVALID_NAME: void; };
XDR Source: enum ManageOfferEffect { MANAGE_OFFER_CREATED = 0, MANAGE_OFFER_UPDATED = 1, MANAGE_OFFER_DELETED = 2 };
XDR Source: union switch (ManageOfferEffect effect) { case MANAGE_OFFER_CREATED: case MANAGE_OFFER_UPDATED: OfferEntry offer; case MANAGE_OFFER_DELETED: void; }
XDR Source: struct ManageOfferSuccessResult { // offers that got claimed while creating this offer ClaimAtom offersClaimed<>;
XDR Source: struct ManageSellOfferOp { Asset selling; Asset buying; int64 amount; // amount being sold. if set to 0, delete the offer Price price; // price of thing being sold in terms of what you are buying
XDR Source: enum ManageSellOfferResultCode { // codes considered as "success" for the operation MANAGE_SELL_OFFER_SUCCESS = 0,
XDR Source: union ManageSellOfferResult switch (ManageSellOfferResultCode code) { case MANAGE_SELL_OFFER_SUCCESS: ManageOfferSuccessResult success; case MANAGE_SELL_OFFER_MALFORMED: case MANAGE_SELL_OFFER_SELL_NO_TRUST: case MANAGE_SELL_OFFER_BUY_NO_TRUST: case MANAGE_SELL_OFFER_SELL_NOT_AUTHORIZED: case MANAGE_SELL_OFFER_BUY_NOT_AUTHORIZED: case MANAGE_SELL_OFFER_LINE_FULL: case MANAGE_SELL_OFFER_UNDERFUNDED: case MANAGE_SELL_OFFER_CROSS_SELF: case MANAGE_SELL_OFFER_SELL_NO_ISSUER: case MANAGE_SELL_OFFER_BUY_NO_ISSUER: case MANAGE_SELL_OFFER_NOT_FOUND: case MANAGE_SELL_OFFER_LOW_RESERVE: void; };
XDR Source: enum MemoType { MEMO_NONE = 0, MEMO_TEXT = 1, MEMO_ID = 2, MEMO_HASH = 3, MEMO_RETURN = 4 };
XDR Source: union Memo switch (MemoType type) { case MEMO_NONE: void; case MEMO_TEXT: string text<28>; case MEMO_ID: uint64 id; case MEMO_HASH: Hash hash; // the hash of what to pull from the content server case MEMO_RETURN: Hash retHash; // the hash of the tx you are rejecting };
XDR Source: struct { uint64 id; uint256 ed25519; }
XDR Source: union MuxedAccount switch (CryptoKeyType type) { case KEY_TYPE_ED25519: uint256 ed25519; case KEY_TYPE_MUXED_ED25519: struct { uint64 id; uint256 ed25519; } med25519; };
XDR Source: struct MuxedEd25519Account { uint64 id; uint256 ed25519; };
XDR Source: typedef PublicKey NodeID;
XDR Source: union switch (int v) { case 0: void; }
XDR Source: enum OfferEntryFlags { // an offer with this flag will not act on and take a reverse offer of equal // price PASSIVE_FLAG = 1 };
XDR Source: struct OfferEntry { AccountID sellerID; int64 offerID; Asset selling; // A Asset buying; // B int64 amount; // amount of A
XDR Source: union switch (OperationType type) { case CREATE_ACCOUNT: CreateAccountOp createAccountOp; case PAYMENT: PaymentOp paymentOp; case PATH_PAYMENT_STRICT_RECEIVE: PathPaymentStrictReceiveOp pathPaymentStrictReceiveOp; case MANAGE_SELL_OFFER: ManageSellOfferOp manageSellOfferOp; case CREATE_PASSIVE_SELL_OFFER: CreatePassiveSellOfferOp createPassiveSellOfferOp; case SET_OPTIONS: SetOptionsOp setOptionsOp; case CHANGE_TRUST: ChangeTrustOp changeTrustOp; case ALLOW_TRUST: AllowTrustOp allowTrustOp; case ACCOUNT_MERGE: MuxedAccount destination; case INFLATION: void; case MANAGE_DATA: ManageDataOp manageDataOp; case BUMP_SEQUENCE: BumpSequenceOp bumpSequenceOp; case MANAGE_BUY_OFFER: ManageBuyOfferOp manageBuyOfferOp; case PATH_PAYMENT_STRICT_SEND: PathPaymentStrictSendOp pathPaymentStrictSendOp; case CREATE_CLAIMABLE_BALANCE: CreateClaimableBalanceOp createClaimableBalanceOp; case CLAIM_CLAIMABLE_BALANCE: ClaimClaimableBalanceOp claimClaimableBalanceOp; case BEGIN_SPONSORING_FUTURE_RESERVES: BeginSponsoringFutureReservesOp beginSponsoringFutureReservesOp; case END_SPONSORING_FUTURE_RESERVES: void; case REVOKE_SPONSORSHIP: RevokeSponsorshipOp revokeSponsorshipOp; case CLAWBACK: ClawbackOp clawbackOp; case CLAWBACK_CLAIMABLE_BALANCE: ClawbackClaimableBalanceOp clawbackClaimableBalanceOp; case SET_TRUST_LINE_FLAGS: SetTrustLineFlagsOp setTrustLineFlagsOp; case LIQUIDITY_POOL_DEPOSIT: LiquidityPoolDepositOp liquidityPoolDepositOp; case LIQUIDITY_POOL_WITHDRAW: LiquidityPoolWithdrawOp liquidityPoolWithdrawOp; case INVOKE_HOST_FUNCTION: InvokeHostFunctionOp invokeHostFunctionOp; case EXTEND_FOOTPRINT_TTL: ExtendFootprintTTLOp extendFootprintTTLOp; case RESTORE_FOOTPRINT: RestoreFootprintOp restoreFootprintOp; }
XDR Source: struct OperationMetaV2 { ExtensionPoint ext;
XDR Source: struct OperationMeta { LedgerEntryChanges changes; };
XDR Source: enum OperationResultCode { opINNER = 0, // inner object result is valid
XDR Source: union switch (OperationType type) { case CREATE_ACCOUNT: CreateAccountResult createAccountResult; case PAYMENT: PaymentResult paymentResult; case PATH_PAYMENT_STRICT_RECEIVE: PathPaymentStrictReceiveResult pathPaymentStrictReceiveResult; case MANAGE_SELL_OFFER: ManageSellOfferResult manageSellOfferResult; case CREATE_PASSIVE_SELL_OFFER: ManageSellOfferResult createPassiveSellOfferResult; case SET_OPTIONS: SetOptionsResult setOptionsResult; case CHANGE_TRUST: ChangeTrustResult changeTrustResult; case ALLOW_TRUST: AllowTrustResult allowTrustResult; case ACCOUNT_MERGE: AccountMergeResult accountMergeResult; case INFLATION: InflationResult inflationResult; case MANAGE_DATA: ManageDataResult manageDataResult; case BUMP_SEQUENCE: BumpSequenceResult bumpSeqResult; case MANAGE_BUY_OFFER: ManageBuyOfferResult manageBuyOfferResult; case PATH_PAYMENT_STRICT_SEND: PathPaymentStrictSendResult pathPaymentStrictSendResult; case CREATE_CLAIMABLE_BALANCE: CreateClaimableBalanceResult createClaimableBalanceResult; case CLAIM_CLAIMABLE_BALANCE: ClaimClaimableBalanceResult claimClaimableBalanceResult; case BEGIN_SPONSORING_FUTURE_RESERVES: BeginSponsoringFutureReservesResult beginSponsoringFutureReservesResult; case END_SPONSORING_FUTURE_RESERVES: EndSponsoringFutureReservesResult endSponsoringFutureReservesResult; case REVOKE_SPONSORSHIP: RevokeSponsorshipResult revokeSponsorshipResult; case CLAWBACK: ClawbackResult clawbackResult; case CLAWBACK_CLAIMABLE_BALANCE: ClawbackClaimableBalanceResult clawbackClaimableBalanceResult; case SET_TRUST_LINE_FLAGS: SetTrustLineFlagsResult setTrustLineFlagsResult; case LIQUIDITY_POOL_DEPOSIT: LiquidityPoolDepositResult liquidityPoolDepositResult; case LIQUIDITY_POOL_WITHDRAW: LiquidityPoolWithdrawResult liquidityPoolWithdrawResult; case INVOKE_HOST_FUNCTION: InvokeHostFunctionResult invokeHostFunctionResult; case EXTEND_FOOTPRINT_TTL: ExtendFootprintTTLResult extendFootprintTTLResult; case RESTORE_FOOTPRINT: RestoreFootprintResult restoreFootprintResult; }
XDR Source: union OperationResult switch (OperationResultCode code) { case opINNER: union switch (OperationType type) { case CREATE_ACCOUNT: CreateAccountResult createAccountResult; case PAYMENT: PaymentResult paymentResult; case PATH_PAYMENT_STRICT_RECEIVE: PathPaymentStrictReceiveResult pathPaymentStrictReceiveResult; case MANAGE_SELL_OFFER: ManageSellOfferResult manageSellOfferResult; case CREATE_PASSIVE_SELL_OFFER: ManageSellOfferResult createPassiveSellOfferResult; case SET_OPTIONS: SetOptionsResult setOptionsResult; case CHANGE_TRUST: ChangeTrustResult changeTrustResult; case ALLOW_TRUST: AllowTrustResult allowTrustResult; case ACCOUNT_MERGE: AccountMergeResult accountMergeResult; case INFLATION: InflationResult inflationResult; case MANAGE_DATA: ManageDataResult manageDataResult; case BUMP_SEQUENCE: BumpSequenceResult bumpSeqResult; case MANAGE_BUY_OFFER: ManageBuyOfferResult manageBuyOfferResult; case PATH_PAYMENT_STRICT_SEND: PathPaymentStrictSendResult pathPaymentStrictSendResult; case CREATE_CLAIMABLE_BALANCE: CreateClaimableBalanceResult createClaimableBalanceResult; case CLAIM_CLAIMABLE_BALANCE: ClaimClaimableBalanceResult claimClaimableBalanceResult; case BEGIN_SPONSORING_FUTURE_RESERVES: BeginSponsoringFutureReservesResult beginSponsoringFutureReservesResult; case END_SPONSORING_FUTURE_RESERVES: EndSponsoringFutureReservesResult endSponsoringFutureReservesResult; case REVOKE_SPONSORSHIP: RevokeSponsorshipResult revokeSponsorshipResult; case CLAWBACK: ClawbackResult clawbackResult; case CLAWBACK_CLAIMABLE_BALANCE: ClawbackClaimableBalanceResult clawbackClaimableBalanceResult; case SET_TRUST_LINE_FLAGS: SetTrustLineFlagsResult setTrustLineFlagsResult; case LIQUIDITY_POOL_DEPOSIT: LiquidityPoolDepositResult liquidityPoolDepositResult; case LIQUIDITY_POOL_WITHDRAW: LiquidityPoolWithdrawResult liquidityPoolWithdrawResult; case INVOKE_HOST_FUNCTION: InvokeHostFunctionResult invokeHostFunctionResult; case EXTEND_FOOTPRINT_TTL: ExtendFootprintTTLResult extendFootprintTTLResult; case RESTORE_FOOTPRINT: RestoreFootprintResult restoreFootprintResult; } tr; case opBAD_AUTH: case opNO_ACCOUNT: case opNOT_SUPPORTED: case opTOO_MANY_SUBENTRIES: case opEXCEEDED_WORK_LIMIT: case opTOO_MANY_SPONSORING: void; };
XDR Source: enum OperationType { CREATE_ACCOUNT = 0, PAYMENT = 1, PATH_PAYMENT_STRICT_RECEIVE = 2, MANAGE_SELL_OFFER = 3, CREATE_PASSIVE_SELL_OFFER = 4, SET_OPTIONS = 5, CHANGE_TRUST = 6, ALLOW_TRUST = 7, ACCOUNT_MERGE = 8, INFLATION = 9, MANAGE_DATA = 10, BUMP_SEQUENCE = 11, MANAGE_BUY_OFFER = 12, PATH_PAYMENT_STRICT_SEND = 13, CREATE_CLAIMABLE_BALANCE = 14, CLAIM_CLAIMABLE_BALANCE = 15, BEGIN_SPONSORING_FUTURE_RESERVES = 16, END_SPONSORING_FUTURE_RESERVES = 17, REVOKE_SPONSORSHIP = 18, CLAWBACK = 19, CLAWBACK_CLAIMABLE_BALANCE = 20, SET_TRUST_LINE_FLAGS = 21, LIQUIDITY_POOL_DEPOSIT = 22, LIQUIDITY_POOL_WITHDRAW = 23, INVOKE_HOST_FUNCTION = 24, EXTEND_FOOTPRINT_TTL = 25, RESTORE_FOOTPRINT = 26 };
XDR Source: struct Operation { // sourceAccount is the account used to run the operation // if not set, the runtime defaults to "sourceAccount" specified at // the transaction level MuxedAccount* sourceAccount;
XDR Source: typedef DependentTxCluster ParallelTxExecutionStage<>;
XDR Source: struct ParallelTxsComponent { int64* baseFee; // A sequence of stages that may have arbitrary data dependencies between // each other, i.e. in a general case the stage execution order may not be // arbitrarily shuffled without affecting the end result. ParallelTxExecutionStage executionStages<>; };
XDR Source: struct PathPaymentStrictReceiveOp { Asset sendAsset; // asset we pay with int64 sendMax; // the maximum amount of sendAsset to // send (excluding fees). // The operation will fail if can't be met
XDR Source: enum PathPaymentStrictReceiveResultCode { // codes considered as "success" for the operation PATH_PAYMENT_STRICT_RECEIVE_SUCCESS = 0, // success
XDR Source: struct { ClaimAtom offers<>; SimplePaymentResult last; }
XDR Source: union PathPaymentStrictReceiveResult switch ( PathPaymentStrictReceiveResultCode code) { case PATH_PAYMENT_STRICT_RECEIVE_SUCCESS: struct { ClaimAtom offers<>; SimplePaymentResult last; } success; case PATH_PAYMENT_STRICT_RECEIVE_MALFORMED: case PATH_PAYMENT_STRICT_RECEIVE_UNDERFUNDED: case PATH_PAYMENT_STRICT_RECEIVE_SRC_NO_TRUST: case PATH_PAYMENT_STRICT_RECEIVE_SRC_NOT_AUTHORIZED: case PATH_PAYMENT_STRICT_RECEIVE_NO_DESTINATION: case PATH_PAYMENT_STRICT_RECEIVE_NO_TRUST: case PATH_PAYMENT_STRICT_RECEIVE_NOT_AUTHORIZED: case PATH_PAYMENT_STRICT_RECEIVE_LINE_FULL: void; case PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER: Asset noIssuer; // the asset that caused the error case PATH_PAYMENT_STRICT_RECEIVE_TOO_FEW_OFFERS: case PATH_PAYMENT_STRICT_RECEIVE_OFFER_CROSS_SELF: case PATH_PAYMENT_STRICT_RECEIVE_OVER_SENDMAX: void; };
XDR Source: struct PathPaymentStrictSendOp { Asset sendAsset; // asset we pay with int64 sendAmount; // amount of sendAsset to send (excluding fees)
XDR Source: enum PathPaymentStrictSendResultCode { // codes considered as "success" for the operation PATH_PAYMENT_STRICT_SEND_SUCCESS = 0, // success
XDR Source: struct { ClaimAtom offers<>; SimplePaymentResult last; }
XDR Source: union PathPaymentStrictSendResult switch (PathPaymentStrictSendResultCode code) { case PATH_PAYMENT_STRICT_SEND_SUCCESS: struct { ClaimAtom offers<>; SimplePaymentResult last; } success; case PATH_PAYMENT_STRICT_SEND_MALFORMED: case PATH_PAYMENT_STRICT_SEND_UNDERFUNDED: case PATH_PAYMENT_STRICT_SEND_SRC_NO_TRUST: case PATH_PAYMENT_STRICT_SEND_SRC_NOT_AUTHORIZED: case PATH_PAYMENT_STRICT_SEND_NO_DESTINATION: case PATH_PAYMENT_STRICT_SEND_NO_TRUST: case PATH_PAYMENT_STRICT_SEND_NOT_AUTHORIZED: case PATH_PAYMENT_STRICT_SEND_LINE_FULL: void; case PATH_PAYMENT_STRICT_SEND_NO_ISSUER: Asset noIssuer; // the asset that caused the error case PATH_PAYMENT_STRICT_SEND_TOO_FEW_OFFERS: case PATH_PAYMENT_STRICT_SEND_OFFER_CROSS_SELF: case PATH_PAYMENT_STRICT_SEND_UNDER_DESTMIN: void; };
XDR Source: struct PaymentOp { MuxedAccount destination; // recipient of the payment Asset asset; // what they end up with int64 amount; // amount they end up with };
XDR Source: enum PaymentResultCode { // codes considered as "success" for the operation PAYMENT_SUCCESS = 0, // payment successfully completed
XDR Source: union PaymentResult switch (PaymentResultCode code) { case PAYMENT_SUCCESS: void; case PAYMENT_MALFORMED: case PAYMENT_UNDERFUNDED: case PAYMENT_SRC_NO_TRUST: case PAYMENT_SRC_NOT_AUTHORIZED: case PAYMENT_NO_DESTINATION: case PAYMENT_NO_TRUST: case PAYMENT_NOT_AUTHORIZED: case PAYMENT_LINE_FULL: case PAYMENT_NO_ISSUER: void; };
XDR Source: struct PreconditionsV2 { TimeBounds* timeBounds;
XDR Source: union Preconditions switch (PreconditionType type) { case PRECOND_NONE: void; case PRECOND_TIME: TimeBounds timeBounds; case PRECOND_V2: PreconditionsV2 v2; };
XDR Source: enum PreconditionType { PRECOND_NONE = 0, PRECOND_TIME = 1, PRECOND_V2 = 2 };
XDR Source: enum PublicKeyType { PUBLIC_KEY_TYPE_ED25519 = KEY_TYPE_ED25519 };
XDR Source: union PublicKey switch (PublicKeyType type) { case PUBLIC_KEY_TYPE_ED25519: uint256 ed25519; };
XDR Source: struct RestoreFootprintOp { ExtensionPoint ext; };
XDR Source: enum RestoreFootprintResultCode { // codes considered as "success" for the operation RESTORE_FOOTPRINT_SUCCESS = 0,
XDR Source: union RestoreFootprintResult switch (RestoreFootprintResultCode code) { case RESTORE_FOOTPRINT_SUCCESS: void; case RESTORE_FOOTPRINT_MALFORMED: case RESTORE_FOOTPRINT_RESOURCE_LIMIT_EXCEEDED: case RESTORE_FOOTPRINT_INSUFFICIENT_REFUNDABLE_FEE: void; };
XDR Source: struct { AccountID accountID; SignerKey signerKey; }
XDR Source: union RevokeSponsorshipOp switch (RevokeSponsorshipType type) { case REVOKE_SPONSORSHIP_LEDGER_ENTRY: LedgerKey ledgerKey; case REVOKE_SPONSORSHIP_SIGNER: struct { AccountID accountID; SignerKey signerKey; } signer; };
XDR Source: enum RevokeSponsorshipResultCode { // codes considered as "success" for the operation REVOKE_SPONSORSHIP_SUCCESS = 0,
XDR Source: union RevokeSponsorshipResult switch (RevokeSponsorshipResultCode code) { case REVOKE_SPONSORSHIP_SUCCESS: void; case REVOKE_SPONSORSHIP_DOES_NOT_EXIST: case REVOKE_SPONSORSHIP_NOT_SPONSOR: case REVOKE_SPONSORSHIP_LOW_RESERVE: case REVOKE_SPONSORSHIP_ONLY_TRANSFERABLE: case REVOKE_SPONSORSHIP_MALFORMED: void; };
XDR Source: enum RevokeSponsorshipType { REVOKE_SPONSORSHIP_LEDGER_ENTRY = 0, REVOKE_SPONSORSHIP_SIGNER = 1 };
XDR Source: enum SCAddressType { SC_ADDRESS_TYPE_ACCOUNT = 0, SC_ADDRESS_TYPE_CONTRACT = 1, SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2, SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3, SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4 };
XDR Source: union SCAddress switch (SCAddressType type) { case SC_ADDRESS_TYPE_ACCOUNT: AccountID accountId; case SC_ADDRESS_TYPE_CONTRACT: ContractID contractId; case SC_ADDRESS_TYPE_MUXED_ACCOUNT: MuxedEd25519Account muxedAccount; case SC_ADDRESS_TYPE_CLAIMABLE_BALANCE: ClaimableBalanceID claimableBalanceId; case SC_ADDRESS_TYPE_LIQUIDITY_POOL: PoolID liquidityPoolId; };
XDR Source: typedef opaque SCBytes<>;
XDR Source: struct SCContractInstance { ContractExecutable executable; SCMap* storage; };
XDR Source: struct { uint32 protocol; uint32 preRelease; }
XDR Source: union SCEnvMetaEntry switch (SCEnvMetaKind kind) { case SC_ENV_META_KIND_INTERFACE_VERSION: struct { uint32 protocol; uint32 preRelease; } interfaceVersion; };
XDR Source: enum SCEnvMetaKind { SC_ENV_META_KIND_INTERFACE_VERSION = 0 };
XDR Source: enum SCErrorCode { SCEC_ARITH_DOMAIN = 0, // Some arithmetic was undefined (overflow, divide-by-zero). SCEC_INDEX_BOUNDS = 1, // Something was indexed beyond its bounds. SCEC_INVALID_INPUT = 2, // User provided some otherwise-bad data. SCEC_MISSING_VALUE = 3, // Some value was required but not provided. SCEC_EXISTING_VALUE = 4, // Some value was provided where not allowed. SCEC_EXCEEDED_LIMIT = 5, // Some arbitrary limit -- gas or otherwise -- was hit. SCEC_INVALID_ACTION = 6, // Data was valid but action requested was not. SCEC_INTERNAL_ERROR = 7, // The host detected an error in its own logic. SCEC_UNEXPECTED_TYPE = 8, // Some type wasn't as expected. SCEC_UNEXPECTED_SIZE = 9 // Something's size wasn't as expected. };
XDR Source: enum SCErrorType { SCE_CONTRACT = 0, // Contract-specific, user-defined codes. SCE_WASM_VM = 1, // Errors while interpreting WASM bytecode. SCE_CONTEXT = 2, // Errors in the contract's host context. SCE_STORAGE = 3, // Errors accessing host storage. SCE_OBJECT = 4, // Errors working with host objects. SCE_CRYPTO = 5, // Errors in cryptographic operations. SCE_EVENTS = 6, // Errors while emitting events. SCE_BUDGET = 7, // Errors relating to budget limits. SCE_VALUE = 8, // Errors working with host values or SCVals. SCE_AUTH = 9 // Errors from the authentication subsystem. };
XDR Source: union SCError switch (SCErrorType type) { case SCE_CONTRACT: uint32 contractCode; case SCE_WASM_VM: case SCE_CONTEXT: case SCE_STORAGE: case SCE_OBJECT: case SCE_CRYPTO: case SCE_EVENTS: case SCE_BUDGET: case SCE_VALUE: case SCE_AUTH: SCErrorCode code; };
XDR Source: struct SCMapEntry { SCVal key; SCVal val; };
XDR Source: typedef SCMapEntry SCMap<>;
XDR Source: union SCMetaEntry switch (SCMetaKind kind) { case SC_META_V0: SCMetaV0 v0; };
XDR Source: enum SCMetaKind { SC_META_V0 = 0 };
XDR Source: struct SCMetaV0 { string key<>; string val<>; };
XDR Source: struct SCNonceKey { int64 nonce; };
XDR Source: struct SCPBallot { uint32 counter; // n Value value; // x };
XDR Source: struct SCPEnvelope { SCPStatement statement; Signature signature; };
XDR Source: struct SCPHistoryEntryV0 { SCPQuorumSet quorumSets<>; // additional quorum sets used by ledgerMessages LedgerSCPMessages ledgerMessages; };
XDR Source: union SCPHistoryEntry switch (int v) { case 0: SCPHistoryEntryV0 v0; };
XDR Source: struct SCPQuorumSet { uint32 threshold; NodeID validators<>; SCPQuorumSet innerSets<>; };
XDR Source: struct { SCPBallot ballot; // b uint32 nPrepared; // p.n uint32 nCommit; // c.n uint32 nH; // h.n Hash quorumSetHash; // D }
XDR Source: struct { SCPBallot commit; // c uint32 nH; // h.n Hash commitQuorumSetHash; // D used before EXTERNALIZE }
XDR Source: union switch (SCPStatementType type) { case SCP_ST_PREPARE: struct { Hash quorumSetHash; // D SCPBallot ballot; // b SCPBallot* prepared; // p SCPBallot* preparedPrime; // p' uint32 nC; // c.n uint32 nH; // h.n } prepare; case SCP_ST_CONFIRM: struct { SCPBallot ballot; // b uint32 nPrepared; // p.n uint32 nCommit; // c.n uint32 nH; // h.n Hash quorumSetHash; // D } confirm; case SCP_ST_EXTERNALIZE: struct { SCPBallot commit; // c uint32 nH; // h.n Hash commitQuorumSetHash; // D used before EXTERNALIZE } externalize; case SCP_ST_NOMINATE: SCPNomination nominate; }
XDR Source: struct { Hash quorumSetHash; // D SCPBallot ballot; // b SCPBallot* prepared; // p SCPBallot* preparedPrime; // p' uint32 nC; // c.n uint32 nH; // h.n }
XDR Source: enum SCPStatementType { SCP_ST_PREPARE = 0, SCP_ST_CONFIRM = 1, SCP_ST_EXTERNALIZE = 2, SCP_ST_NOMINATE = 3 };
XDR Source: struct SCPStatement { NodeID nodeID; // v uint64 slotIndex; // i
XDR Source: enum SCSpecEntryKind { SC_SPEC_ENTRY_FUNCTION_V0 = 0, SC_SPEC_ENTRY_UDT_STRUCT_V0 = 1, SC_SPEC_ENTRY_UDT_UNION_V0 = 2, SC_SPEC_ENTRY_UDT_ENUM_V0 = 3, SC_SPEC_ENTRY_UDT_ERROR_ENUM_V0 = 4, SC_SPEC_ENTRY_EVENT_V0 = 5 };
XDR Source: union SCSpecEntry switch (SCSpecEntryKind kind) { case SC_SPEC_ENTRY_FUNCTION_V0: SCSpecFunctionV0 functionV0; case SC_SPEC_ENTRY_UDT_STRUCT_V0: SCSpecUDTStructV0 udtStructV0; case SC_SPEC_ENTRY_UDT_UNION_V0: SCSpecUDTUnionV0 udtUnionV0; case SC_SPEC_ENTRY_UDT_ENUM_V0: SCSpecUDTEnumV0 udtEnumV0; case SC_SPEC_ENTRY_UDT_ERROR_ENUM_V0: SCSpecUDTErrorEnumV0 udtErrorEnumV0; case SC_SPEC_ENTRY_EVENT_V0: SCSpecEventV0 eventV0; };
XDR Source: enum SCSpecEventDataFormat { SC_SPEC_EVENT_DATA_FORMAT_SINGLE_VALUE = 0, SC_SPEC_EVENT_DATA_FORMAT_VEC = 1, SC_SPEC_EVENT_DATA_FORMAT_MAP = 2 };
XDR Source: enum SCSpecEventParamLocationV0 { SC_SPEC_EVENT_PARAM_LOCATION_DATA = 0, SC_SPEC_EVENT_PARAM_LOCATION_TOPIC_LIST = 1 };
XDR Source: struct SCSpecEventParamV0 { string doc
XDR Source: struct SCSpecEventV0 { string doc
XDR Source: struct SCSpecFunctionInputV0 { string doc
XDR Source: struct SCSpecFunctionV0 { string doc
XDR Source: struct SCSpecTypeBytesN { uint32 n; };
XDR Source: union SCSpecTypeDef switch (SCSpecType type) { case SC_SPEC_TYPE_VAL: case SC_SPEC_TYPE_BOOL: case SC_SPEC_TYPE_VOID: case SC_SPEC_TYPE_ERROR: case SC_SPEC_TYPE_U32: case SC_SPEC_TYPE_I32: case SC_SPEC_TYPE_U64: case SC_SPEC_TYPE_I64: case SC_SPEC_TYPE_TIMEPOINT: case SC_SPEC_TYPE_DURATION: case SC_SPEC_TYPE_U128: case SC_SPEC_TYPE_I128: case SC_SPEC_TYPE_U256: case SC_SPEC_TYPE_I256: case SC_SPEC_TYPE_BYTES: case SC_SPEC_TYPE_STRING: case SC_SPEC_TYPE_SYMBOL: case SC_SPEC_TYPE_ADDRESS: case SC_SPEC_TYPE_MUXED_ADDRESS: void; case SC_SPEC_TYPE_OPTION: SCSpecTypeOption option; case SC_SPEC_TYPE_RESULT: SCSpecTypeResult result; case SC_SPEC_TYPE_VEC: SCSpecTypeVec vec; case SC_SPEC_TYPE_MAP: SCSpecTypeMap map; case SC_SPEC_TYPE_TUPLE: SCSpecTypeTuple tuple; case SC_SPEC_TYPE_BYTES_N: SCSpecTypeBytesN bytesN; case SC_SPEC_TYPE_UDT: SCSpecTypeUDT udt; };
XDR Source: struct SCSpecTypeMap { SCSpecTypeDef keyType; SCSpecTypeDef valueType; };
XDR Source: struct SCSpecTypeOption { SCSpecTypeDef valueType; };
XDR Source: struct SCSpecTypeResult { SCSpecTypeDef okType; SCSpecTypeDef errorType; };
XDR Source: struct SCSpecTypeTuple { SCSpecTypeDef valueTypes<12>; };
XDR Source: struct SCSpecTypeUDT { string name<60>; };
XDR Source: struct SCSpecTypeVec { SCSpecTypeDef elementType; };
XDR Source: enum SCSpecType { SC_SPEC_TYPE_VAL = 0,
XDR Source: struct SCSpecUDTEnumCaseV0 { string doc
XDR Source: struct SCSpecUDTEnumV0 { string doc
XDR Source: struct SCSpecUDTErrorEnumCaseV0 { string doc
XDR Source: struct SCSpecUDTErrorEnumV0 { string doc
XDR Source: struct SCSpecUDTStructFieldV0 { string doc
XDR Source: struct SCSpecUDTStructV0 { string doc
XDR Source: struct SCSpecUDTUnionCaseTupleV0 { string doc
XDR Source: enum SCSpecUDTUnionCaseV0Kind { SC_SPEC_UDT_UNION_CASE_VOID_V0 = 0, SC_SPEC_UDT_UNION_CASE_TUPLE_V0 = 1 };
XDR Source: union SCSpecUDTUnionCaseV0 switch (SCSpecUDTUnionCaseV0Kind kind) { case SC_SPEC_UDT_UNION_CASE_VOID_V0: SCSpecUDTUnionCaseVoidV0 voidCase; case SC_SPEC_UDT_UNION_CASE_TUPLE_V0: SCSpecUDTUnionCaseTupleV0 tupleCase; };
XDR Source: struct SCSpecUDTUnionCaseVoidV0 { string doc
XDR Source: struct SCSpecUDTUnionV0 { string doc
XDR Source: typedef string SCString<>;
XDR Source: typedef string SCSymbol
XDR Source: enum SCValType { SCV_BOOL = 0, SCV_VOID = 1, SCV_ERROR = 2,
XDR Source: typedef int64 SequenceNumber;
XDR Source: struct SerializedBinaryFuseFilter { BinaryFuseFilterType type;
XDR Source: struct SetOptionsOp { AccountID* inflationDest; // sets the inflation destination
XDR Source: enum SetOptionsResultCode { // codes considered as "success" for the operation SET_OPTIONS_SUCCESS = 0, // codes considered as "failure" for the operation SET_OPTIONS_LOW_RESERVE = -1, // not enough funds to add a signer SET_OPTIONS_TOO_MANY_SIGNERS = -2, // max number of signers already reached SET_OPTIONS_BAD_FLAGS = -3, // invalid combination of clear/set flags SET_OPTIONS_INVALID_INFLATION = -4, // inflation account does not exist SET_OPTIONS_CANT_CHANGE = -5, // can no longer change this option SET_OPTIONS_UNKNOWN_FLAG = -6, // can't set an unknown flag SET_OPTIONS_THRESHOLD_OUT_OF_RANGE = -7, // bad value for weight/threshold SET_OPTIONS_BAD_SIGNER = -8, // signer cannot be masterkey SET_OPTIONS_INVALID_HOME_DOMAIN = -9, // malformed home domain SET_OPTIONS_AUTH_REVOCABLE_REQUIRED = -10 // auth revocable is required for clawback };
XDR Source: union SetOptionsResult switch (SetOptionsResultCode code) { case SET_OPTIONS_SUCCESS: void; case SET_OPTIONS_LOW_RESERVE: case SET_OPTIONS_TOO_MANY_SIGNERS: case SET_OPTIONS_BAD_FLAGS: case SET_OPTIONS_INVALID_INFLATION: case SET_OPTIONS_CANT_CHANGE: case SET_OPTIONS_UNKNOWN_FLAG: case SET_OPTIONS_THRESHOLD_OUT_OF_RANGE: case SET_OPTIONS_BAD_SIGNER: case SET_OPTIONS_INVALID_HOME_DOMAIN: case SET_OPTIONS_AUTH_REVOCABLE_REQUIRED: void; };
XDR Source: struct SetTrustLineFlagsOp { AccountID trustor; Asset asset;
XDR Source: enum SetTrustLineFlagsResultCode { // codes considered as "success" for the operation SET_TRUST_LINE_FLAGS_SUCCESS = 0,
XDR Source: union SetTrustLineFlagsResult switch (SetTrustLineFlagsResultCode code) { case SET_TRUST_LINE_FLAGS_SUCCESS: void; case SET_TRUST_LINE_FLAGS_MALFORMED: case SET_TRUST_LINE_FLAGS_NO_TRUST_LINE: case SET_TRUST_LINE_FLAGS_CANT_REVOKE: case SET_TRUST_LINE_FLAGS_INVALID_STATE: case SET_TRUST_LINE_FLAGS_LOW_RESERVE: void; };
XDR Source: struct ShortHashSeed { opaque seed16; };
XDR Source: typedef opaque SignatureHint4;
XDR Source: typedef opaque Signature<64>;
XDR Source: struct { /* Public key that must sign the payload. / uint256 ed25519; / Payload to be raw signed by ed25519. */ opaque payload<64>; }
XDR Source: enum SignerKeyType { SIGNER_KEY_TYPE_ED25519 = KEY_TYPE_ED25519, SIGNER_KEY_TYPE_PRE_AUTH_TX = KEY_TYPE_PRE_AUTH_TX, SIGNER_KEY_TYPE_HASH_X = KEY_TYPE_HASH_X, SIGNER_KEY_TYPE_ED25519_SIGNED_PAYLOAD = KEY_TYPE_ED25519_SIGNED_PAYLOAD };
XDR Source: union SignerKey switch (SignerKeyType type) { case SIGNER_KEY_TYPE_ED25519: uint256 ed25519; case SIGNER_KEY_TYPE_PRE_AUTH_TX: /* SHA-256 Hash of TransactionSignaturePayload structure / uint256 preAuthTx; case SIGNER_KEY_TYPE_HASH_X: / Hash of random 256 bit preimage X / uint256 hashX; case SIGNER_KEY_TYPE_ED25519_SIGNED_PAYLOAD: struct { / Public key that must sign the payload. / uint256 ed25519; / Payload to be raw signed by ed25519. */ opaque payload<64>; } ed25519SignedPayload; };
XDR Source: struct Signer { SignerKey key; uint32 weight; // really only need 1 byte };
XDR Source: struct SimplePaymentResult { AccountID destination; Asset asset; int64 amount; };
XDR Source: struct SorobanAddressCredentialsWithDelegates { SorobanAddressCredentials addressCredentials; SorobanDelegateSignature delegates<>; };
XDR Source: struct SorobanAddressCredentials { SCAddress address; int64 nonce; uint32 signatureExpirationLedger; SCVal signature; };
XDR Source: typedef SorobanAuthorizationEntry SorobanAuthorizationEntries<>;
XDR Source: struct SorobanAuthorizationEntry { SorobanCredentials credentials; SorobanAuthorizedInvocation rootInvocation; };
XDR Source: enum SorobanAuthorizedFunctionType { SOROBAN_AUTHORIZED_FUNCTION_TYPE_CONTRACT_FN = 0, SOROBAN_AUTHORIZED_FUNCTION_TYPE_CREATE_CONTRACT_HOST_FN = 1, SOROBAN_AUTHORIZED_FUNCTION_TYPE_CREATE_CONTRACT_V2_HOST_FN = 2 };
XDR Source: union SorobanAuthorizedFunction switch (SorobanAuthorizedFunctionType type) { case SOROBAN_AUTHORIZED_FUNCTION_TYPE_CONTRACT_FN: InvokeContractArgs contractFn; // This variant of auth payload for creating new contract instances // doesn't allow specifying the constructor arguments, creating contracts // with constructors that take arguments is only possible by authorizing // SOROBAN_AUTHORIZED_FUNCTION_TYPE_CREATE_CONTRACT_V2_HOST_FN // (protocol 22+). case SOROBAN_AUTHORIZED_FUNCTION_TYPE_CREATE_CONTRACT_HOST_FN: CreateContractArgs createContractHostFn; // This variant of auth payload for creating new contract instances // is only accepted in and after protocol 22. It allows authorizing the // contract constructor arguments. case SOROBAN_AUTHORIZED_FUNCTION_TYPE_CREATE_CONTRACT_V2_HOST_FN: CreateContractArgsV2 createContractV2HostFn; };
XDR Source: struct SorobanAuthorizedInvocation { SorobanAuthorizedFunction function; SorobanAuthorizedInvocation subInvocations<>; };
XDR Source: enum SorobanCredentialsType { SOROBAN_CREDENTIALS_SOURCE_ACCOUNT = 0, SOROBAN_CREDENTIALS_ADDRESS = 1, SOROBAN_CREDENTIALS_ADDRESS_V2 = 2, SOROBAN_CREDENTIALS_ADDRESS_WITH_DELEGATES = 3 };
XDR Source: union SorobanCredentials switch (SorobanCredentialsType type) { case SOROBAN_CREDENTIALS_SOURCE_ACCOUNT: void; case SOROBAN_CREDENTIALS_ADDRESS: SorobanAddressCredentials address; case SOROBAN_CREDENTIALS_ADDRESS_V2: SorobanAddressCredentials addressV2; case SOROBAN_CREDENTIALS_ADDRESS_WITH_DELEGATES: SorobanAddressCredentialsWithDelegates addressWithDelegates; };
XDR Source: struct SorobanDelegateSignature { SCAddress address; SCVal signature; SorobanDelegateSignature nestedDelegates<>; };
XDR Source: struct SorobanResourcesExtV0 { // Vector of indices representing what Soroban // entries in the footprint are archived, based on the // order of keys provided in the readWrite footprint. uint32 archivedSorobanEntries<>; };
XDR Source: struct SorobanResources { // The ledger footprint of the transaction. LedgerFootprint footprint; // The maximum number of instructions this transaction can use uint32 instructions;
XDR Source: union switch (int v) { case 0: void; case 1: SorobanResourcesExtV0 resourceExt; }
XDR Source: struct SorobanTransactionData { union switch (int v) { case 0: void; case 1: SorobanResourcesExtV0 resourceExt; } ext; SorobanResources resources; // Amount of the transaction fee allocated to the Soroban resource fees. // The fraction of resourceFee corresponding to resources specified // above is not refundable (i.e. fees for instructions, ledger I/O), as // well as fees for the transaction size. // The remaining part of the fee is refundable and the charged value is // based on the actual consumption of refundable resources (events, ledger // rent bumps). // The inclusionFee used for prioritization of the transaction is defined // as tx.fee - resourceFee. int64 resourceFee; };
XDR Source: struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;
XDR Source: union SorobanTransactionMetaExt switch (int v) { case 0: void; case 1: SorobanTransactionMetaExtV1 v1; };
XDR Source: struct SorobanTransactionMetaV2 { SorobanTransactionMetaExt ext;
XDR Source: struct SorobanTransactionMeta { SorobanTransactionMetaExt ext;
XDR Source: typedef AccountID* SponsorshipDescriptor;
XDR Source: struct StateArchivalSettings { uint32 maxEntryTTL; uint32 minTemporaryTTL; uint32 minPersistentTTL;
XDR Source: union switch (StellarValueType v) { case STELLAR_VALUE_BASIC: void; case STELLAR_VALUE_SIGNED: LedgerCloseValueSignature lcValueSignature; case STELLAR_VALUE_EMPTY_TX_SET: struct { Hash txSetHash; Hash previousLedgerHash; uint32 previousLedgerVersion; LedgerCloseValueSignature lcValueSignature; } proposedValue; }
XDR Source: struct { Hash txSetHash; Hash previousLedgerHash; uint32 previousLedgerVersion; LedgerCloseValueSignature lcValueSignature; }
XDR Source: enum StellarValueType { STELLAR_VALUE_BASIC = 0, STELLAR_VALUE_SIGNED = 1, STELLAR_VALUE_EMPTY_TX_SET = 2 };
XDR Source: struct StellarValue { Hash txSetHash; // transaction set to apply to previous ledger TimePoint closeTime; // network close time
XDR Source: typedef string string32<32>;
XDR Source: typedef string string64<64>;
XDR Source: enum ThresholdIndexes { THRESHOLD_MASTER_WEIGHT = 0, THRESHOLD_LOW = 1, THRESHOLD_MED = 2, THRESHOLD_HIGH = 3 };
XDR Source: typedef opaque Thresholds4;
XDR Source: struct TimeBounds { TimePoint minTime; TimePoint maxTime; // 0 here means no maxTime };
XDR Source: typedef uint64 TimePoint;
XDR Source: union TransactionEnvelope switch (EnvelopeType type) { case ENVELOPE_TYPE_TX_V0: TransactionV0Envelope v0; case ENVELOPE_TYPE_TX: TransactionV1Envelope v1; case ENVELOPE_TYPE_TX_FEE_BUMP: FeeBumpTransactionEnvelope feeBump; };
XDR Source: enum TransactionEventStage { // The event has happened before any one of the transactions has its // operations applied. TRANSACTION_EVENT_STAGE_BEFORE_ALL_TXS = 0, // The event has happened immediately after operations of the transaction // have been applied. TRANSACTION_EVENT_STAGE_AFTER_TX = 1, // The event has happened after every transaction had its operations // applied. TRANSACTION_EVENT_STAGE_AFTER_ALL_TXS = 2 };
XDR Source: struct TransactionEvent { TransactionEventStage stage; // Stage at which an event has occurred. ContractEvent event; // The contract event that has occurred. };
XDR Source: union switch (int v) { case 0: void; case 1: SorobanTransactionData sorobanData; }
XDR Source: union switch (int v) { case 0: void; case 1: GeneralizedTransactionSet generalizedTxSet; }
XDR Source: struct TransactionHistoryEntry { uint32 ledgerSeq; TransactionSet txSet;
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct TransactionHistoryResultEntry { uint32 ledgerSeq; TransactionResultSet txResultSet;
XDR Source: struct TransactionMetaV1 { LedgerEntryChanges txChanges; // tx level changes if any OperationMeta operations<>; // meta for each operation };
XDR Source: struct TransactionMetaV2 { LedgerEntryChanges txChangesBefore; // tx level changes before operations // are applied if any OperationMeta operations<>; // meta for each operation LedgerEntryChanges txChangesAfter; // tx level changes after operations are // applied if any };
XDR Source: struct TransactionMetaV3 { ExtensionPoint ext;
XDR Source: struct TransactionMetaV4 { ExtensionPoint ext;
XDR Source: union TransactionMeta switch (int v) { case 0: OperationMeta operations<>; case 1: TransactionMetaV1 v1; case 2: TransactionMetaV2 v2; case 3: TransactionMetaV3 v3; case 4: TransactionMetaV4 v4; };
XDR Source: union TransactionPhase switch (int v) { case 0: TxSetComponent v0Components<>; case 1: ParallelTxsComponent parallelTxsComponent; };
XDR Source: enum TransactionResultCode { txFEE_BUMP_INNER_SUCCESS = 1, // fee bump inner transaction succeeded txSUCCESS = 0, // all operations succeeded
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct TransactionResultMetaV1 { ExtensionPoint ext;
XDR Source: struct TransactionResultMeta { TransactionResultPair result; LedgerEntryChanges feeProcessing; TransactionMeta txApplyProcessing; };
XDR Source: struct TransactionResultPair { Hash transactionHash; TransactionResult result; // result for the transaction };
XDR Source: union switch (TransactionResultCode code) { case txFEE_BUMP_INNER_SUCCESS: case txFEE_BUMP_INNER_FAILED: InnerTransactionResultPair innerResultPair; case txSUCCESS: case txFAILED: OperationResult results<>; case txTOO_EARLY: case txTOO_LATE: case txMISSING_OPERATION: case txBAD_SEQ: case txBAD_AUTH: case txINSUFFICIENT_BALANCE: case txNO_ACCOUNT: case txINSUFFICIENT_FEE: case txBAD_AUTH_EXTRA: case txINTERNAL_ERROR: case txNOT_SUPPORTED: // case txFEE_BUMP_INNER_FAILED: handled above case txBAD_SPONSORSHIP: case txBAD_MIN_SEQ_AGE_OR_GAP: case txMALFORMED: case txSOROBAN_INVALID: case txFROZEN_KEY_ACCESSED: void; }
XDR Source: struct TransactionResultSet { TransactionResultPair results<>; };
XDR Source: struct TransactionResult { int64 feeCharged; // actual fee charged for the transaction
XDR Source: struct TransactionSetV1 { Hash previousLedgerHash; TransactionPhase phases<>; };
XDR Source: struct TransactionSet { Hash previousLedgerHash; TransactionEnvelope txs<>; };
XDR Source: union switch (EnvelopeType type) { // Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0 case ENVELOPE_TYPE_TX: Transaction tx; case ENVELOPE_TYPE_TX_FEE_BUMP: FeeBumpTransaction feeBump; }
XDR Source: struct TransactionSignaturePayload { Hash networkId; union switch (EnvelopeType type) { // Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0 case ENVELOPE_TYPE_TX: Transaction tx; case ENVELOPE_TYPE_TX_FEE_BUMP: FeeBumpTransaction feeBump; } taggedTransaction; };
XDR Source: struct TransactionV0Envelope { TransactionV0 tx; /* Each decorated signature is a signature over the SHA256 hash of * a TransactionSignaturePayload */ DecoratedSignature signatures<20>; };
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct TransactionV0 { uint256 sourceAccountEd25519; uint32 fee; SequenceNumber seqNum; TimeBounds* timeBounds; Memo memo; Operation operations
XDR Source: struct TransactionV1Envelope { Transaction tx; /* Each decorated signature is a signature over the SHA256 hash of * a TransactionSignaturePayload */ DecoratedSignature signatures<20>; };
XDR Source: struct Transaction { // account used to run the transaction MuxedAccount sourceAccount;
XDR Source: union TrustLineAsset switch (AssetType type) { case ASSET_TYPE_NATIVE: // Not credit void;
XDR Source: union switch (int v) { case 0: void; }
XDR Source: struct TrustLineEntryExtensionV2 { int32 liquidityPoolUseCount;
XDR Source: union switch (int v) { case 0: void; case 1: struct { Liabilities liabilities;
XDR Source: union switch (int v) { case 0: void; case 2: TrustLineEntryExtensionV2 v2; }
XDR Source: struct { Liabilities liabilities;
XDR Source: struct TrustLineEntry { AccountID accountID; // account this trustline belongs to TrustLineAsset asset; // type of asset (with issuer) int64 balance; // how much of this asset the user has. // Asset defines the unit for this;
XDR Source: enum TrustLineFlags { // issuer has authorized account to perform transactions with its credit AUTHORIZED_FLAG = 1, // issuer has authorized account to maintain and reduce liabilities for its // credit AUTHORIZED_TO_MAINTAIN_LIABILITIES_FLAG = 2, // issuer has specified that it may clawback its credit, and that claimable // balances created with its credit may also be clawed back TRUSTLINE_CLAWBACK_ENABLED_FLAG = 4 };
XDR Source: struct TTLEntry { // Hash of the LedgerKey that is associated with this TTLEntry Hash keyHash; uint32 liveUntilLedgerSeq; };
XDR Source: struct { int64* baseFee; TransactionEnvelope txs<>; }
XDR Source: enum TxSetComponentType { // txs with effective fee <= bid derived from a base fee (if any). // If base fee is not specified, no discount is applied. TXSET_COMP_TXS_MAYBE_DISCOUNTED_FEE = 0 };
XDR Source: union TxSetComponent switch (TxSetComponentType type) { case TXSET_COMP_TXS_MAYBE_DISCOUNTED_FEE: struct { int64* baseFee; TransactionEnvelope txs<>; } txsMaybeDiscountedFee; };
XDR Source: struct UInt128Parts { uint64 hi; uint64 lo; };
XDR Source: struct UInt256Parts { uint64 hi_hi; uint64 hi_lo; uint64 lo_hi; uint64 lo_lo; };
XDR Source: typedef opaque uint25632;
XDR Source: struct UpgradeEntryMeta { LedgerUpgrade upgrade; LedgerEntryChanges changes; };
XDR Source: typedef opaque UpgradeType<128>;
Properties
The executable tag as text.
Functions
Builds a ContractExecutableExternalRefXdr whose tag bytes are the UTF-8 encoding of tag.
Decodes a ContractEventXdr from a base64 string.
Decodes a DiagnosticEventXdr from a base64 string.
Decodes a HostFunctionXdr from a base64 string.
Decodes a LedgerCloseMetaXdr from a base64 string.
Decodes a LedgerEntryDataXdr from a base64 string.
Decodes a LedgerEntryXdr from a base64 string.
Decodes a LedgerHeaderHistoryEntryXdr from a base64 string.
Decodes a LedgerKeyXdr from a base64 string.
Decodes a SCValXdr from a base64 string.
Decodes a SorobanAuthorizationEntryXdr from a base64 string.
Decodes a SorobanTransactionDataXdr from a base64 string.
Decodes a TransactionEnvelopeXdr from a base64 string.
Decodes a TransactionEventXdr from a base64 string.
Decodes a TransactionMetaXdr from a base64 string.
Decodes a TransactionResultXdr from a base64 string.
Encodes this XDR object to a base64 string.