algosdk 2.9.0 → 3.0.0-beta.1

package/dist/esm/transaction.js

@@ -1,913 +1,568 @@
-import { Buffer } from 'buffer';
 import base32 from 'hi-base32';
-import * as address from './encoding/address';
-import * as encoding from './encoding/encoding';
-import * as nacl from './nacl/naclWrappers';
-import * as utils from './utils/utils';
-import { translateBoxReferences } from './boxStorage';
-import { TransactionType, isTransactionType, } from './types/transactions/base';
+import { boxReferencesToEncodingData } from './boxStorage.js';
+import { Address } from './encoding/address.js';
+import * as encoding from './encoding/encoding.js';
+import { AddressSchema, Uint64Schema, ByteArraySchema, FixedLengthByteArraySchema, StringSchema, ArraySchema, NamedMapSchema, BooleanSchema, OptionalSchema, allOmitEmpty, } from './encoding/schema/index.js';
+import * as nacl from './nacl/naclWrappers.js';
+import { isOnApplicationComplete, TransactionType, isTransactionType, } from './types/transactions/base.js';
+import { StateProof, StateProofMessage } from './stateproof.js';
+import * as utils from './utils/utils.js';
 const ALGORAND_TRANSACTION_LENGTH = 52;
-export const ALGORAND_MIN_TX_FEE = 1000; // version v5
 const ALGORAND_TRANSACTION_LEASE_LENGTH = 32;
-const ALGORAND_MAX_ASSET_DECIMALS = 19;
 const NUM_ADDL_BYTES_AFTER_SIGNING = 75; // NUM_ADDL_BYTES_AFTER_SIGNING is the number of bytes added to a txn after signing it
-const ALGORAND_TRANSACTION_LEASE_LABEL_LENGTH = 5;
-const ALGORAND_TRANSACTION_ADDRESS_LENGTH = 32;
-const ALGORAND_TRANSACTION_REKEY_LABEL_LENGTH = 5;
 const ASSET_METADATA_HASH_LENGTH = 32;
 const KEYREG_VOTE_KEY_LENGTH = 32;
 const KEYREG_SELECTION_KEY_LENGTH = 32;
 const KEYREG_STATE_PROOF_KEY_LENGTH = 64;
