// Copyright 2015 Stellar Development Foundation and contributors. Licensed // under the Apache License, Version 2.0. See the COPYING file at the root // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 %#include "xdr/Stellar-ledger-entries.h" namespace stellar { struct DecoratedSignature { SignatureHint hint; // last 4 bytes of the public key, used as a hint Signature signature; // actual signature }; enum OperationType { CREATE_ACCOUNT = 0, PAYMENT = 1, PATH_PAYMENT = 2, MANAGE_OFFER = 3, CREATE_PASSIVE_OFFER = 4, SET_OPTIONS = 5, CHANGE_TRUST = 6, ALLOW_TRUST = 7, ACCOUNT_MERGE = 8, INFLATION = 9, MANAGE_DATA = 10, // thuannd start: comment old code //BUMP_SEQUENCE = 11 // thuannd end // thuannd start: add new Operation Type BUMP_SEQUENCE = 11, CREATE_CONTRACT = 12, CALL_CONTRACT = 13, SEND_ASSET = 14, CHECK_CONTRACT = 15 // TRANSFER_ASSET = 15, // CHECK_CONTRACT = 16 // thuannd end }; /* CreateAccount Creates and funds a new account with the specified starting balance. Threshold: med Result: CreateAccountResult */ struct CreateAccountOp { AccountID destination; // account to create int64 startingBalance; // amount they end up with }; /* Payment Send an amount in specified asset to a destination account. Threshold: med Result: PaymentResult */ struct PaymentOp { AccountID destination; // recipient of the payment Asset asset; // what they end up with int64 amount; // amount they end up with }; /* PathPayment send an amount to a destination account through a path. (up to sendMax, sendAsset) (X0, Path[0]) .. (Xn, Path[n]) (destAmount, destAsset) Threshold: med Result: PathPaymentResult */ struct PathPaymentOp { 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 AccountID destination; // recipient of the payment Asset destAsset; // what they end up with int64 destAmount; // amount they end up with Asset path<5>; // additional hops it must go through to get there }; /* Creates, updates or deletes an offer Threshold: med Result: ManageOfferResult */ struct ManageOfferOp { 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 // 0=create a new offer, otherwise edit an existing offer uint64 offerID; }; /* Creates an offer that doesn't take offers of the same price Threshold: med Result: CreatePassiveOfferResult */ struct CreatePassiveOfferOp { Asset selling; // A Asset buying; // B int64 amount; // amount taker gets. if set to 0, delete the offer Price price; // cost of A in terms of B }; /* Set Account Options updates "AccountEntry" fields. note: updating thresholds or signers requires high threshold Threshold: med or high Result: SetOptionsResult */ struct SetOptionsOp { AccountID* inflationDest; // sets the inflation destination uint32* clearFlags; // which flags to clear uint32* setFlags; // which flags to set // account threshold manipulation uint32* masterWeight; // weight of the master account uint32* lowThreshold; uint32* medThreshold; uint32* highThreshold; string32* homeDomain; // sets the home domain // Add, update or remove a signer for the account // signer is deleted if the weight is 0 Signer* signer; }; /* Creates, updates or deletes a trust line Threshold: med Result: ChangeTrustResult */ struct ChangeTrustOp { Asset line; // if limit is set to 0, deletes the trust line int64 limit; }; /* Updates the "authorized" flag of an existing trust line this is called by the issuer of the related asset. note that authorize can only be set (and not cleared) if the issuer account does not have the AUTH_REVOCABLE_FLAG set Threshold: low Result: AllowTrustResult */ struct AllowTrustOp { AccountID trustor; union switch (AssetType type) { // ASSET_TYPE_NATIVE is not allowed case ASSET_TYPE_CREDIT_ALPHANUM4: opaque assetCode4[4]; case ASSET_TYPE_CREDIT_ALPHANUM12: opaque assetCode12[12]; // add other asset types here in the future } asset; bool authorize; }; /* Inflation Runs inflation Threshold: low Result: InflationResult */ /* AccountMerge Transfers native balance to destination account. Threshold: high Result : AccountMergeResult */ /* ManageData Adds, Updates, or Deletes a key value pair associated with a particular account. Threshold: med Result: ManageDataResult */ struct ManageDataOp { string64 dataName; DataValue* dataValue; // set to null to clear }; /* Bump Sequence increases the sequence to a given level Threshold: low Result: BumpSequenceResult */ struct BumpSequenceOp { SequenceNumber bumpTo; }; // thuannd start: add new operation struct /* CreateContract Creates new contract is used to hold asset and data of contract. Threshold: med Result: CreateContractResult */ struct CreateContractOp { ContractID contractId; // auto gen by core based on a file that is gotten from url int64 startingBalance; // amount they end up with string128 contractAddr; // address of contract ContractInput data; // data for contract string256 state; // state that is returned from smart contract host }; /* SendAsset Send asset to a contract. Threshold: med Result: SendAssetResult */ struct SendAssetOp { ContractID contractId; // a public key of the contract Asset asset; // what they end up with int64 amount; // amount they end up with string256 state; // state that is returned from smart contract host }; ///* TransferAsset // Transfer asset from the contract to destination. // Threshold: med // Result: TransferAssetResult //*/ //struct TransferAssetOp //{ // AccountID destination; // recipient of the payment // Asset asset; // what they end up with // int64 amount; // amount they end up with //}; /* CheckContract Check whether a transaction has all the contracts or not. Threshold: med Result: CheckContractResult */ struct CheckContractOp { int32 isContract; // check isContract }; //========CallContract========================= /* Check Check amount of source account. Threshold: med Result: CheckResult */ struct Check { AccountID sourceAccId; int64 amount; string32 op; }; /* Invoke Update new state into the ContractState table. Threshold: med Result: InvokeResult */ struct Invoke { string256 newState; }; /* Query Get data that are returned from docker and send them to the user. Threshold: med Result: QueryResult */ struct Query { string256 data; }; /* Transfer Transfer asset from the contract to destination. Threshold: med Result: TransferResult */ struct Transfer { AccountID destination; // recipient of the payment Asset asset; // what they end up with int64 amount; // amount they end up with }; enum ContrOperationType { CHECK = 0, INVOKE = 1, QUERY = 2, TRANSFER = 3, }; /* An contract operation is defined for CallContractOp */ struct ContrOperation { union switch (ContrOperationType type) { case CHECK: Check check; case INVOKE: Invoke invoke; case QUERY: Query query; case TRANSFER: Transfer transfer; } body; }; //===========CallContract=================== /* CallContract Call the contract that was created. Threshold: med Result: CallContractResult */ struct CallContractOp { ContractID contractId; // a public key of the contract ContractInput data; // data for contract //Check check; //Invoke invoke; //Query query; //Transfer transfer; ContrOperation contrOps<100>; }; // thuannd end /* An operation is the lowest unit of work that a transaction does */ struct Operation { // sourceAccount is the account used to run the operation // if not set, the runtime defaults to "sourceAccount" specified at // the transaction level AccountID* sourceAccount; union switch (OperationType type) { case CREATE_ACCOUNT: CreateAccountOp createAccountOp; case PAYMENT: PaymentOp paymentOp; case PATH_PAYMENT: PathPaymentOp pathPaymentOp; case MANAGE_OFFER: ManageOfferOp manageOfferOp; case CREATE_PASSIVE_OFFER: CreatePassiveOfferOp createPassiveOfferOp; case SET_OPTIONS: SetOptionsOp setOptionsOp; case CHANGE_TRUST: ChangeTrustOp changeTrustOp; case ALLOW_TRUST: AllowTrustOp allowTrustOp; case ACCOUNT_MERGE: AccountID destination; case INFLATION: void; case MANAGE_DATA: ManageDataOp manageDataOp; case BUMP_SEQUENCE: BumpSequenceOp bumpSequenceOp; // thuannd start: add new operation type for the contract case CREATE_CONTRACT: CreateContractOp createContractOp; case CALL_CONTRACT: CallContractOp callContractOp; case SEND_ASSET: SendAssetOp sendAssetOp; // case TRANSFER_ASSET: // TransferAssetOp transferAssetOp; case CHECK_CONTRACT: CheckContractOp checkContractOp; // thuannd end. } body; }; enum MemoType { MEMO_NONE = 0, MEMO_TEXT = 1, MEMO_ID = 2, MEMO_HASH = 3, MEMO_RETURN = 4 }; 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 }; struct TimeBounds { uint64 minTime; uint64 maxTime; // 0 here means no maxTime }; /* a transaction is a container for a set of operations - is executed by an account - fees are collected from the account - operations are executed in order as one ACID transaction either all operations are applied or none are if any returns a failing code */ struct Transaction { // account used to run the transaction AccountID sourceAccount; // the fee the sourceAccount will pay uint32 fee; // sequence number to consume in the account SequenceNumber seqNum; // validity range (inclusive) for the last ledger close time TimeBounds* timeBounds; Memo memo; Operation operations<100>; // reserved for future use union switch (int v) { case 0: void; } ext; }; struct TransactionSignaturePayload { Hash networkId; union switch (EnvelopeType type) { case ENVELOPE_TYPE_TX: Transaction tx; /* All other values of type are invalid */ } taggedTransaction; }; /* A TransactionEnvelope wraps a transaction with signatures. */ struct TransactionEnvelope { Transaction tx; /* Each decorated signature is a signature over the SHA256 hash of * a TransactionSignaturePayload */ DecoratedSignature signatures<20>; }; /* Operation Results section */ /* This result is used when offers are taken during an operation */ struct ClaimOfferAtom { // emitted to identify the offer AccountID sellerID; // Account that owns the offer uint64 offerID; // amount and asset taken from the owner Asset assetSold; int64 amountSold; // amount and asset sent to the owner Asset assetBought; int64 amountBought; }; /******* CreateAccount Result ********/ enum CreateAccountResultCode { // codes considered as "success" for the operation CREATE_ACCOUNT_SUCCESS = 0, // account was created // codes considered as "failure" for the operation CREATE_ACCOUNT_MALFORMED = -1, // invalid destination CREATE_ACCOUNT_UNDERFUNDED = -2, // not enough funds in source account CREATE_ACCOUNT_LOW_RESERVE = -3, // would create an account below the min reserve CREATE_ACCOUNT_ALREADY_EXIST = -4 // account already exists }; union CreateAccountResult switch (CreateAccountResultCode code) { case CREATE_ACCOUNT_SUCCESS: void; default: void; }; /******* Payment Result ********/ enum PaymentResultCode { // codes considered as "success" for the operation PAYMENT_SUCCESS = 0, // payment successfuly completed // codes considered as "failure" for the operation PAYMENT_MALFORMED = -1, // bad input PAYMENT_UNDERFUNDED = -2, // not enough funds in source account PAYMENT_SRC_NO_TRUST = -3, // no trust line on source account PAYMENT_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer PAYMENT_NO_DESTINATION = -5, // destination account does not exist PAYMENT_NO_TRUST = -6, // destination missing a trust line for asset PAYMENT_NOT_AUTHORIZED = -7, // destination not authorized to hold asset PAYMENT_LINE_FULL = -8, // destination would go above their limit PAYMENT_NO_ISSUER = -9 // missing issuer on asset }; union PaymentResult switch (PaymentResultCode code) { case PAYMENT_SUCCESS: void; default: void; }; /******* Payment Result ********/ enum PathPaymentResultCode { // codes considered as "success" for the operation PATH_PAYMENT_SUCCESS = 0, // success // codes considered as "failure" for the operation PATH_PAYMENT_MALFORMED = -1, // bad input PATH_PAYMENT_UNDERFUNDED = -2, // not enough funds in source account PATH_PAYMENT_SRC_NO_TRUST = -3, // no trust line on source account PATH_PAYMENT_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer PATH_PAYMENT_NO_DESTINATION = -5, // destination account does not exist PATH_PAYMENT_NO_TRUST = -6, // dest missing a trust line for asset PATH_PAYMENT_NOT_AUTHORIZED = -7, // dest not authorized to hold asset PATH_PAYMENT_LINE_FULL = -8, // dest would go above their limit PATH_PAYMENT_NO_ISSUER = -9, // missing issuer on one asset PATH_PAYMENT_TOO_FEW_OFFERS = -10, // not enough offers to satisfy path PATH_PAYMENT_OFFER_CROSS_SELF = -11, // would cross one of its own offers PATH_PAYMENT_OVER_SENDMAX = -12 // could not satisfy sendmax }; struct SimplePaymentResult { AccountID destination; Asset asset; int64 amount; }; union PathPaymentResult switch (PathPaymentResultCode code) { case PATH_PAYMENT_SUCCESS: struct { ClaimOfferAtom offers<>; SimplePaymentResult last; } success; case PATH_PAYMENT_NO_ISSUER: Asset noIssuer; // the asset that caused the error default: void; }; /******* ManageOffer Result ********/ enum ManageOfferResultCode { // codes considered as "success" for the operation MANAGE_OFFER_SUCCESS = 0, // codes considered as "failure" for the operation MANAGE_OFFER_MALFORMED = -1, // generated offer would be invalid MANAGE_OFFER_SELL_NO_TRUST = -2, // no trust line for what we're selling MANAGE_OFFER_BUY_NO_TRUST = -3, // no trust line for what we're buying MANAGE_OFFER_SELL_NOT_AUTHORIZED = -4, // not authorized to sell MANAGE_OFFER_BUY_NOT_AUTHORIZED = -5, // not authorized to buy MANAGE_OFFER_LINE_FULL = -6, // can't receive more of what it's buying MANAGE_OFFER_UNDERFUNDED = -7, // doesn't hold what it's trying to sell MANAGE_OFFER_CROSS_SELF = -8, // would cross an offer from the same user MANAGE_OFFER_SELL_NO_ISSUER = -9, // no issuer for what we're selling MANAGE_OFFER_BUY_NO_ISSUER = -10, // no issuer for what we're buying // update errors MANAGE_OFFER_NOT_FOUND = -11, // offerID does not match an existing offer MANAGE_OFFER_LOW_RESERVE = -12 // not enough funds to create a new Offer }; enum ManageOfferEffect { MANAGE_OFFER_CREATED = 0, MANAGE_OFFER_UPDATED = 1, MANAGE_OFFER_DELETED = 2 }; struct ManageOfferSuccessResult { // offers that got claimed while creating this offer ClaimOfferAtom offersClaimed<>; union switch (ManageOfferEffect effect) { case MANAGE_OFFER_CREATED: case MANAGE_OFFER_UPDATED: OfferEntry offer; default: void; } offer; }; union ManageOfferResult switch (ManageOfferResultCode code) { case MANAGE_OFFER_SUCCESS: ManageOfferSuccessResult success; default: void; }; /******* SetOptions Result ********/ 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 }; union SetOptionsResult switch (SetOptionsResultCode code) { case SET_OPTIONS_SUCCESS: void; default: void; }; /******* ChangeTrust Result ********/ 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 }; union ChangeTrustResult switch (ChangeTrustResultCode code) { case CHANGE_TRUST_SUCCESS: void; default: void; }; /******* AllowTrust Result ********/ 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 }; union AllowTrustResult switch (AllowTrustResultCode code) { case ALLOW_TRUST_SUCCESS: void; default: void; }; /******* AccountMerge Result ********/ 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 }; union AccountMergeResult switch (AccountMergeResultCode code) { case ACCOUNT_MERGE_SUCCESS: int64 sourceAccountBalance; // how much got transfered from source account default: void; }; /******* Inflation Result ********/ enum InflationResultCode { // codes considered as "success" for the operation INFLATION_SUCCESS = 0, // codes considered as "failure" for the operation INFLATION_NOT_TIME = -1 }; struct InflationPayout // or use PaymentResultAtom to limit types? { AccountID destination; int64 amount; }; union InflationResult switch (InflationResultCode code) { case INFLATION_SUCCESS: InflationPayout payouts<>; default: void; }; /******* ManageData Result ********/ 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 }; union ManageDataResult switch (ManageDataResultCode code) { case MANAGE_DATA_SUCCESS: void; default: void; }; /******* BumpSequence Result ********/ 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 }; union BumpSequenceResult switch (BumpSequenceResultCode code) { case BUMP_SEQUENCE_SUCCESS: void; default: void; }; // thuannd start: add new operation result /******* CreateContract Result ********/ enum CreateContractResultCode { // codes considered as "success" for the operation CREATE_CONTRACT_SUCCESS = 0, // contract was created // codes considered as "failure" for the operation CREATE_CONTRACT_MALFORMED = -1, // invalid destination CREATE_CONTRACT_UNDERFUNDED = -2, // not enough funds in source account // would create an contract below the min reserve CREATE_CONTRACT_LOW_RESERVE = -3, CREATE_CONTRACT_ALREADY_EXIST = -4 // contract already exists }; union CreateContractResult switch (CreateContractResultCode code) { case CREATE_CONTRACT_SUCCESS: void; default: void; }; /******* SendAsset Result ********/ enum SendAssetResultCode { // codes considered as "success" for the operation SEND_ASSET_SUCCESS = 0, // sendAsset successfuly completed // codes considered as "failure" for the operation SEND_ASSET_MALFORMED = -1, // bad input SEND_ASSET_UNDERFUNDED = -2, // not enough funds in source account SEND_ASSET_SRC_NO_TRUST = -3, // no trust line on source account SEND_ASSET_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer SEND_ASSET_NO_DESTINATION = -5, // contract does not exist SEND_ASSET_NO_TRUST = -6, // contract missing a trust line for asset SEND_ASSET_NOT_AUTHORIZED = -7, // contract not authorized to hold asset SEND_ASSET_LINE_FULL = -8, // contract would go above their limit SEND_ASSET_NO_ISSUER = -9, // missing issuer on asset SEND_ASSET_NO_CONTRACT_STATE = -10 // contractState does not exist }; union SendAssetResult switch (SendAssetResultCode code) { case SEND_ASSET_SUCCESS: void; default: void; }; /******* CallContract Result ********/ enum CallContractResultCode { // codes considered as "success" for the operation CALL_CONTRACT_SUCCESS = 0, // callContract successfuly completed // codes considered as "failure" for the operation CALL_CONTRACT_MALFORMED = -1, // bad input CALL_CONTRACT_NO_CONTRACT_STATE = -2, // CALL_CONTRACT_CHECK_AMOUNT = -3, // CALL_CONTRACT_UNDERFUNDED = -4, // CALL_CONTRACT_SRC_NO_TRUST = -5, // CALL_CONTRACT_SRC_NOT_AUTHORIZED = -6, // CALL_CONTRACT_NO_DESTINATION = -7, // CALL_CONTRACT_NO_TRUST = -8, // CALL_CONTRACT_NOT_AUTHORIZED = -9, // CALL_CONTRACT_LINE_FULL = -10, // CALL_CONTRACT_NO_ISSUER = -11, // CALL_CONTRACT_OVER_SENDMAX = -12 // }; union CallContractResult switch (CallContractResultCode code) { case CALL_CONTRACT_SUCCESS: void; default: void; }; ///******* TransferAsset Result ********/ //enum TransferAssetResultCode //{ // // codes considered as "success" for the operation // TRANSFER_ASSET_SUCCESS = 0, // transferAsset successfuly completed // // codes considered as "failure" for the operation // TRANSFER_ASSET_MALFORMED = -1, // bad input // TRANSFER_ASSET_UNDERFUNDED = -2, // not enough funds in contract // TRANSFER_ASSET_SRC_NO_TRUST = -3, // no trust line on contract // TRANSFER_ASSET_SRC_NOT_AUTHORIZED = -4, // contract not authorized to transfer // TRANSFER_ASSET_NO_DESTINATION = -5, // destination does not exist // TRANSFER_ASSET_NO_TRUST = -6, // destination missing a trust line for asset // TRANSFER_ASSET_NOT_AUTHORIZED = -7, // destination not authorized to hold asset // TRANSFER_ASSET_LINE_FULL = -8, // destination would go above their limit // TRANSFER_ASSET_NO_ISSUER = -9 // missing issuer on asset //}; //union TransferAssetResult switch (TransferAssetResultCode code) //{ //case TRANSFER_ASSET_SUCCESS: // void; //default: // void; //}; /******* CheckContract Result ********/ enum CheckContractResultCode { // codes considered as "success" for the operation CHECK_CONTRACT_SUCCESS = 0, // account was created // codes considered as "failure" for the operation CHECK_CONTRACT_MALFORMED = -1 // invalid destination }; union CheckContractResult switch (CheckContractResultCode code) { case CHECK_CONTRACT_SUCCESS: void; default: void; }; // thuannd end /* High level Operation Result */ enum OperationResultCode { opINNER = 0, // inner object result is valid opBAD_AUTH = -1, // too few valid signatures / wrong network opNO_ACCOUNT = -2, // source account was not found opNOT_SUPPORTED = -3 // operation not supported at this time }; union OperationResult switch (OperationResultCode code) { case opINNER: union switch (OperationType type) { case CREATE_ACCOUNT: CreateAccountResult createAccountResult; case PAYMENT: PaymentResult paymentResult; case PATH_PAYMENT: PathPaymentResult pathPaymentResult; case MANAGE_OFFER: ManageOfferResult manageOfferResult; case CREATE_PASSIVE_OFFER: ManageOfferResult createPassiveOfferResult; 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; // thuannd start: add new operation type for contract case CREATE_CONTRACT: CreateContractResult createContractResult; case CALL_CONTRACT: CallContractResult callContractResult; case SEND_ASSET: SendAssetResult sendAssetResult; // case TRANSFER_ASSET: // TransferAssetResult transferAssetResult; case CHECK_CONTRACT: CheckContractResult checkContractResult; // thuannd end } tr; default: void; }; enum TransactionResultCode { txSUCCESS = 0, // all operations succeeded txFAILED = -1, // one of the operations failed (none were applied) txTOO_EARLY = -2, // ledger closeTime before minTime txTOO_LATE = -3, // ledger closeTime after maxTime txMISSING_OPERATION = -4, // no operation was specified txBAD_SEQ = -5, // sequence number does not match source account txBAD_AUTH = -6, // too few valid signatures / wrong network txINSUFFICIENT_BALANCE = -7, // fee would bring account below reserve txNO_ACCOUNT = -8, // source account not found txINSUFFICIENT_FEE = -9, // fee is too small txBAD_AUTH_EXTRA = -10, // unused signatures attached to transaction txINTERNAL_ERROR = -11 // an unknown error occured }; struct TransactionResult { int64 feeCharged; // actual fee charged for the transaction union switch (TransactionResultCode code) { case txSUCCESS: case txFAILED: OperationResult results<>; default: void; } result; // reserved for future use union switch (int v) { case 0: void; } ext; }; }