+const ALGORAND_TRANSACTION_GROUP_LENGTH = 32;
+function uint8ArrayIsEmpty(input) {
+    return input.every((value) => value === 0);
+}
 function getKeyregKey(input, inputName, length) {
     if (input == null) {
         return undefined;
     }
-    let inputAsBuffer;
+    let inputBytes;
+    if (input instanceof Uint8Array) {
+        inputBytes = input;
+    }
+    if (inputBytes == null || inputBytes.byteLength !== length) {
+        throw Error(`${inputName} must be a ${length} byte Uint8Array`);
+    }
+    return inputBytes;
+}
+function ensureAddress(input) {
+    if (input == null) {
+        throw new Error('Address must not be null or undefined');
+    }
     if (typeof input === 'string') {
-        inputAsBuffer = Buffer.from(input, 'base64');
+        return Address.fromString(input);
+    }
+    if (input instanceof Address) {
+        return input;
+    }
+    throw new Error(`Not an address: ${input}`);
+}
+function optionalAddress(input) {
+    if (input == null) {
+        return undefined;
+    }
+    let addr;
+    if (input instanceof Address) {
+        addr = input;
+    }
+    else if (typeof input === 'string') {
+        addr = Address.fromString(input);
+    }
+    else {
+        throw new Error(`Not an address: ${input}`);
+    }
+    if (uint8ArrayIsEmpty(addr.publicKey)) {
+        // If it's the zero address, throw an error so that the user won't be surprised that this gets dropped
+        throw new Error('Invalid use of the zero address. To omit this value, pass in undefined');
+    }
+    return addr;
+}
+function optionalUint8Array(input) {
+    if (typeof input === 'undefined') {
+        return undefined;
+    }
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    throw new Error(`Not a Uint8Array: ${input}`);
+}
+function ensureUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    throw new Error(`Not a Uint8Array: ${input}`);
+}
+function optionalUint64(input) {
+    if (typeof input === 'undefined') {
+        return undefined;
+    }
+    return utils.ensureUint64(input);
+}
+function ensureBoolean(input) {
+    if (input === true || input === false) {
+        return input;
+    }
+    throw new Error(`Not a boolean: ${input}`);
+}
+function ensureArray(input) {
+    if (Array.isArray(input)) {
+        return input.slice();
+    }
+    throw new Error(`Not an array: ${input}`);
+}
+function optionalFixedLengthByteArray(input, length, name) {
+    const bytes = optionalUint8Array(input);
+    if (typeof bytes === 'undefined') {
+        return undefined;
     }
-    else if (input.constructor === Uint8Array) {
-        inputAsBuffer = Buffer.from(input);
+    if (bytes.byteLength !== length) {
+        throw new Error(`${name} must be ${length} bytes long, was ${bytes.byteLength}`);
     }
-    else if (Buffer.isBuffer(input)) {
-        inputAsBuffer = input;
+    if (uint8ArrayIsEmpty(bytes)) {
+        // if contains all 0s, omit it
+        return undefined;
     }
-    if (inputAsBuffer == null || inputAsBuffer.byteLength !== length) {
-        throw Error(`${inputName} must be a ${length} byte Uint8Array or Buffer or base64 string.`);
+    return bytes;
+}
+function ensureBoxReference(input) {
+    if (input != null && typeof input === 'object') {
+        const { appIndex, name } = input;
+        return {
+            appIndex: utils.ensureUint64(appIndex),
+            name: ensureUint8Array(name),
+        };
     }
-    return inputAsBuffer;
+    throw new Error(`Not a box reference: ${input}`);
 }
+const TX_TAG = new TextEncoder().encode('TX');
 /**
  * Transaction enables construction of Algorand transactions
  * */
 export class Transaction {
-    constructor({ ...transaction }) {
-        this.name = 'Transaction';
-        this.tag = Buffer.from('TX');
-        // Populate defaults
-        /* eslint-disable no-param-reassign */
-        const defaults = {
-            type: TransactionType.pay,
-            flatFee: false,
-            nonParticipation: false,
-        };
-        // Default type
-        if (typeof transaction.type === 'undefined') {
-            transaction.type = defaults.type;
-        }
-        // Default flatFee
-        if (typeof transaction.flatFee ===
-            'undefined') {
-            transaction.flatFee =
-                defaults.flatFee;
-        }
-        // Default nonParticipation
-        if (transaction.type === TransactionType.keyreg &&
-            typeof transaction.voteKey !== 'undefined' &&
-            typeof transaction.nonParticipation === 'undefined') {
-            transaction.nonParticipation = defaults.nonParticipation;
-        }
-        /* eslint-enable no-param-reassign */
-        // Move suggested parameters from its object to inline
-        if (transaction.suggestedParams !== undefined) {
-            // Create a temporary reference to the transaction object that has params inline and also as a suggested params object
-            //   - Helpful for moving params from named object to inline
-            const reference = transaction;
-            reference.genesisHash = reference.suggestedParams.genesisHash;
-            reference.fee = reference.suggestedParams.fee;
-            if (reference.suggestedParams.flatFee !== undefined)
-                reference.flatFee = reference.suggestedParams.flatFee;
-            reference.firstRound = reference.suggestedParams.firstRound;
-            reference.lastRound = reference.suggestedParams.lastRound;
-            reference.genesisID = reference.suggestedParams.genesisID;
-        }
-        // At this point all suggestedParams have been moved to be inline, so we can reassign the transaction object type
-        // to one which is more useful as we prepare properties for storing
-        const txn = transaction;
-        txn.from = address.decodeAddress(txn.from);
-        if (txn.to !== undefined)
-            txn.to = address.decodeAddress(txn.to);
-        if (txn.closeRemainderTo !== undefined)
-            txn.closeRemainderTo = address.decodeAddress(txn.closeRemainderTo);
-        if (txn.assetManager !== undefined)
-            txn.assetManager = address.decodeAddress(txn.assetManager);
-        if (txn.assetReserve !== undefined)
-            txn.assetReserve = address.decodeAddress(txn.assetReserve);
-        if (txn.assetFreeze !== undefined)
-            txn.assetFreeze = address.decodeAddress(txn.assetFreeze);
-        if (txn.assetClawback !== undefined)
-            txn.assetClawback = address.decodeAddress(txn.assetClawback);
-        if (txn.assetRevocationTarget !== undefined)
-            txn.assetRevocationTarget = address.decodeAddress(txn.assetRevocationTarget);
-        if (txn.freezeAccount !== undefined)
-            txn.freezeAccount = address.decodeAddress(txn.freezeAccount);
-        if (txn.reKeyTo !== undefined)
-            txn.reKeyTo = address.decodeAddress(txn.reKeyTo);
-        if (txn.genesisHash === undefined)
-            throw Error('genesis hash must be specified and in a base64 string.');
-        txn.genesisHash = Buffer.from(txn.genesisHash, 'base64');
-        if (txn.amount !== undefined &&
-            (!(Number.isSafeInteger(txn.amount) ||
-                (typeof txn.amount === 'bigint' &&
-                    txn.amount <= BigInt('0xffffffffffffffff'))) ||
-                txn.amount < 0))
-            throw Error('Amount must be a positive number and smaller than 2^64-1. If the number is larger than 2^53-1, use bigint.');
-        if (!Number.isSafeInteger(txn.fee) || txn.fee < 0)
-            throw Error('fee must be a positive number and smaller than 2^53-1');
-        if (!Number.isSafeInteger(txn.firstRound) || txn.firstRound < 0)
-            throw Error('firstRound must be a positive number');
-        if (!Number.isSafeInteger(txn.lastRound) || txn.lastRound < 0)
-            throw Error('lastRound must be a positive number');
-        if (txn.extraPages !== undefined &&
-            (!Number.isInteger(txn.extraPages) ||
-                txn.extraPages < 0 ||
-                txn.extraPages > 3))
-            throw Error('extraPages must be an Integer between and including 0 to 3');
-        if (txn.assetTotal !== undefined &&
-            (!(Number.isSafeInteger(txn.assetTotal) ||
-                (typeof txn.assetTotal === 'bigint' &&
-                    txn.assetTotal <= BigInt('0xffffffffffffffff'))) ||
-                txn.assetTotal < 0))
-            throw Error('Total asset issuance must be a positive number and smaller than 2^64-1. If the number is larger than 2^53-1, use bigint.');
-        if (txn.assetDecimals !== undefined &&
-            (!Number.isSafeInteger(txn.assetDecimals) ||
-                txn.assetDecimals < 0 ||
-                txn.assetDecimals > ALGORAND_MAX_ASSET_DECIMALS))
-            throw Error(`assetDecimals must be a positive number and smaller than ${ALGORAND_MAX_ASSET_DECIMALS.toString()}`);
-        if (txn.assetIndex !== undefined &&
-            (!Number.isSafeInteger(txn.assetIndex) || txn.assetIndex < 0))
-            throw Error('Asset index must be a positive number and smaller than 2^53-1');
-        if (txn.appIndex !== undefined &&
-            (!Number.isSafeInteger(txn.appIndex) || txn.appIndex < 0))
-            throw Error('Application index must be a positive number and smaller than 2^53-1');
-        if (txn.appLocalInts !== undefined &&
-            (!Number.isSafeInteger(txn.appLocalInts) || txn.appLocalInts < 0))
-            throw Error('Application local ints count must be a positive number and smaller than 2^53-1');
-        if (txn.appLocalByteSlices !== undefined &&
-            (!Number.isSafeInteger(txn.appLocalByteSlices) ||
-                txn.appLocalByteSlices < 0))
-            throw Error('Application local byte slices count must be a positive number and smaller than 2^53-1');
-        if (txn.appGlobalInts !== undefined &&
-            (!Number.isSafeInteger(txn.appGlobalInts) || txn.appGlobalInts < 0))
-            throw Error('Application global ints count must be a positive number and smaller than 2^53-1');
-        if (txn.appGlobalByteSlices !== undefined &&
-            (!Number.isSafeInteger(txn.appGlobalByteSlices) ||
-                txn.appGlobalByteSlices < 0))
-            throw Error('Application global byte slices count must be a positive number and smaller than 2^53-1');
-        if (txn.appApprovalProgram !== undefined) {
-            if (txn.appApprovalProgram.constructor !== Uint8Array)
-                throw Error('appApprovalProgram must be a Uint8Array.');
-        }
-        if (txn.appClearProgram !== undefined) {
-            if (txn.appClearProgram.constructor !== Uint8Array)
-                throw Error('appClearProgram must be a Uint8Array.');
-        }
-        if (txn.appArgs !== undefined) {
-            if (!Array.isArray(txn.appArgs))
-                throw Error('appArgs must be an Array of Uint8Array.');
-            txn.appArgs = txn.appArgs.slice();
-            txn.appArgs.forEach((arg) => {
-                if (arg.constructor !== Uint8Array)
-                    throw Error('each element of AppArgs must be a Uint8Array.');
-            });
-        }
-        else {
-            txn.appArgs = [];
-        }
-        if (txn.appAccounts !== undefined) {
-            if (!Array.isArray(txn.appAccounts))
-                throw Error('appAccounts must be an Array of addresses.');
-            txn.appAccounts = txn.appAccounts.map((addressAsString) => address.decodeAddress(addressAsString));
-        }
-        if (txn.appForeignApps !== undefined) {
-            if (!Array.isArray(txn.appForeignApps))
-                throw Error('appForeignApps must be an Array of integers.');
-            txn.appForeignApps = txn.appForeignApps.slice();
-            txn.appForeignApps.forEach((foreignAppIndex) => {
-                if (!Number.isSafeInteger(foreignAppIndex) || foreignAppIndex < 0)
-                    throw Error('each foreign application index must be a positive number and smaller than 2^53-1');
-            });
-        }
-        if (txn.appForeignAssets !== undefined) {
-            if (!Array.isArray(txn.appForeignAssets))
-                throw Error('appForeignAssets must be an Array of integers.');
-            txn.appForeignAssets = txn.appForeignAssets.slice();
-            txn.appForeignAssets.forEach((foreignAssetIndex) => {
-                if (!Number.isSafeInteger(foreignAssetIndex) || foreignAssetIndex < 0)
-                    throw Error('each foreign asset index must be a positive number and smaller than 2^53-1');
-            });
-        }
-        if (txn.boxes !== undefined) {
-            if (!Array.isArray(txn.boxes))
-                throw Error('boxes must be an Array of BoxReference.');
-            txn.boxes = txn.boxes.slice();
-            txn.boxes.forEach((box) => {
-                if (!Number.isSafeInteger(box.appIndex) ||
-                    box.name.constructor !== Uint8Array)
-                    throw Error('box app index must be a number and name must be an Uint8Array.');
-            });
-        }
-        if (txn.assetMetadataHash !== undefined &&
-            txn.assetMetadataHash.length !== 0) {
-            if (typeof txn.assetMetadataHash === 'string') {
-                txn.assetMetadataHash = new Uint8Array(Buffer.from(txn.assetMetadataHash));
-            }
-            if (txn.assetMetadataHash.constructor !== Uint8Array ||
-                txn.assetMetadataHash.byteLength !== ASSET_METADATA_HASH_LENGTH) {
-                throw Error(`assetMetadataHash must be a ${ASSET_METADATA_HASH_LENGTH} byte Uint8Array or string.`);
-            }
-            if (txn.assetMetadataHash.every((value) => value === 0)) {
-                // if hash contains all 0s, omit it
-                txn.assetMetadataHash = undefined;
-            }
-        }
-        else {
-            txn.assetMetadataHash = undefined;
-        }
-        if (txn.note !== undefined) {
-            if (txn.note.constructor !== Uint8Array)
-                throw Error('note must be a Uint8Array.');
-        }
-        else {
-            txn.note = new Uint8Array(0);
-        }
-        if (txn.lease !== undefined) {
-            if (txn.lease.constructor !== Uint8Array)
-                throw Error('lease must be a Uint8Array.');
-            if (txn.lease.length !== ALGORAND_TRANSACTION_LEASE_LENGTH)
-                throw Error(`lease must be of length ${ALGORAND_TRANSACTION_LEASE_LENGTH.toString()}.`);
-            if (txn.lease.every((value) => value === 0)) {
-                // if lease contains all 0s, omit it
-                txn.lease = new Uint8Array(0);
-            }
-        }
-        else {
-            txn.lease = new Uint8Array(0);
-        }
-        txn.voteKey = getKeyregKey(txn.voteKey, 'voteKey', KEYREG_VOTE_KEY_LENGTH);
-        txn.selectionKey = getKeyregKey(txn.selectionKey, 'selectionKey', KEYREG_SELECTION_KEY_LENGTH);
-        txn.stateProofKey = getKeyregKey(txn.stateProofKey, 'stateProofKey', KEYREG_STATE_PROOF_KEY_LENGTH);
-        // Checking non-participation key registration
-        if (txn.nonParticipation &&
-            (txn.voteKey ||
-                txn.selectionKey ||
-                txn.voteFirst ||
-                txn.stateProofKey ||
-                txn.voteLast ||
-                txn.voteKeyDilution)) {
-            throw new Error('nonParticipation is true but participation params are present.');
-        }
-        // Checking online key registration
-        if (!txn.nonParticipation &&
-            (txn.voteKey ||
-                txn.selectionKey ||
-                txn.stateProofKey ||
-                txn.voteFirst ||
-                txn.voteLast ||
-                txn.voteKeyDilution) &&
-            !(txn.voteKey &&
-                txn.selectionKey &&
-                txn.voteFirst &&
-                txn.voteLast &&
-                txn.voteKeyDilution)
-        // stateProofKey not included here for backwards compatibility
-        ) {
-            throw new Error('online key registration missing at least one of the following fields: ' +
-                'voteKey, selectionKey, voteFirst, voteLast, voteKeyDilution');
-        }
-        // The last option is an offline key registration where all the fields
-        // nonParticipation, voteKey, selectionKey, voteFirst, voteLast, voteKeyDilution
-        // are all undefined/false
-        // Remove unwanted properties and store transaction on instance
-        delete txn.suggestedParams;
-        Object.assign(this, utils.removeUndefinedProperties(txn));
-        // Modify Fee
-        if (!txn.flatFee) {
-            this.fee *= this.estimateSize();
-            // If suggested fee too small and will be rejected, set to min tx fee
-            if (this.fee < ALGORAND_MIN_TX_FEE) {
-                this.fee = ALGORAND_MIN_TX_FEE;
-            }
-        }
-        // say we are aware of groups
+    constructor(params) {
+        if (!isTransactionType(params.type)) {
+            throw new Error(`Invalid transaction type: ${params.type}`);
+        }
+        // Common fields
+        this.type = params.type; // verified above
+        this.sender = ensureAddress(params.sender);
+        this.note = ensureUint8Array(params.note ?? new Uint8Array());
+        this.lease = optionalFixedLengthByteArray(params.lease, ALGORAND_TRANSACTION_LEASE_LENGTH, 'lease');
+        this.rekeyTo = optionalAddress(params.rekeyTo);
+        // Group
         this.group = undefined;
-        // stpf fields
-        if (txn.stateProofType !== undefined &&
-            (!Number.isSafeInteger(txn.stateProofType) || txn.stateProofType < 0))
-            throw Error('State Proof type must be a positive number and smaller than 2^53-1');
-        if (txn.stateProofMessage !== undefined) {
-            if (txn.stateProofMessage.constructor !== Uint8Array)
-                throw Error('stateProofMessage must be a Uint8Array.');
-        }
-        else {
-            txn.stateProofMessage = new Uint8Array(0);
-        }
-        if (txn.stateProof !== undefined) {
-            if (txn.stateProof.constructor !== Uint8Array)
-                throw Error('stateProof must be a Uint8Array.');
-        }
-        else {
-            txn.stateProof = new Uint8Array(0);
-        }
-    }
-    // eslint-disable-next-line camelcase
-    get_obj_for_encoding() {
-        if (this.type === 'pay') {
-            const txn = {
-                amt: this.amount,
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: 'pay',
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
+        // Suggested params fields
+        this.firstValid = utils.ensureUint64(params.suggestedParams.firstValid);
+        this.lastValid = utils.ensureUint64(params.suggestedParams.lastValid);
+        if (params.suggestedParams.genesisID) {
+            if (typeof params.suggestedParams.genesisID !== 'string') {
+                throw new Error('Genesis ID must be a string if present');
+            }
+            this.genesisID = params.suggestedParams.genesisID;
+        }
+        this.genesisHash = optionalUint8Array(params.suggestedParams.genesisHash);
+        // Fee is handled at the end
+        const fieldsPresent = [];
+        if (params.paymentParams)
+            fieldsPresent.push(TransactionType.pay);
+        if (params.keyregParams)
+            fieldsPresent.push(TransactionType.keyreg);
+        if (params.assetConfigParams)
+            fieldsPresent.push(TransactionType.acfg);
+        if (params.assetTransferParams)
+            fieldsPresent.push(TransactionType.axfer);
+        if (params.assetFreezeParams)
+            fieldsPresent.push(TransactionType.afrz);
+        if (params.appCallParams)
+            fieldsPresent.push(TransactionType.appl);
+        if (params.stateProofParams)
+            fieldsPresent.push(TransactionType.stpf);
+        if (fieldsPresent.length !== 1) {
+            throw new Error(`Transaction has wrong number of type fields present (${fieldsPresent.length}): ${fieldsPresent}`);
+        }
+        if (this.type !== fieldsPresent[0]) {
+            throw new Error(`Transaction has type ${this.type} but fields present for ${fieldsPresent[0]}`);
+        }
+        if (params.paymentParams) {
+            this.payment = {
+                receiver: ensureAddress(params.paymentParams.receiver),
+                amount: utils.ensureUint64(params.paymentParams.amount),
+                closeRemainderTo: optionalAddress(params.paymentParams.closeRemainderTo),
             };
-            // parse close address
-            if (this.closeRemainderTo !== undefined &&
-                address.encodeAddress(this.closeRemainderTo.publicKey) !==
-                    address.ALGORAND_ZERO_ADDRESS_STRING) {
-                txn.close = Buffer.from(this.closeRemainderTo.publicKey);
-            }
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            // allowed zero values
-            if (this.to !== undefined)
-                txn.rcv = Buffer.from(this.to.publicKey);
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.rekey)
-                delete txn.rekey;
-            return txn;
         }
-        if (this.type === 'keyreg') {
-            const txn = {
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
-                votekey: this.voteKey,
-                selkey: this.selectionKey,
-                sprfkey: this.stateProofKey,
-                votefst: this.voteFirst,
-                votelst: this.voteLast,
-                votekd: this.voteKeyDilution,
+        if (params.keyregParams) {
+            this.keyreg = {
+                voteKey: getKeyregKey(params.keyregParams.voteKey, 'voteKey', KEYREG_VOTE_KEY_LENGTH),
+                selectionKey: getKeyregKey(params.keyregParams.selectionKey, 'selectionKey', KEYREG_SELECTION_KEY_LENGTH),
+                stateProofKey: getKeyregKey(params.keyregParams.stateProofKey, 'stateProofKey', KEYREG_STATE_PROOF_KEY_LENGTH),
+                voteFirst: optionalUint64(params.keyregParams.voteFirst),
+                voteLast: optionalUint64(params.keyregParams.voteLast),
+                voteKeyDilution: optionalUint64(params.keyregParams.voteKeyDilution),
+                nonParticipation: ensureBoolean(params.keyregParams.nonParticipation ?? false),
             };
-            // allowed zero values
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            if (this.nonParticipation) {
-                txn.nonpart = true;
-            }
-            if (!txn.selkey)
-                delete txn.selkey;
-            if (!txn.votekey)
-                delete txn.votekey;
-            if (!txn.sprfkey)
-                delete txn.sprfkey;
-            if (!txn.votefst)
-                delete txn.votefst;
-            if (!txn.votelst)
-                delete txn.votelst;
-            if (!txn.votekd)
-                delete txn.votekd;
-            return txn;
-        }
-        if (this.type === 'acfg') {
-            // asset creation, or asset reconfigure, or asset destruction
-            const txn = {
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
-                caid: this.assetIndex,
-                apar: {
-                    t: this.assetTotal,
-                    df: this.assetDefaultFrozen,
-                    dc: this.assetDecimals,
-                },
+            // Checking non-participation key registration
+            if (this.keyreg.nonParticipation &&
+                (this.keyreg.voteKey ||
+                    this.keyreg.selectionKey ||
+                    this.keyreg.stateProofKey ||
+                    typeof this.keyreg.voteFirst !== 'undefined' ||
+                    typeof this.keyreg.voteLast !== 'undefined' ||
+                    typeof this.keyreg.voteKeyDilution !== 'undefined')) {
+                throw new Error('nonParticipation is true but participation params are present.');
+            }
+            // Checking online key registration
+            if (
+            // If we are participating
+            !this.keyreg.nonParticipation &&
+                // And *ANY* participating fields are present
+                (this.keyreg.voteKey ||
+                    this.keyreg.selectionKey ||
+                    this.keyreg.stateProofKey ||
+                    typeof this.keyreg.voteFirst !== 'undefined' ||
+                    typeof this.keyreg.voteLast !== 'undefined' ||
+                    typeof this.keyreg.voteKeyDilution !== 'undefined') &&
+                // Then *ALL* participating fields must be present (with an exception for stateProofKey,
+                // which was introduced later so for backwards compatibility we don't require it)
+                !(this.keyreg.voteKey &&
+                    this.keyreg.selectionKey &&
+                    typeof this.keyreg.voteFirst !== 'undefined' &&
+                    typeof this.keyreg.voteLast !== 'undefined' &&
+                    typeof this.keyreg.voteKeyDilution !== 'undefined')) {
+                throw new Error(`Online key registration missing at least one of the following fields: voteKey, selectionKey, voteFirst, voteLast, voteKeyDilution`);
+            }
+            // The last option is an offline key registration where all the fields
+            // nonParticipation, voteKey, selectionKey, stateProofKey, voteFirst, voteLast, voteKeyDilution
+            // are all undefined
+        }
+        if (params.assetConfigParams) {
+            this.assetConfig = {
+                assetIndex: utils.ensureUint64(params.assetConfigParams.assetIndex ?? 0),
+                total: utils.ensureUint64(params.assetConfigParams.total ?? 0),
+                decimals: utils.ensureSafeUnsignedInteger(params.assetConfigParams.decimals ?? 0),
+                defaultFrozen: ensureBoolean(params.assetConfigParams.defaultFrozen ?? false),
+                manager: optionalAddress(params.assetConfigParams.manager),
+                reserve: optionalAddress(params.assetConfigParams.reserve),
+                freeze: optionalAddress(params.assetConfigParams.freeze),
+                clawback: optionalAddress(params.assetConfigParams.clawback),
+                unitName: params.assetConfigParams.unitName,
+                assetName: params.assetConfigParams.assetName,
+                assetURL: params.assetConfigParams.assetURL,
+                assetMetadataHash: optionalFixedLengthByteArray(params.assetConfigParams.assetMetadataHash, ASSET_METADATA_HASH_LENGTH, 'assetMetadataHash'),
             };
-            if (this.assetManager !== undefined)
-                txn.apar.m = Buffer.from(this.assetManager.publicKey);
-            if (this.assetReserve !== undefined)
-                txn.apar.r = Buffer.from(this.assetReserve.publicKey);
-            if (this.assetFreeze !== undefined)
-                txn.apar.f = Buffer.from(this.assetFreeze.publicKey);
-            if (this.assetClawback !== undefined)
-                txn.apar.c = Buffer.from(this.assetClawback.publicKey);
-            if (this.assetName !== undefined)
-                txn.apar.an = this.assetName;
-            if (this.assetUnitName !== undefined)
-                txn.apar.un = this.assetUnitName;
-            if (this.assetURL !== undefined)
-                txn.apar.au = this.assetURL;
-            if (this.assetMetadataHash !== undefined)
-                txn.apar.am = Buffer.from(this.assetMetadataHash);
-            // allowed zero values
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            if (!txn.caid)
-                delete txn.caid;
-            if (!txn.apar.t &&
-                !txn.apar.un &&
-                !txn.apar.an &&
-                !txn.apar.df &&
-                !txn.apar.m &&
-                !txn.apar.r &&
-                !txn.apar.f &&
-                !txn.apar.c &&
-                !txn.apar.au &&
-                !txn.apar.am &&
-                !txn.apar.dc) {
-                delete txn.apar;
-            }
-            else {
-                if (!txn.apar.t)
-                    delete txn.apar.t;
-                if (!txn.apar.dc)
-                    delete txn.apar.dc;
-                if (!txn.apar.un)
-                    delete txn.apar.un;
-                if (!txn.apar.an)
-                    delete txn.apar.an;
-                if (!txn.apar.df)
-                    delete txn.apar.df;
-                if (!txn.apar.m)
-                    delete txn.apar.m;
-                if (!txn.apar.r)
-                    delete txn.apar.r;
-                if (!txn.apar.f)
-                    delete txn.apar.f;
-                if (!txn.apar.c)
-                    delete txn.apar.c;
-                if (!txn.apar.au)
-                    delete txn.apar.au;
-                if (!txn.apar.am)
-                    delete txn.apar.am;
-            }
-            if (txn.grp === undefined)
-                delete txn.grp;
-            return txn;
         }
-        if (this.type === 'axfer') {
-            // asset transfer, acceptance, revocation, mint, or burn
-            const txn = {
-                aamt: this.amount,
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                arcv: Buffer.from(this.to.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
-                xaid: this.assetIndex,
+        if (params.assetTransferParams) {
+            this.assetTransfer = {
+                assetIndex: utils.ensureUint64(params.assetTransferParams.assetIndex),
+                amount: utils.ensureUint64(params.assetTransferParams.amount),
+                assetSender: optionalAddress(params.assetTransferParams.assetSender),
+                receiver: ensureAddress(params.assetTransferParams.receiver),
+                closeRemainderTo: optionalAddress(params.assetTransferParams.closeRemainderTo),
             };
-            if (this.closeRemainderTo !== undefined)
-                txn.aclose = Buffer.from(this.closeRemainderTo.publicKey);
-            if (this.assetRevocationTarget !== undefined)
-                txn.asnd = Buffer.from(this.assetRevocationTarget.publicKey);
-            // allowed zero values
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.aamt)
-                delete txn.aamt;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            if (!txn.aclose)
-                delete txn.aclose;
-            if (!txn.asnd)
-                delete txn.asnd;
-            if (!txn.rekey)
-                delete txn.rekey;
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            return txn;
         }
-        if (this.type === 'afrz') {
-            // asset freeze or unfreeze
-            const txn = {
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
-                faid: this.assetIndex,
-                afrz: this.freezeState,
+        if (params.assetFreezeParams) {
+            this.assetFreeze = {
+                assetIndex: utils.ensureUint64(params.assetFreezeParams.assetIndex),
+                freezeAccount: ensureAddress(params.assetFreezeParams.freezeTarget),
+                frozen: ensureBoolean(params.assetFreezeParams.frozen),
             };
-            if (this.freezeAccount !== undefined)
-                txn.fadd = Buffer.from(this.freezeAccount.publicKey);
-            // allowed zero values
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (!txn.afrz)
-                delete txn.afrz;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            return txn;
         }
-        if (this.type === 'appl') {
-            // application call of some kind
-            const txn = {
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                grp: this.group,
-                apid: this.appIndex,
-                apan: this.appOnComplete,
-                apls: {
-                    nui: this.appLocalInts,
-                    nbs: this.appLocalByteSlices,
-                },
-                apgs: {
-                    nui: this.appGlobalInts,
-                    nbs: this.appGlobalByteSlices,
-                },
-                apfa: this.appForeignApps,
-                apas: this.appForeignAssets,
-                apep: this.extraPages,
-                apbx: translateBoxReferences(this.boxes, this.appForeignApps, this.appIndex),
+        if (params.appCallParams) {
+            const { onComplete } = params.appCallParams;
+            if (!isOnApplicationComplete(onComplete)) {
+                throw new Error(`Invalid onCompletion value: ${onComplete}`);
+            }
+            this.applicationCall = {
+                appIndex: utils.ensureUint64(params.appCallParams.appIndex),
+                onComplete,
+                numLocalInts: utils.ensureSafeUnsignedInteger(params.appCallParams.numLocalInts ?? 0),
+                numLocalByteSlices: utils.ensureSafeUnsignedInteger(params.appCallParams.numLocalByteSlices ?? 0),
+                numGlobalInts: utils.ensureSafeUnsignedInteger(params.appCallParams.numGlobalInts ?? 0),
+                numGlobalByteSlices: utils.ensureSafeUnsignedInteger(params.appCallParams.numGlobalByteSlices ?? 0),
+                extraPages: utils.ensureSafeUnsignedInteger(params.appCallParams.extraPages ?? 0),
+                approvalProgram: ensureUint8Array(params.appCallParams.approvalProgram ?? new Uint8Array()),
+                clearProgram: ensureUint8Array(params.appCallParams.clearProgram ?? new Uint8Array()),
+                appArgs: ensureArray(params.appCallParams.appArgs ?? []).map(ensureUint8Array),
+                accounts: ensureArray(params.appCallParams.accounts ?? []).map(ensureAddress),
+                foreignApps: ensureArray(params.appCallParams.foreignApps ?? []).map(utils.ensureUint64),
+                foreignAssets: ensureArray(params.appCallParams.foreignAssets ?? []).map(utils.ensureUint64),
+                boxes: ensureArray(params.appCallParams.boxes ?? []).map(ensureBoxReference),
             };
-            if (this.reKeyTo !== undefined) {
-                txn.rekey = Buffer.from(this.reKeyTo.publicKey);
-            }
-            if (this.appApprovalProgram !== undefined) {
-                txn.apap = Buffer.from(this.appApprovalProgram);
-            }
-            if (this.appClearProgram !== undefined) {
-                txn.apsu = Buffer.from(this.appClearProgram);
-            }
-            if (this.appArgs !== undefined) {
-                txn.apaa = this.appArgs.map((arg) => Buffer.from(arg));
-            }
-            if (this.appAccounts !== undefined) {
-                txn.apat = this.appAccounts.map((decodedAddress) => Buffer.from(decodedAddress.publicKey));
-            }
-            // allowed zero values
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (!txn.apid)
-                delete txn.apid;
-            if (!txn.apls.nui)
-                delete txn.apls.nui;
-            if (!txn.apls.nbs)
-                delete txn.apls.nbs;
-            if (!txn.apls.nui && !txn.apls.nbs)
-                delete txn.apls;
-            if (!txn.apgs.nui)
-                delete txn.apgs.nui;
-            if (!txn.apgs.nbs)
-                delete txn.apgs.nbs;
-            if (!txn.apaa || !txn.apaa.length)
-                delete txn.apaa;
-            if (!txn.apgs.nui && !txn.apgs.nbs)
-                delete txn.apgs;
-            if (!txn.apap)
-                delete txn.apap;
-            if (!txn.apsu)
-                delete txn.apsu;
-            if (!txn.apan)
-                delete txn.apan;
-            if (!txn.apfa || !txn.apfa.length)
-                delete txn.apfa;
-            if (!txn.apas || !txn.apas.length)
-                delete txn.apas;
-            for (const box of txn.apbx) {
-                if (!box.i)
-                    delete box.i;
-                if (!box.n || !box.n.length)
-                    delete box.n;
-            }
-            if (!txn.apbx || !txn.apbx.length)
-                delete txn.apbx;
-            if (!txn.apat || !txn.apat.length)
-                delete txn.apat;
-            if (!txn.apep)
-                delete txn.apep;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            return txn;
         }
-        if (this.type === 'stpf') {
-            // state proof txn
-            const txn = {
-                fee: this.fee,
-                fv: this.firstRound,
-                lv: this.lastRound,
-                note: Buffer.from(this.note),
-                snd: Buffer.from(this.from.publicKey),
-                type: this.type,
-                gen: this.genesisID,
-                gh: this.genesisHash,
-                lx: Buffer.from(this.lease),
-                sptype: this.stateProofType,
-                spmsg: Buffer.from(this.stateProofMessage),
-                sp: Buffer.from(this.stateProof),
+        if (params.stateProofParams) {
+            this.stateProof = {
+                stateProofType: utils.ensureSafeUnsignedInteger(params.stateProofParams.stateProofType ?? 0),
+                stateProof: params.stateProofParams.stateProof,
+                message: params.stateProofParams.message,
             };
-            // allowed zero values
-            if (!txn.sptype)
-                delete txn.sptype;
-            if (!txn.note.length)
-                delete txn.note;
-            if (!txn.lx.length)
-                delete txn.lx;
-            if (!txn.amt)
-                delete txn.amt;
-            if (!txn.fee)
-                delete txn.fee;
-            if (!txn.fv)
-                delete txn.fv;
-            if (!txn.gen)
-                delete txn.gen;
-            if (!txn.apid)
-                delete txn.apid;
-            if (!txn.apaa || !txn.apaa.length)
-                delete txn.apaa;
-            if (!txn.apap)
-                delete txn.apap;
-            if (!txn.apsu)
-                delete txn.apsu;
-            if (!txn.apan)
-                delete txn.apan;
-            if (!txn.apfa || !txn.apfa.length)
-                delete txn.apfa;
-            if (!txn.apas || !txn.apas.length)
-                delete txn.apas;
-            if (!txn.apat || !txn.apat.length)
-                delete txn.apat;
-            if (!txn.apep)
-                delete txn.apep;
-            if (txn.grp === undefined)
-                delete txn.grp;
-            return txn;
         }
-        return undefined;
-    }
-    // eslint-disable-next-line camelcase
-    static from_obj_for_encoding(txnForEnc) {
-        const txn = Object.create(this.prototype);
-        txn.name = 'Transaction';
-        txn.tag = Buffer.from('TX');
-        txn.genesisID = txnForEnc.gen;
-        txn.genesisHash = Buffer.from(txnForEnc.gh);
-        if (!isTransactionType(txnForEnc.type)) {
-            throw new Error(`Unrecognized transaction type: ${txnForEnc.type}`);
-        }
-        txn.type = txnForEnc.type;
-        txn.fee = txnForEnc.fee;
-        txn.firstRound = txnForEnc.fv;
-        txn.lastRound = txnForEnc.lv;
-        txn.note = new Uint8Array(txnForEnc.note);
-        txn.lease = new Uint8Array(txnForEnc.lx);
-        txn.from = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.snd)));
-        if (txnForEnc.grp !== undefined)
-            txn.group = Buffer.from(txnForEnc.grp);
-        if (txnForEnc.rekey !== undefined)
-            txn.reKeyTo = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.rekey)));
-        if (txnForEnc.type === 'pay') {
-            txn.amount = txnForEnc.amt;
-            txn.to = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.rcv)));
-            if (txnForEnc.close !== undefined)
-                txn.closeRemainderTo = address.decodeAddress(address.encodeAddress(txnForEnc.close));
-        }
-        else if (txnForEnc.type === 'keyreg') {
-            if (txnForEnc.votekey !== undefined) {
-                txn.voteKey = Buffer.from(txnForEnc.votekey);
-            }
-            if (txnForEnc.selkey !== undefined) {
-                txn.selectionKey = Buffer.from(txnForEnc.selkey);
-            }
-            if (txnForEnc.sprfkey !== undefined) {
-                txn.stateProofKey = Buffer.from(txnForEnc.sprfkey);
-            }
-            if (txnForEnc.votekd !== undefined) {
-                txn.voteKeyDilution = txnForEnc.votekd;
-            }
-            if (txnForEnc.votefst !== undefined) {
-                txn.voteFirst = txnForEnc.votefst;
-            }
-            if (txnForEnc.votelst !== undefined) {
-                txn.voteLast = txnForEnc.votelst;
-            }
-            if (txnForEnc.nonpart !== undefined) {
-                txn.nonParticipation = txnForEnc.nonpart;
+        // Determine fee
+        this.fee = utils.ensureUint64(params.suggestedParams.fee);
+        const feeDependsOnSize = !ensureBoolean(params.suggestedParams.flatFee ?? false);
+        if (feeDependsOnSize) {
+            const minFee = utils.ensureUint64(params.suggestedParams.minFee);
+            this.fee *= BigInt(this.estimateSize());
+            // If suggested fee too small and will be rejected, set to min tx fee
+            if (this.fee < minFee) {
+                this.fee = minFee;
             }
         }
-        else if (txnForEnc.type === 'acfg') {
-            // asset creation, or asset reconfigure, or asset destruction
-            if (txnForEnc.caid !== undefined) {
-                txn.assetIndex = txnForEnc.caid;
-            }
-            if (txnForEnc.apar !== undefined) {
-                txn.assetTotal = txnForEnc.apar.t;
-                txn.assetDefaultFrozen = txnForEnc.apar.df;
-                if (txnForEnc.apar.dc !== undefined)
-                    txn.assetDecimals = txnForEnc.apar.dc;
-                if (txnForEnc.apar.m !== undefined)
-                    txn.assetManager = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.apar.m)));
-                if (txnForEnc.apar.r !== undefined)
-                    txn.assetReserve = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.apar.r)));
-                if (txnForEnc.apar.f !== undefined)
-                    txn.assetFreeze = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.apar.f)));
-                if (txnForEnc.apar.c !== undefined)
-                    txn.assetClawback = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.apar.c)));
-                if (txnForEnc.apar.un !== undefined)
-                    txn.assetUnitName = txnForEnc.apar.un;
-                if (txnForEnc.apar.an !== undefined)
-                    txn.assetName = txnForEnc.apar.an;
-                if (txnForEnc.apar.au !== undefined)
-                    txn.assetURL = txnForEnc.apar.au;
-                if (txnForEnc.apar.am !== undefined)
-                    txn.assetMetadataHash = txnForEnc.apar.am;
-            }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getEncodingSchema() {
+        return Transaction.encodingSchema;
+    }
+    toEncodingData() {
+        const data = new Map([
+            ['type', this.type],
+            ['fv', this.firstValid],
+            ['lv', this.lastValid],
+            ['snd', this.sender],
+            ['gen', this.genesisID],
+            ['gh', this.genesisHash],
+            ['fee', this.fee],
+            ['note', this.note],
+            ['lx', this.lease],
+            ['rekey', this.rekeyTo],
+            ['grp', this.group],
+        ]);
+        if (this.payment) {
+            data.set('amt', this.payment.amount);
+            data.set('rcv', this.payment.receiver);
+            data.set('close', this.payment.closeRemainderTo);
+            return data;
+        }
+        if (this.keyreg) {
+            data.set('votekey', this.keyreg.voteKey);
+            data.set('selkey', this.keyreg.selectionKey);
+            data.set('sprfkey', this.keyreg.stateProofKey);
+            data.set('votefst', this.keyreg.voteFirst);
+            data.set('votelst', this.keyreg.voteLast);
+            data.set('votekd', this.keyreg.voteKeyDilution);
+            data.set('nonpart', this.keyreg.nonParticipation);
+            return data;
+        }
+        if (this.assetConfig) {
+            data.set('caid', this.assetConfig.assetIndex);
+            const assetParams = new Map([
+                ['t', this.assetConfig.total],
+                ['dc', this.assetConfig.decimals],
+                ['df', this.assetConfig.defaultFrozen],
+                ['m', this.assetConfig.manager],
+                ['r', this.assetConfig.reserve],
+                ['f', this.assetConfig.freeze],
+                ['c', this.assetConfig.clawback],
+                ['un', this.assetConfig.unitName],
+                ['an', this.assetConfig.assetName],
+                ['au', this.assetConfig.assetURL],
+                ['am', this.assetConfig.assetMetadataHash],
+            ]);
+            data.set('apar', assetParams);
+            return data;
+        }
+        if (this.assetTransfer) {
+            data.set('xaid', this.assetTransfer.assetIndex);
+            data.set('aamt', this.assetTransfer.amount);
+            data.set('arcv', this.assetTransfer.receiver);
+            data.set('aclose', this.assetTransfer.closeRemainderTo);
+            data.set('asnd', this.assetTransfer.assetSender);
+            return data;
+        }
+        if (this.assetFreeze) {
+            data.set('faid', this.assetFreeze.assetIndex);
+            data.set('afrz', this.assetFreeze.frozen);
+            data.set('fadd', this.assetFreeze.freezeAccount);
+            return data;
+        }
+        if (this.applicationCall) {
+            data.set('apid', this.applicationCall.appIndex);
+            data.set('apan', this.applicationCall.onComplete);
+            data.set('apaa', this.applicationCall.appArgs);
+            data.set('apat', this.applicationCall.accounts);
+            data.set('apas', this.applicationCall.foreignAssets);
+            data.set('apfa', this.applicationCall.foreignApps);
+            data.set('apbx', boxReferencesToEncodingData(this.applicationCall.boxes, this.applicationCall.foreignApps, this.applicationCall.appIndex));
+            data.set('apap', this.applicationCall.approvalProgram);
+            data.set('apsu', this.applicationCall.clearProgram);
+            data.set('apls', new Map([
+                ['nui', this.applicationCall.numLocalInts],
+                ['nbs', this.applicationCall.numLocalByteSlices],
+            ]));
+            data.set('apgs', new Map([
+                ['nui', this.applicationCall.numGlobalInts],
+                ['nbs', this.applicationCall.numGlobalByteSlices],
+            ]));
+            data.set('apep', this.applicationCall.extraPages);
+            return data;
+        }
+        if (this.stateProof) {
+            data.set('sptype', this.stateProof.stateProofType);
+            data.set('sp', this.stateProof.stateProof
+                ? this.stateProof.stateProof.toEncodingData()
+                : undefined);
+            data.set('spmsg', this.stateProof.message
+                ? this.stateProof.message.toEncodingData()
+                : undefined);
+            return data;
+        }
+        throw new Error(`Unexpected transaction type: ${this.type}`);
+    }
+    static fromEncodingData(data) {
+        if (!(data instanceof Map)) {
+            throw new Error(`Invalid decoded logic sig account: ${data}`);
+        }
+        const suggestedParams = {
+            minFee: BigInt(0),
+            flatFee: true,
+            fee: data.get('fee') ?? 0,
+            firstValid: data.get('fv') ?? 0,
+            lastValid: data.get('lv') ?? 0,
+            genesisHash: data.get('gh'),
+            genesisID: data.get('gen'),
+        };
+        const txnType = data.get('type');
+        if (!isTransactionType(txnType)) {
+            throw new Error(`Unrecognized transaction type: ${txnType}`);
+        }
+        const params = {
+            type: txnType,
+            sender: data.get('snd') ?? Address.zeroAddress(),
+            note: data.get('note'),
+            lease: data.get('lx'),
+            suggestedParams,
+        };
+        if (data.get('rekey')) {
+            params.rekeyTo = data.get('rekey');
         }
-        else if (txnForEnc.type === 'axfer') {
-            // asset transfer, acceptance, revocation, mint, or burn
-            if (txnForEnc.xaid !== undefined) {
-                txn.assetIndex = txnForEnc.xaid;
-            }
-            if (txnForEnc.aamt !== undefined)
-                txn.amount = txnForEnc.aamt;
-            if (txnForEnc.aclose !== undefined) {
-                txn.closeRemainderTo = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.aclose)));
-            }
-            if (txnForEnc.asnd !== undefined) {
-                txn.assetRevocationTarget = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.asnd)));
-            }
-            txn.to = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.arcv)));
+        if (params.type === TransactionType.pay) {
+            const paymentParams = {
+                amount: data.get('amt') ?? 0,
+                receiver: data.get('rcv') ?? Address.zeroAddress(),
+            };
+            if (data.get('close')) {
+                paymentParams.closeRemainderTo = data.get('close');
+            }
+            params.paymentParams = paymentParams;
+        }
+        else if (params.type === TransactionType.keyreg) {
+            const keyregParams = {
+                voteKey: data.get('votekey'),
+                selectionKey: data.get('selkey'),
+                stateProofKey: data.get('sprfkey'),
+                voteFirst: data.get('votefst'),
+                voteLast: data.get('votelst'),
+                voteKeyDilution: data.get('votekd'),
+                nonParticipation: data.get('nonpart'),
+            };
+            params.keyregParams = keyregParams;
         }
-        else if (txnForEnc.type === 'afrz') {
-            if (txnForEnc.afrz !== undefined) {
-                txn.freezeState = txnForEnc.afrz;
+        else if (params.type === TransactionType.acfg) {
+            const assetConfigParams = {
+                assetIndex: data.get('caid'),
+            };
+            if (data.get('apar')) {
+                const assetParams = data.get('apar');
+                assetConfigParams.total = assetParams.get('t');
+                assetConfigParams.decimals = assetParams.get('dc');
+                assetConfigParams.defaultFrozen = assetParams.get('df');
+                assetConfigParams.unitName = assetParams.get('un');
+                assetConfigParams.assetName = assetParams.get('an');
+                assetConfigParams.assetURL = assetParams.get('au');
+                assetConfigParams.assetMetadataHash = assetParams.get('am');
+                if (assetParams.get('m')) {
+                    assetConfigParams.manager = assetParams.get('m');
+                }
+                if (assetParams.get('r')) {
+                    assetConfigParams.reserve = assetParams.get('r');
+                }
+                if (assetParams.get('f')) {
+                    assetConfigParams.freeze = assetParams.get('f');
+                }
+                if (assetParams.get('c')) {
+                    assetConfigParams.clawback = assetParams.get('c');
+                }
+            }
+            params.assetConfigParams = assetConfigParams;
+        }
+        else if (params.type === TransactionType.axfer) {
+            const assetTransferParams = {
+                assetIndex: data.get('xaid') ?? 0,
+                amount: data.get('aamt') ?? 0,
+                receiver: data.get('arcv') ?? Address.zeroAddress(),
+            };
+            if (data.get('aclose')) {
+                assetTransferParams.closeRemainderTo = data.get('aclose');
             }
-            if (txnForEnc.faid !== undefined) {
-                txn.assetIndex = txnForEnc.faid;
+            if (data.get('asnd')) {
+                assetTransferParams.assetSender = data.get('asnd');
             }
-            txn.freezeAccount = address.decodeAddress(address.encodeAddress(new Uint8Array(txnForEnc.fadd)));
+            params.assetTransferParams = assetTransferParams;
         }
-        else if (txnForEnc.type === 'appl') {
-            if (txnForEnc.apid !== undefined) {
-                txn.appIndex = txnForEnc.apid;
-            }
-            if (txnForEnc.apan !== undefined) {
-                txn.appOnComplete = txnForEnc.apan;
-            }
-            if (txnForEnc.apls !== undefined) {
-                if (txnForEnc.apls.nui !== undefined)
-                    txn.appLocalInts = txnForEnc.apls.nui;
-                if (txnForEnc.apls.nbs !== undefined)
-                    txn.appLocalByteSlices = txnForEnc.apls.nbs;
-            }
-            if (txnForEnc.apgs !== undefined) {
-                if (txnForEnc.apgs.nui !== undefined)
-                    txn.appGlobalInts = txnForEnc.apgs.nui;
-                if (txnForEnc.apgs.nbs !== undefined)
-                    txn.appGlobalByteSlices = txnForEnc.apgs.nbs;
-            }
-            if (txnForEnc.apep !== undefined) {
-                txn.extraPages = txnForEnc.apep;
-            }
-            if (txnForEnc.apap !== undefined) {
-                txn.appApprovalProgram = new Uint8Array(txnForEnc.apap);
-            }
-            if (txnForEnc.apsu !== undefined) {
-                txn.appClearProgram = new Uint8Array(txnForEnc.apsu);
-            }
-            if (txnForEnc.apaa !== undefined) {
-                txn.appArgs = txnForEnc.apaa.map((arg) => new Uint8Array(arg));
-            }
-            if (txnForEnc.apat !== undefined) {
-                txn.appAccounts = txnForEnc.apat.map((addressBytes) => address.decodeAddress(address.encodeAddress(new Uint8Array(addressBytes))));
-            }
-            if (txnForEnc.apfa !== undefined) {
-                txn.appForeignApps = txnForEnc.apfa;
-            }
-            if (txnForEnc.apas !== undefined) {
-                txn.appForeignAssets = txnForEnc.apas;
-            }
-            if (txnForEnc.apbx !== undefined) {
-                txn.boxes = txnForEnc.apbx.map((box) => ({
-                    // We return 0 for the app ID so that it's guaranteed translateBoxReferences will
-                    // translate the app index back to 0. If we instead returned the called app ID,
-                    // translateBoxReferences would translate the app index to a nonzero value if the called
-                    // app is also in the foreign app array.
-                    appIndex: box.i ? txn.appForeignApps[box.i - 1] : 0,
-                    name: box.n,
-                }));
-            }
+        else if (params.type === TransactionType.afrz) {
+            const assetFreezeParams = {
+                assetIndex: data.get('faid') ?? 0,
+                freezeTarget: data.get('fadd') ?? Address.zeroAddress(),
+                frozen: data.get('afrz') ?? false,
+            };
+            params.assetFreezeParams = assetFreezeParams;
+        }
+        else if (params.type === TransactionType.appl) {
+            const appCallParams = {
+                appIndex: data.get('apid') ?? 0,
+                onComplete: utils.ensureSafeUnsignedInteger(data.get('apan') ?? 0),
+                appArgs: data.get('apaa'),
+                accounts: data.get('apat'),
+                foreignAssets: data.get('apas'),
+                foreignApps: data.get('apfa'),
+                approvalProgram: data.get('apap'),
+                clearProgram: data.get('apsu'),
+                extraPages: data.get('apep'),
+            };
+            const localSchema = data.get('apls');
+            if (localSchema) {
+                appCallParams.numLocalInts = localSchema.get('nui');
+                appCallParams.numLocalByteSlices = localSchema.get('nbs');
+            }
+            const globalSchema = data.get('apgs');
+            if (globalSchema) {
+                appCallParams.numGlobalInts = globalSchema.get('nui');
+                appCallParams.numGlobalByteSlices = globalSchema.get('nbs');
+            }
+            const boxes = data.get('apbx');
+            if (boxes) {
+                appCallParams.boxes = boxes.map((box) => {
+                    const index = utils.ensureSafeUnsignedInteger(box.get('i') ?? 0);
+                    const name = ensureUint8Array(box.get('n') ?? new Uint8Array());
+                    if (index === 0) {
+                        // We return 0 for the app ID so that it's guaranteed translateBoxReferences will
+                        // translate the app index back to 0. If we instead returned the called app ID,
+                        // translateBoxReferences would translate the app index to a nonzero value if the called
+                        // app is also in the foreign app array.
+                        return {
+                            appIndex: 0,
+                            name,
+                        };
+                    }
+                    if (!appCallParams.foreignApps ||
+                        index > appCallParams.foreignApps.length) {
+                        throw new Error(`Cannot find foreign app index ${index} in ${appCallParams.foreignApps}`);
+                    }
+                    return {
+                        appIndex: appCallParams.foreignApps[index - 1],
+                        name,
+                    };
+                });
+            }
+            params.appCallParams = appCallParams;
+        }
+        else if (params.type === TransactionType.stpf) {
+            const stateProofParams = {
+                stateProofType: data.get('sptype'),
+                stateProof: data.get('sp')
+                    ? StateProof.fromEncodingData(data.get('sp'))
+                    : undefined,
+                message: data.get('spmsg')
+                    ? StateProofMessage.fromEncodingData(data.get('spmsg'))
+                    : undefined,
+            };
+            params.stateProofParams = stateProofParams;
         }
-        else if (txnForEnc.type === 'stpf') {
-            if (txnForEnc.sptype !== undefined) {
-                txn.stateProofType = txnForEnc.sptype;
-            }
-            if (txnForEnc.sp !== undefined) {
-                txn.stateProof = txnForEnc.sp;
-            }
-            if (txnForEnc.spmsg !== undefined) {
-                txn.stateProofMessage = txnForEnc.spmsg;
+        else {
+            const exhaustiveCheck = params.type;
+            throw new Error(`Unexpected transaction type: ${exhaustiveCheck}`);
+        }
+        const txn = new Transaction(params);
+        if (data.get('grp')) {
+            const group = ensureUint8Array(data.get('grp'));
+            if (group.byteLength !== ALGORAND_TRANSACTION_GROUP_LENGTH) {
+                throw new Error(`Invalid group length: ${group.byteLength}`);
             }
+            txn.group = group;
         }
         return txn;
     }
@@ -916,181 +571,244 @@ export class Transaction {
     }
     bytesToSign() {
         const encodedMsg = this.toByte();
-        return Buffer.from(utils.concatArrays(this.tag, encodedMsg));
+        return utils.concatArrays(TX_TAG, encodedMsg);
     }
     toByte() {
-        return encoding.encode(this.get_obj_for_encoding());
+        return encoding.encodeMsgpack(this);
     }
     // returns the raw signature
     rawSignTxn(sk) {
         const toBeSigned = this.bytesToSign();
         const sig = nacl.sign(toBeSigned, sk);
-        return Buffer.from(sig);
+        return sig;
     }
     signTxn(sk) {
-        // construct signed message
-        const sTxn = {
-            sig: this.rawSignTxn(sk),
-            txn: this.get_obj_for_encoding(),
-        };
-        // add AuthAddr if signing with a different key than From indicates
+        // TODO: deprecate in favor of SignedTransaction class
         const keypair = nacl.keyPairFromSecretKey(sk);
-        const pubKeyFromSk = keypair.publicKey;
-        if (address.encodeAddress(pubKeyFromSk) !==
-            address.encodeAddress(this.from.publicKey)) {
-            sTxn.sgnr = Buffer.from(pubKeyFromSk);
-        }
-        return new Uint8Array(encoding.encode(sTxn));
+        const signerAddr = new Address(keypair.publicKey);
+        const sig = this.rawSignTxn(sk);
+        return this.attachSignature(signerAddr, sig);
     }
     attachSignature(signerAddr, signature) {
+        // TODO: deprecate in favor of SignedTransaction class
         if (!nacl.isValidSignatureLength(signature.length)) {
             throw new Error('Invalid signature length');
         }
-        const sTxn = {
-            sig: Buffer.from(signature),
-            txn: this.get_obj_for_encoding(),
-        };
+        const sTxn = new Map([
+            ['sig', signature],
+            ['txn', this.toEncodingData()],
+        ]);
+        const signerAddrObj = ensureAddress(signerAddr);
         // add AuthAddr if signing with a different key than From indicates
-        if (signerAddr !== address.encodeAddress(this.from.publicKey)) {
-            const signerPublicKey = address.decodeAddress(signerAddr).publicKey;
-            sTxn.sgnr = Buffer.from(signerPublicKey);
-        }
-        return new Uint8Array(encoding.encode(sTxn));
+        if (!this.sender.equals(signerAddrObj)) {
+            sTxn.set('sgnr', signerAddrObj);
+        }
+        // This is a hack to avoid a circular reference with the SignedTransaction class
+        const stxnSchema = new NamedMapSchema(allOmitEmpty([
+            {
+                key: 'txn',
+                valueSchema: Transaction.encodingSchema,
+            },
+            {
+                key: 'sig',
+                valueSchema: new FixedLengthByteArraySchema(64),
+            },
+            {
+                key: 'sgnr',
+                valueSchema: new OptionalSchema(new AddressSchema()),
+            },
+        ]));
+        return encoding.msgpackRawEncode(stxnSchema.prepareMsgpack(sTxn));
     }
     rawTxID() {
         const enMsg = this.toByte();
-        const gh = Buffer.from(utils.concatArrays(this.tag, enMsg));
-        return Buffer.from(nacl.genericHash(gh));
+        const gh = utils.concatArrays(TX_TAG, enMsg);
+        return Uint8Array.from(nacl.genericHash(gh));
     }
     txID() {
         const hash = this.rawTxID();
         return base32.encode(hash).slice(0, ALGORAND_TRANSACTION_LENGTH);
     }
-    // add a lease to a transaction not yet having
-    // supply feePerByte to increment fee accordingly
-    addLease(lease, feePerByte = 0) {
-        let mutableLease;
-        if (lease !== undefined) {
-            if (lease.constructor !== Uint8Array)
-                throw Error('lease must be a Uint8Array.');
-            if (lease.length !== ALGORAND_TRANSACTION_LEASE_LENGTH)
-                throw Error(`lease must be of length ${ALGORAND_TRANSACTION_LEASE_LENGTH.toString()}.`);
-            mutableLease = new Uint8Array(lease);
-        }
-        else {
-            mutableLease = new Uint8Array(0);
-        }
-        this.lease = mutableLease;
-        if (feePerByte !== 0) {
-            this.fee +=
-                (ALGORAND_TRANSACTION_LEASE_LABEL_LENGTH +
-                    ALGORAND_TRANSACTION_LEASE_LENGTH) *
-                    feePerByte;
-        }
-    }
-    // add the rekey-to field to a transaction not yet having it
-    // supply feePerByte to increment fee accordingly
-    addRekey(reKeyTo, feePerByte = 0) {
-        if (reKeyTo !== undefined) {
-            this.reKeyTo = address.decodeAddress(reKeyTo);
-        }
-        if (feePerByte !== 0) {
-            this.fee +=
-                (ALGORAND_TRANSACTION_REKEY_LABEL_LENGTH +
-                    ALGORAND_TRANSACTION_ADDRESS_LENGTH) *
-                    feePerByte;
-        }
-    }
-    // build display dict for prettyPrint and toString
-    // eslint-disable-next-line no-underscore-dangle
-    _getDictForDisplay() {
-        const forPrinting = {
-            ...this,
-        };
-        forPrinting.tag = forPrinting.tag.toString();
-        forPrinting.from = address.encodeAddress(forPrinting.from.publicKey);
-        if (forPrinting.to !== undefined)
-            forPrinting.to = address.encodeAddress(forPrinting.to.publicKey);
-        // things that need fixing:
-        if (forPrinting.freezeAccount !== undefined)
-            forPrinting.freezeAccount = address.encodeAddress(forPrinting.freezeAccount.publicKey);
-        if (forPrinting.closeRemainderTo !== undefined)
-            forPrinting.closeRemainderTo = address.encodeAddress(forPrinting.closeRemainderTo.publicKey);
-        if (forPrinting.assetManager !== undefined)
-            forPrinting.assetManager = address.encodeAddress(forPrinting.assetManager.publicKey);
-        if (forPrinting.assetReserve !== undefined)
-            forPrinting.assetReserve = address.encodeAddress(forPrinting.assetReserve.publicKey);
-        if (forPrinting.assetFreeze !== undefined)
-            forPrinting.assetFreeze = address.encodeAddress(forPrinting.assetFreeze.publicKey);
-        if (forPrinting.assetClawback !== undefined)
-            forPrinting.assetClawback = address.encodeAddress(forPrinting.assetClawback.publicKey);
-        if (forPrinting.assetRevocationTarget !== undefined)
-            forPrinting.assetRevocationTarget = address.encodeAddress(forPrinting.assetRevocationTarget.publicKey);
-        if (forPrinting.reKeyTo !== undefined)
-            forPrinting.reKeyTo = address.encodeAddress(forPrinting.reKeyTo.publicKey);
-        forPrinting.genesisHash = forPrinting.genesisHash.toString('base64');
-        return forPrinting;
-    }
-    // pretty print the transaction to console
-    prettyPrint() {
-        // eslint-disable-next-line no-underscore-dangle,no-console
-        console.log(this._getDictForDisplay());
-    }
-    // get string representation
-    toString() {
-        // eslint-disable-next-line no-underscore-dangle
-        return JSON.stringify(this._getDictForDisplay());
-    }
-}
-/**
- * encodeUnsignedSimulateTransaction takes a txnBuilder.Transaction object,
- * converts it into a SignedTransaction-like object, and converts it to a Buffer.
- *
- * Note: this function should only be used to simulate unsigned transactions.
- *
- * @param transactionObject - Transaction object to simulate.
- */
-export function encodeUnsignedSimulateTransaction(transactionObject) {
-    const objToEncode = {
-        txn: transactionObject.get_obj_for_encoding(),
-    };
-    return encoding.encode(objToEncode);
 }
+Transaction.encodingSchema = new NamedMapSchema(allOmitEmpty([
+    // Common
+    { key: 'type', valueSchema: new StringSchema() },
+    { key: 'snd', valueSchema: new AddressSchema() },
+    { key: 'lv', valueSchema: new Uint64Schema() },
+    { key: 'gen', valueSchema: new OptionalSchema(new StringSchema()) },
+    {
+        key: 'gh',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+    },
+    { key: 'fee', valueSchema: new Uint64Schema() },
+    { key: 'fv', valueSchema: new Uint64Schema() },
+    { key: 'note', valueSchema: new ByteArraySchema() },
+    {
+        key: 'lx',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+    },
+    { key: 'rekey', valueSchema: new OptionalSchema(new AddressSchema()) },
+    {
+        key: 'grp',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+    },
+    // We mark all top-level type-specific fields optional because they will not be present when
+    // the transaction is not that type.
+    // Payment
+    { key: 'amt', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'rcv', valueSchema: new OptionalSchema(new AddressSchema()) },
+    { key: 'close', valueSchema: new OptionalSchema(new AddressSchema()) },
+    // Keyreg
+    {
+        key: 'votekey',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+    },
+    {
+        key: 'selkey',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+    },
+    {
+        key: 'sprfkey',
+        valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(64)),
+    },
+    { key: 'votefst', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'votelst', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'votekd', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'nonpart', valueSchema: new OptionalSchema(new BooleanSchema()) },
+    // AssetConfig
+    { key: 'caid', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    {
+        key: 'apar',
+        valueSchema: new OptionalSchema(new NamedMapSchema(allOmitEmpty([
+            { key: 't', valueSchema: new Uint64Schema() },
+            { key: 'dc', valueSchema: new Uint64Schema() },
+            { key: 'df', valueSchema: new BooleanSchema() },
+            {
+                key: 'm',
+                valueSchema: new OptionalSchema(new AddressSchema()),
+            },
+            {
+                key: 'r',
+                valueSchema: new OptionalSchema(new AddressSchema()),
+            },
+            {
+                key: 'f',
+                valueSchema: new OptionalSchema(new AddressSchema()),
+            },
+            {
+                key: 'c',
+                valueSchema: new OptionalSchema(new AddressSchema()),
+            },
+            {
+                key: 'un',
+                valueSchema: new OptionalSchema(new StringSchema()),
+            },
+            {
+                key: 'an',
+                valueSchema: new OptionalSchema(new StringSchema()),
+            },
+            {
+                key: 'au',
+                valueSchema: new OptionalSchema(new StringSchema()),
+            },
+            {
+                key: 'am',
+                valueSchema: new OptionalSchema(new FixedLengthByteArraySchema(32)),
+            },
+        ]))),
+    },
+    // AssetTransfer
+    { key: 'xaid', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'aamt', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'arcv', valueSchema: new OptionalSchema(new AddressSchema()) },
+    { key: 'aclose', valueSchema: new OptionalSchema(new AddressSchema()) },
+    { key: 'asnd', valueSchema: new OptionalSchema(new AddressSchema()) },
+    // AssetFreeze
+    { key: 'faid', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'afrz', valueSchema: new OptionalSchema(new BooleanSchema()) },
+    { key: 'fadd', valueSchema: new OptionalSchema(new AddressSchema()) },
+    // Application
+    { key: 'apid', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'apan', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    {
+        key: 'apaa',
+        valueSchema: new OptionalSchema(new ArraySchema(new ByteArraySchema())),
+    },
+    {
+        key: 'apat',
+        valueSchema: new OptionalSchema(new ArraySchema(new AddressSchema())),
+    },
+    {
+        key: 'apas',
+        valueSchema: new OptionalSchema(new ArraySchema(new Uint64Schema())),
+    },
+    {
+        key: 'apfa',
+        valueSchema: new OptionalSchema(new ArraySchema(new Uint64Schema())),
+    },
+    {
+        key: 'apbx',
+        valueSchema: new OptionalSchema(new ArraySchema(new NamedMapSchema(allOmitEmpty([
+            {
+                key: 'i',
+                valueSchema: new Uint64Schema(),
+            },
+            {
+                key: 'n',
+                valueSchema: new ByteArraySchema(),
+            },
+        ])))),
+    },
+    { key: 'apap', valueSchema: new OptionalSchema(new ByteArraySchema()) },
+    { key: 'apsu', valueSchema: new OptionalSchema(new ByteArraySchema()) },
+    {
+        key: 'apls',
+        valueSchema: new OptionalSchema(new NamedMapSchema(allOmitEmpty([
+            {
+                key: 'nui',
+                valueSchema: new Uint64Schema(),
+            },
+            {
+                key: 'nbs',
+                valueSchema: new Uint64Schema(),
+            },
+        ]))),
+    },
+    {
+        key: 'apgs',
+        valueSchema: new OptionalSchema(new NamedMapSchema(allOmitEmpty([
+            {
+                key: 'nui',
+                valueSchema: new Uint64Schema(),
+            },
+            {
+                key: 'nbs',
+                valueSchema: new Uint64Schema(),
+            },
+        ]))),
+    },
+    { key: 'apep', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    // StateProof
+    { key: 'sptype', valueSchema: new OptionalSchema(new Uint64Schema()) },
+    { key: 'sp', valueSchema: new OptionalSchema(StateProof.encodingSchema) },
+    {
+        key: 'spmsg',
+        valueSchema: new OptionalSchema(StateProofMessage.encodingSchema),
+    },
+]));
 /**
  * encodeUnsignedTransaction takes a completed txnBuilder.Transaction object, such as from the makeFoo
  * family of transactions, and converts it to a Buffer
  * @param transactionObject - the completed Transaction object
  */
 export function encodeUnsignedTransaction(transactionObject) {
-    const objToEncode = transactionObject.get_obj_for_encoding();
-    return encoding.encode(objToEncode);
+    return encoding.encodeMsgpack(transactionObject);
 }
 /**
- * decodeUnsignedTransaction takes a Buffer (as if from encodeUnsignedTransaction) and converts it to a txnBuilder.Transaction object
+ * decodeUnsignedTransaction takes a Uint8Array (as if from encodeUnsignedTransaction) and converts it to a txnBuilder.Transaction object
  * @param transactionBuffer - the Uint8Array containing a transaction
  */
 export function decodeUnsignedTransaction(transactionBuffer) {
-    const partlyDecodedObject = encoding.decode(transactionBuffer);
-    return Transaction.from_obj_for_encoding(partlyDecodedObject);
-}
-/**
- * decodeSignedTransaction takes a Buffer (from transaction.signTxn) and converts it to an object
- * containing the Transaction (txn), the signature (sig), and the auth-addr field if applicable (sgnr)
- * @param transactionBuffer - the Uint8Array containing a transaction
- * @returns containing a Transaction, the signature, and possibly an auth-addr field
- */
-export function decodeSignedTransaction(transactionBuffer) {
-    const stxnDecoded = encoding.decode(transactionBuffer);
-    const stxn = {
-        ...stxnDecoded,
-        txn: Transaction.from_obj_for_encoding(stxnDecoded.txn),
-    };
-    return stxn;
-}
-export function instantiateTxnIfNeeded(transactionLike) {
-    return transactionLike instanceof Transaction
-        ? transactionLike
-        : new Transaction(transactionLike);
+    return encoding.decodeMsgpack(transactionBuffer, Transaction);
 }
-export default Transaction;
 //# sourceMappingURL=transaction.js.map