algosdk 2.4.0 → 2.6.0

package/dist/esm/client/v2/algod/models/types.js

@@ -397,6 +397,113 @@ export class Application extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * An application's initial global/local/box states that were accessed during
+ * simulation.
+ */
+export class ApplicationInitialStates extends BaseModel {
+    /**
+     * Creates a new `ApplicationInitialStates` object.
+     * @param id - Application index.
+     * @param appBoxes - An application's global/local/box state.
+     * @param appGlobals - An application's global/local/box state.
+     * @param appLocals - An application's initial local states tied to different accounts.
+     */
+    constructor({ id, appBoxes, appGlobals, appLocals, }) {
+        super();
+        this.id = id;
+        this.appBoxes = appBoxes;
+        this.appGlobals = appGlobals;
+        this.appLocals = appLocals;
+        this.attribute_map = {
+            id: 'id',
+            appBoxes: 'app-boxes',
+            appGlobals: 'app-globals',
+            appLocals: 'app-locals',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['id'] === 'undefined')
+            throw new Error(`Response is missing required field 'id': ${data}`);
+        return new ApplicationInitialStates({
+            id: data['id'],
+            appBoxes: typeof data['app-boxes'] !== 'undefined'
+                ? ApplicationKVStorage.from_obj_for_encoding(data['app-boxes'])
+                : undefined,
+            appGlobals: typeof data['app-globals'] !== 'undefined'
+                ? ApplicationKVStorage.from_obj_for_encoding(data['app-globals'])
+                : undefined,
+            appLocals: typeof data['app-locals'] !== 'undefined'
+                ? data['app-locals'].map(ApplicationKVStorage.from_obj_for_encoding)
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * An application's global/local/box state.
+ */
+export class ApplicationKVStorage extends BaseModel {
+    /**
+     * Creates a new `ApplicationKVStorage` object.
+     * @param kvs - Key-Value pairs representing application states.
+     * @param account - The address of the account associated with the local state.
+     */
+    constructor({ kvs, account }) {
+        super();
+        this.kvs = kvs;
+        this.account = account;
+        this.attribute_map = {
+            kvs: 'kvs',
+            account: 'account',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (!Array.isArray(data['kvs']))
+            throw new Error(`Response is missing required array field 'kvs': ${data}`);
+        return new ApplicationKVStorage({
+            kvs: data['kvs'].map(AvmKeyValue.from_obj_for_encoding),
+            account: data['account'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * References an account's local state for an application.
+ */
+export class ApplicationLocalReference extends BaseModel {
+    /**
+     * Creates a new `ApplicationLocalReference` object.
+     * @param account - Address of the account with the local state.
+     * @param app - Application ID of the local state application.
+     */
+    constructor({ account, app }) {
+        super();
+        this.account = account;
+        this.app = app;
+        this.attribute_map = {
+            account: 'account',
+            app: 'app',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['account'] === 'undefined')
+            throw new Error(`Response is missing required field 'account': ${data}`);
+        if (typeof data['app'] === 'undefined')
+            throw new Error(`Response is missing required field 'app': ${data}`);
+        return new ApplicationLocalReference({
+            account: data['account'],
+            app: data['app'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Stores local state associated with an application.
  */
@@ -502,6 +609,59 @@ export class ApplicationParams extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * An operation against an application's global/local/box state.
+ */
+export class ApplicationStateOperation extends BaseModel {
+    /**
+     * Creates a new `ApplicationStateOperation` object.
+     * @param appStateType - Type of application state. Value `g` is **global state**, `l` is **local
+     * state**, `b` is **boxes**.
+     * @param key - The key (name) of the global/local/box state.
+     * @param operation - Operation type. Value `w` is **write**, `d` is **delete**.
+     * @param account - For local state changes, the address of the account associated with the local
+     * state.
+     * @param newValue - Represents an AVM value.
+     */
+    constructor({ appStateType, key, operation, account, newValue, }) {
+        super();
+        this.appStateType = appStateType;
+        this.key =
+            typeof key === 'string'
+                ? new Uint8Array(Buffer.from(key, 'base64'))
+                : key;
+        this.operation = operation;
+        this.account = account;
+        this.newValue = newValue;
+        this.attribute_map = {
+            appStateType: 'app-state-type',
+            key: 'key',
+            operation: 'operation',
+            account: 'account',
+            newValue: 'new-value',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['app-state-type'] === 'undefined')
+            throw new Error(`Response is missing required field 'app-state-type': ${data}`);
+        if (typeof data['key'] === 'undefined')
+            throw new Error(`Response is missing required field 'key': ${data}`);
+        if (typeof data['operation'] === 'undefined')
+            throw new Error(`Response is missing required field 'operation': ${data}`);
+        return new ApplicationStateOperation({
+            appStateType: data['app-state-type'],
+            key: data['key'],
+            operation: data['operation'],
+            account: data['account'],
+            newValue: typeof data['new-value'] !== 'undefined'
+                ? AvmValue.from_obj_for_encoding(data['new-value'])
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Specifies maximums on the number of each type that may be stored.
  */
@@ -609,6 +769,38 @@ export class AssetHolding extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * References an asset held by an account.
+ */
+export class AssetHoldingReference extends BaseModel {
+    /**
+     * Creates a new `AssetHoldingReference` object.
+     * @param account - Address of the account holding the asset.
+     * @param asset - Asset ID of the holding.
+     */
+    constructor({ account, asset }) {
+        super();
+        this.account = account;
+        this.asset = asset;
+        this.attribute_map = {
+            account: 'account',
+            asset: 'asset',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['account'] === 'undefined')
+            throw new Error(`Response is missing required field 'account': ${data}`);
+        if (typeof data['asset'] === 'undefined')
+            throw new Error(`Response is missing required field 'asset': ${data}`);
+        return new AssetHoldingReference({
+            account: data['account'],
+            asset: data['asset'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * AssetParams specifies the parameters for an asset.
  * (apar) when part of an AssetConfig transaction.
@@ -721,6 +913,78 @@ export class AssetParams extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Represents an AVM key-value pair in an application store.
+ */
+export class AvmKeyValue extends BaseModel {
+    /**
+     * Creates a new `AvmKeyValue` object.
+     * @param key -
+     * @param value - Represents an AVM value.
+     */
+    constructor({ key, value }) {
+        super();
+        this.key =
+            typeof key === 'string'
+                ? new Uint8Array(Buffer.from(key, 'base64'))
+                : key;
+        this.value = value;
+        this.attribute_map = {
+            key: 'key',
+            value: 'value',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['key'] === 'undefined')
+            throw new Error(`Response is missing required field 'key': ${data}`);
+        if (typeof data['value'] === 'undefined')
+            throw new Error(`Response is missing required field 'value': ${data}`);
+        return new AvmKeyValue({
+            key: data['key'],
+            value: AvmValue.from_obj_for_encoding(data['value']),
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * Represents an AVM value.
+ */
+export class AvmValue extends BaseModel {
+    /**
+     * Creates a new `AvmValue` object.
+     * @param type - value type. Value `1` refers to **bytes**, value `2` refers to **uint64**
+     * @param bytes - bytes value.
+     * @param uint - uint value.
+     */
+    constructor({ type, bytes, uint, }) {
+        super();
+        this.type = type;
+        this.bytes =
+            typeof bytes === 'string'
+                ? new Uint8Array(Buffer.from(bytes, 'base64'))
+                : bytes;
+        this.uint = uint;
+        this.attribute_map = {
+            type: 'type',
+            bytes: 'bytes',
+            uint: 'uint',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['type'] === 'undefined')
+            throw new Error(`Response is missing required field 'type': ${data}`);
+        return new AvmValue({
+            type: data['type'],
+            bytes: data['bytes'],
+            uint: data['uint'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Hash of a block header.
  */
@@ -778,6 +1042,32 @@ export class BlockResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Top level transaction IDs in a block.
+ */
+export class BlockTxidsResponse extends BaseModel {
+    /**
+     * Creates a new `BlockTxidsResponse` object.
+     * @param blocktxids - Block transaction IDs.
+     */
+    constructor({ blocktxids }) {
+        super();
+        this.blocktxids = blocktxids;
+        this.attribute_map = {
+            blocktxids: 'blockTxids',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (!Array.isArray(data['blockTxids']))
+            throw new Error(`Response is missing required array field 'blockTxids': ${data}`);
+        return new BlockTxidsResponse({
+            blocktxids: data['blockTxids'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Box name and its content.
  */
@@ -785,20 +1075,23 @@ export class Box extends BaseModel {
     /**
      * Creates a new `Box` object.
      * @param name - (name) box name, base64 encoded
+     * @param round - The round for which this information is relevant
      * @param value - (value) box value, base64 encoded.
      */
-    constructor({ name, value, }) {
+    constructor({ name, round, value, }) {
         super();
         this.name =
             typeof name === 'string'
                 ? new Uint8Array(Buffer.from(name, 'base64'))
                 : name;
+        this.round = round;
         this.value =
             typeof value === 'string'
                 ? new Uint8Array(Buffer.from(value, 'base64'))
                 : value;
         this.attribute_map = {
             name: 'name',
+            round: 'round',
             value: 'value',
         };
     }
@@ -807,10 +1100,13 @@ export class Box extends BaseModel {
         /* eslint-disable dot-notation */
         if (typeof data['name'] === 'undefined')
             throw new Error(`Response is missing required field 'name': ${data}`);
+        if (typeof data['round'] === 'undefined')
+            throw new Error(`Response is missing required field 'round': ${data}`);
         if (typeof data['value'] === 'undefined')
             throw new Error(`Response is missing required field 'value': ${data}`);
         return new Box({
             name: data['name'],
+            round: data['round'],
             value: data['value'],
         });
         /* eslint-enable dot-notation */
@@ -845,6 +1141,41 @@ export class BoxDescriptor extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * References a box of an application.
+ */
+export class BoxReference extends BaseModel {
+    /**
+     * Creates a new `BoxReference` object.
+     * @param app - Application ID which this box belongs to
+     * @param name - Base64 encoded box name
+     */
+    constructor({ app, name, }) {
+        super();
+        this.app = app;
+        this.name =
+            typeof name === 'string'
+                ? new Uint8Array(Buffer.from(name, 'base64'))
+                : name;
+        this.attribute_map = {
+            app: 'app',
+            name: 'name',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['app'] === 'undefined')
+            throw new Error(`Response is missing required field 'app': ${data}`);
+        if (typeof data['name'] === 'undefined')
+            throw new Error(`Response is missing required field 'name': ${data}`);
+        return new BoxReference({
+            app: data['app'],
+            name: data['name'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Box names of an application
  */
@@ -1457,20 +1788,20 @@ export class LedgerStateDeltaForTransactionGroup extends BaseModel {
         this.delta = delta;
         this.ids = ids;
         this.attribute_map = {
-            delta: 'delta',
-            ids: 'ids',
+            delta: 'Delta',
+            ids: 'Ids',
         };
     }
     // eslint-disable-next-line camelcase
     static from_obj_for_encoding(data) {
         /* eslint-disable dot-notation */
-        if (typeof data['delta'] === 'undefined')
-            throw new Error(`Response is missing required field 'delta': ${data}`);
-        if (!Array.isArray(data['ids']))
-            throw new Error(`Response is missing required array field 'ids': ${data}`);
+        if (typeof data['Delta'] === 'undefined')
+            throw new Error(`Response is missing required field 'Delta': ${data}`);
+        if (!Array.isArray(data['Ids']))
+            throw new Error(`Response is missing required array field 'Ids': ${data}`);
         return new LedgerStateDeltaForTransactionGroup({
-            delta: data['delta'],
-            ids: data['ids'],
+            delta: data['Delta'],
+            ids: data['Ids'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1817,6 +2148,65 @@ export class PostTransactionsResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * A write operation into a scratch slot.
+ */
+export class ScratchChange extends BaseModel {
+    /**
+     * Creates a new `ScratchChange` object.
+     * @param newValue - Represents an AVM value.
+     * @param slot - The scratch slot written.
+     */
+    constructor({ newValue, slot, }) {
+        super();
+        this.newValue = newValue;
+        this.slot = slot;
+        this.attribute_map = {
+            newValue: 'new-value',
+            slot: 'slot',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['new-value'] === 'undefined')
+            throw new Error(`Response is missing required field 'new-value': ${data}`);
+        if (typeof data['slot'] === 'undefined')
+            throw new Error(`Response is missing required field 'slot': ${data}`);
+        return new ScratchChange({
+            newValue: AvmValue.from_obj_for_encoding(data['new-value']),
+            slot: data['slot'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * Initial states of resources that were accessed during simulation.
+ */
+export class SimulateInitialStates extends BaseModel {
+    /**
+     * Creates a new `SimulateInitialStates` object.
+     * @param appInitialStates - The initial states of accessed application before simulation. The order of this
+     * array is arbitrary.
+     */
+    constructor({ appInitialStates, }) {
+        super();
+        this.appInitialStates = appInitialStates;
+        this.attribute_map = {
+            appInitialStates: 'app-initial-states',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulateInitialStates({
+            appInitialStates: typeof data['app-initial-states'] !== 'undefined'
+                ? data['app-initial-states'].map(ApplicationInitialStates.from_obj_for_encoding)
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Request type for simulation endpoint.
  */
@@ -1824,22 +2214,34 @@ export class SimulateRequest extends BaseModel {
     /**
      * Creates a new `SimulateRequest` object.
      * @param txnGroups - The transaction groups to simulate.
-     * @param allowEmptySignatures - Allow transactions without signatures to be simulated as if they had correct
+     * @param allowEmptySignatures - Allows transactions without signatures to be simulated as if they had correct
      * signatures.
      * @param allowMoreLogging - Lifts limits on log opcode usage during simulation.
+     * @param allowUnnamedResources - Allows access to unnamed resources during simulation.
+     * @param execTraceConfig - An object that configures simulation execution trace.
      * @param extraOpcodeBudget - Applies extra opcode budget during simulation for each transaction group.
+     * @param round - If provided, specifies the round preceding the simulation. State changes through
+     * this round will be used to run this simulation. Usually only the 4 most recent
+     * rounds will be available (controlled by the node config value MaxAcctLookback).
+     * If not specified, defaults to the latest available round.
      */
-    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, extraOpcodeBudget, }) {
+    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, allowUnnamedResources, execTraceConfig, extraOpcodeBudget, round, }) {
         super();
         this.txnGroups = txnGroups;
         this.allowEmptySignatures = allowEmptySignatures;
         this.allowMoreLogging = allowMoreLogging;
+        this.allowUnnamedResources = allowUnnamedResources;
+        this.execTraceConfig = execTraceConfig;
         this.extraOpcodeBudget = extraOpcodeBudget;
+        this.round = round;
         this.attribute_map = {
             txnGroups: 'txn-groups',
             allowEmptySignatures: 'allow-empty-signatures',
             allowMoreLogging: 'allow-more-logging',
+            allowUnnamedResources: 'allow-unnamed-resources',
+            execTraceConfig: 'exec-trace-config',
             extraOpcodeBudget: 'extra-opcode-budget',
+            round: 'round',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1851,7 +2253,12 @@ export class SimulateRequest extends BaseModel {
             txnGroups: data['txn-groups'].map(SimulateRequestTransactionGroup.from_obj_for_encoding),
             allowEmptySignatures: data['allow-empty-signatures'],
             allowMoreLogging: data['allow-more-logging'],
+            allowUnnamedResources: data['allow-unnamed-resources'],
+            execTraceConfig: typeof data['exec-trace-config'] !== 'undefined'
+                ? SimulateTraceConfig.from_obj_for_encoding(data['exec-trace-config'])
+                : undefined,
             extraOpcodeBudget: data['extra-opcode-budget'],
+            round: data['round'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1895,18 +2302,24 @@ export class SimulateResponse extends BaseModel {
      * @param evalOverrides - The set of parameters and limits override during simulation. If this set of
      * parameters is present, then evaluation parameters may differ from standard
      * evaluation in certain ways.
+     * @param execTraceConfig - An object that configures simulation execution trace.
+     * @param initialStates - Initial states of resources that were accessed during simulation.
      */
-    constructor({ lastRound, txnGroups, version, evalOverrides, }) {
+    constructor({ lastRound, txnGroups, version, evalOverrides, execTraceConfig, initialStates, }) {
         super();
         this.lastRound = lastRound;
         this.txnGroups = txnGroups;
         this.version = version;
         this.evalOverrides = evalOverrides;
+        this.execTraceConfig = execTraceConfig;
+        this.initialStates = initialStates;
         this.attribute_map = {
             lastRound: 'last-round',
             txnGroups: 'txn-groups',
             version: 'version',
             evalOverrides: 'eval-overrides',
+            execTraceConfig: 'exec-trace-config',
+            initialStates: 'initial-states',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1925,6 +2338,51 @@ export class SimulateResponse extends BaseModel {
             evalOverrides: typeof data['eval-overrides'] !== 'undefined'
                 ? SimulationEvalOverrides.from_obj_for_encoding(data['eval-overrides'])
                 : undefined,
+            execTraceConfig: typeof data['exec-trace-config'] !== 'undefined'
+                ? SimulateTraceConfig.from_obj_for_encoding(data['exec-trace-config'])
+                : undefined,
+            initialStates: typeof data['initial-states'] !== 'undefined'
+                ? SimulateInitialStates.from_obj_for_encoding(data['initial-states'])
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * An object that configures simulation execution trace.
+ */
+export class SimulateTraceConfig extends BaseModel {
+    /**
+     * Creates a new `SimulateTraceConfig` object.
+     * @param enable - A boolean option for opting in execution trace features simulation endpoint.
+     * @param scratchChange - A boolean option enabling returning scratch slot changes together with execution
+     * trace during simulation.
+     * @param stackChange - A boolean option enabling returning stack changes together with execution trace
+     * during simulation.
+     * @param stateChange - A boolean option enabling returning application state changes (global, local,
+     * and box changes) with the execution trace during simulation.
+     */
+    constructor({ enable, scratchChange, stackChange, stateChange, }) {
+        super();
+        this.enable = enable;
+        this.scratchChange = scratchChange;
+        this.stackChange = stackChange;
+        this.stateChange = stateChange;
+        this.attribute_map = {
+            enable: 'enable',
+            scratchChange: 'scratch-change',
+            stackChange: 'stack-change',
+            stateChange: 'state-change',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulateTraceConfig({
+            enable: data['enable'],
+            scratchChange: data['scratch-change'],
+            stackChange: data['stack-change'],
+            stateChange: data['state-change'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1944,20 +2402,31 @@ export class SimulateTransactionGroupResult extends BaseModel {
      * indicate deeper inner transactions.
      * @param failureMessage - If present, indicates that the transaction group failed and specifies why that
      * happened
+     * @param unnamedResourcesAccessed - These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
      */
-    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, }) {
+    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, unnamedResourcesAccessed, }) {
         super();
         this.txnResults = txnResults;
         this.appBudgetAdded = appBudgetAdded;
         this.appBudgetConsumed = appBudgetConsumed;
         this.failedAt = failedAt;
         this.failureMessage = failureMessage;
+        this.unnamedResourcesAccessed = unnamedResourcesAccessed;
         this.attribute_map = {
             txnResults: 'txn-results',
             appBudgetAdded: 'app-budget-added',
             appBudgetConsumed: 'app-budget-consumed',
             failedAt: 'failed-at',
             failureMessage: 'failure-message',
+            unnamedResourcesAccessed: 'unnamed-resources-accessed',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1971,6 +2440,9 @@ export class SimulateTransactionGroupResult extends BaseModel {
             appBudgetConsumed: data['app-budget-consumed'],
             failedAt: data['failed-at'],
             failureMessage: data['failure-message'],
+            unnamedResourcesAccessed: typeof data['unnamed-resources-accessed'] !== 'undefined'
+                ? SimulateUnnamedResourcesAccessed.from_obj_for_encoding(data['unnamed-resources-accessed'])
+                : undefined,
         });
         /* eslint-enable dot-notation */
     }
@@ -1985,17 +2457,32 @@ export class SimulateTransactionResult extends BaseModel {
      * includes confirmation details like the round and reward details.
      * @param appBudgetConsumed - Budget used during execution of an app call transaction. This value includes
      * budged used by inner app calls spawned by this transaction.
+     * @param execTrace - The execution trace of calling an app or a logic sig, containing the inner app
+     * call trace in a recursive way.
      * @param logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
+     * @param unnamedResourcesAccessed - These are resources that were accessed by this group that would normally have
+     * caused failure, but were allowed in simulation. Depending on where this object
+     * is in the response, the unnamed resources it contains may or may not qualify for
+     * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+     * the resources do qualify, but if this is a field in SimulateTransactionResult,
+     * they do not qualify. In order to make this group valid for actual submission,
+     * resources that qualify for group sharing can be made available by any
+     * transaction of the group; otherwise, resources must be placed in the same
+     * transaction which accessed them.
      */
-    constructor({ txnResult, appBudgetConsumed, logicSigBudgetConsumed, }) {
+    constructor({ txnResult, appBudgetConsumed, execTrace, logicSigBudgetConsumed, unnamedResourcesAccessed, }) {
         super();
         this.txnResult = txnResult;
         this.appBudgetConsumed = appBudgetConsumed;
+        this.execTrace = execTrace;
         this.logicSigBudgetConsumed = logicSigBudgetConsumed;
+        this.unnamedResourcesAccessed = unnamedResourcesAccessed;
         this.attribute_map = {
             txnResult: 'txn-result',
             appBudgetConsumed: 'app-budget-consumed',
+            execTrace: 'exec-trace',
             logicSigBudgetConsumed: 'logic-sig-budget-consumed',
+            unnamedResourcesAccessed: 'unnamed-resources-accessed',
         };
     }
     // eslint-disable-next-line camelcase
@@ -2006,7 +2493,80 @@ export class SimulateTransactionResult extends BaseModel {
         return new SimulateTransactionResult({
             txnResult: PendingTransactionResponse.from_obj_for_encoding(data['txn-result']),
             appBudgetConsumed: data['app-budget-consumed'],
+            execTrace: typeof data['exec-trace'] !== 'undefined'
+                ? SimulationTransactionExecTrace.from_obj_for_encoding(data['exec-trace'])
+                : undefined,
             logicSigBudgetConsumed: data['logic-sig-budget-consumed'],
+            unnamedResourcesAccessed: typeof data['unnamed-resources-accessed'] !== 'undefined'
+                ? SimulateUnnamedResourcesAccessed.from_obj_for_encoding(data['unnamed-resources-accessed'])
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * These are resources that were accessed by this group that would normally have
+ * caused failure, but were allowed in simulation. Depending on where this object
+ * is in the response, the unnamed resources it contains may or may not qualify for
+ * group resource sharing. If this is a field in SimulateTransactionGroupResult,
+ * the resources do qualify, but if this is a field in SimulateTransactionResult,
+ * they do not qualify. In order to make this group valid for actual submission,
+ * resources that qualify for group sharing can be made available by any
+ * transaction of the group; otherwise, resources must be placed in the same
+ * transaction which accessed them.
+ */
+export class SimulateUnnamedResourcesAccessed extends BaseModel {
+    /**
+     * Creates a new `SimulateUnnamedResourcesAccessed` object.
+     * @param accounts - The unnamed accounts that were referenced. The order of this array is arbitrary.
+     * @param appLocals - The unnamed application local states that were referenced. The order of this
+     * array is arbitrary.
+     * @param apps - The unnamed applications that were referenced. The order of this array is
+     * arbitrary.
+     * @param assetHoldings - The unnamed asset holdings that were referenced. The order of this array is
+     * arbitrary.
+     * @param assets - The unnamed assets that were referenced. The order of this array is arbitrary.
+     * @param boxes - The unnamed boxes that were referenced. The order of this array is arbitrary.
+     * @param extraBoxRefs - The number of extra box references used to increase the IO budget. This is in
+     * addition to the references defined in the input transaction group and any
+     * referenced to unnamed boxes.
+     */
+    constructor({ accounts, appLocals, apps, assetHoldings, assets, boxes, extraBoxRefs, }) {
+        super();
+        this.accounts = accounts;
+        this.appLocals = appLocals;
+        this.apps = apps;
+        this.assetHoldings = assetHoldings;
+        this.assets = assets;
+        this.boxes = boxes;
+        this.extraBoxRefs = extraBoxRefs;
+        this.attribute_map = {
+            accounts: 'accounts',
+            appLocals: 'app-locals',
+            apps: 'apps',
+            assetHoldings: 'asset-holdings',
+            assets: 'assets',
+            boxes: 'boxes',
+            extraBoxRefs: 'extra-box-refs',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulateUnnamedResourcesAccessed({
+            accounts: data['accounts'],
+            appLocals: typeof data['app-locals'] !== 'undefined'
+                ? data['app-locals'].map(ApplicationLocalReference.from_obj_for_encoding)
+                : undefined,
+            apps: data['apps'],
+            assetHoldings: typeof data['asset-holdings'] !== 'undefined'
+                ? data['asset-holdings'].map(AssetHoldingReference.from_obj_for_encoding)
+                : undefined,
+            assets: data['assets'],
+            boxes: typeof data['boxes'] !== 'undefined'
+                ? data['boxes'].map(BoxReference.from_obj_for_encoding)
+                : undefined,
+            extraBoxRefs: data['extra-box-refs'],
         });
         /* eslint-enable dot-notation */
     }
@@ -2021,18 +2581,21 @@ export class SimulationEvalOverrides extends BaseModel {
      * Creates a new `SimulationEvalOverrides` object.
      * @param allowEmptySignatures - If true, transactions without signatures are allowed and simulated as if they
      * were properly signed.
+     * @param allowUnnamedResources - If true, allows access to unnamed resources during simulation.
      * @param extraOpcodeBudget - The extra opcode budget added to each transaction group during simulation
      * @param maxLogCalls - The maximum log calls one can make during simulation
      * @param maxLogSize - The maximum byte number to log during simulation
      */
-    constructor({ allowEmptySignatures, extraOpcodeBudget, maxLogCalls, maxLogSize, }) {
+    constructor({ allowEmptySignatures, allowUnnamedResources, extraOpcodeBudget, maxLogCalls, maxLogSize, }) {
         super();
         this.allowEmptySignatures = allowEmptySignatures;
+        this.allowUnnamedResources = allowUnnamedResources;
         this.extraOpcodeBudget = extraOpcodeBudget;
         this.maxLogCalls = maxLogCalls;
         this.maxLogSize = maxLogSize;
         this.attribute_map = {
             allowEmptySignatures: 'allow-empty-signatures',
+            allowUnnamedResources: 'allow-unnamed-resources',
             extraOpcodeBudget: 'extra-opcode-budget',
             maxLogCalls: 'max-log-calls',
             maxLogSize: 'max-log-size',
@@ -2043,6 +2606,7 @@ export class SimulationEvalOverrides extends BaseModel {
         /* eslint-disable dot-notation */
         return new SimulationEvalOverrides({
             allowEmptySignatures: data['allow-empty-signatures'],
+            allowUnnamedResources: data['allow-unnamed-resources'],
             extraOpcodeBudget: data['extra-opcode-budget'],
             maxLogCalls: data['max-log-calls'],
             maxLogSize: data['max-log-size'],
@@ -2050,6 +2614,125 @@ export class SimulationEvalOverrides extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * The set of trace information and effect from evaluating a single opcode.
+ */
+export class SimulationOpcodeTraceUnit extends BaseModel {
+    /**
+     * Creates a new `SimulationOpcodeTraceUnit` object.
+     * @param pc - The program counter of the current opcode being evaluated.
+     * @param scratchChanges - The writes into scratch slots.
+     * @param spawnedInners - The indexes of the traces for inner transactions spawned by this opcode, if any.
+     * @param stackAdditions - The values added by this opcode to the stack.
+     * @param stackPopCount - The number of deleted stack values by this opcode.
+     * @param stateChanges - The operations against the current application's states.
+     */
+    constructor({ pc, scratchChanges, spawnedInners, stackAdditions, stackPopCount, stateChanges, }) {
+        super();
+        this.pc = pc;
+        this.scratchChanges = scratchChanges;
+        this.spawnedInners = spawnedInners;
+        this.stackAdditions = stackAdditions;
+        this.stackPopCount = stackPopCount;
+        this.stateChanges = stateChanges;
+        this.attribute_map = {
+            pc: 'pc',
+            scratchChanges: 'scratch-changes',
+            spawnedInners: 'spawned-inners',
+            stackAdditions: 'stack-additions',
+            stackPopCount: 'stack-pop-count',
+            stateChanges: 'state-changes',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['pc'] === 'undefined')
+            throw new Error(`Response is missing required field 'pc': ${data}`);
+        return new SimulationOpcodeTraceUnit({
+            pc: data['pc'],
+            scratchChanges: typeof data['scratch-changes'] !== 'undefined'
+                ? data['scratch-changes'].map(ScratchChange.from_obj_for_encoding)
+                : undefined,
+            spawnedInners: data['spawned-inners'],
+            stackAdditions: typeof data['stack-additions'] !== 'undefined'
+                ? data['stack-additions'].map(AvmValue.from_obj_for_encoding)
+                : undefined,
+            stackPopCount: data['stack-pop-count'],
+            stateChanges: typeof data['state-changes'] !== 'undefined'
+                ? data['state-changes'].map(ApplicationStateOperation.from_obj_for_encoding)
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * The execution trace of calling an app or a logic sig, containing the inner app
+ * call trace in a recursive way.
+ */
+export class SimulationTransactionExecTrace extends BaseModel {
+    /**
+     * Creates a new `SimulationTransactionExecTrace` object.
+     * @param approvalProgramHash - SHA512_256 hash digest of the approval program executed in transaction.
+     * @param approvalProgramTrace - Program trace that contains a trace of opcode effects in an approval program.
+     * @param clearStateProgramHash - SHA512_256 hash digest of the clear state program executed in transaction.
+     * @param clearStateProgramTrace - Program trace that contains a trace of opcode effects in a clear state program.
+     * @param innerTrace - An array of SimulationTransactionExecTrace representing the execution trace of
+     * any inner transactions executed.
+     * @param logicSigHash - SHA512_256 hash digest of the logic sig executed in transaction.
+     * @param logicSigTrace - Program trace that contains a trace of opcode effects in a logic sig.
+     */
+    constructor({ approvalProgramHash, approvalProgramTrace, clearStateProgramHash, clearStateProgramTrace, innerTrace, logicSigHash, logicSigTrace, }) {
+        super();
+        this.approvalProgramHash =
+            typeof approvalProgramHash === 'string'
+                ? new Uint8Array(Buffer.from(approvalProgramHash, 'base64'))
+                : approvalProgramHash;
+        this.approvalProgramTrace = approvalProgramTrace;
+        this.clearStateProgramHash =
+            typeof clearStateProgramHash === 'string'
+                ? new Uint8Array(Buffer.from(clearStateProgramHash, 'base64'))
+                : clearStateProgramHash;
+        this.clearStateProgramTrace = clearStateProgramTrace;
+        this.innerTrace = innerTrace;
+        this.logicSigHash =
+            typeof logicSigHash === 'string'
+                ? new Uint8Array(Buffer.from(logicSigHash, 'base64'))
+                : logicSigHash;
+        this.logicSigTrace = logicSigTrace;
+        this.attribute_map = {
+            approvalProgramHash: 'approval-program-hash',
+            approvalProgramTrace: 'approval-program-trace',
+            clearStateProgramHash: 'clear-state-program-hash',
+            clearStateProgramTrace: 'clear-state-program-trace',
+            innerTrace: 'inner-trace',
+            logicSigHash: 'logic-sig-hash',
+            logicSigTrace: 'logic-sig-trace',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulationTransactionExecTrace({
+            approvalProgramHash: data['approval-program-hash'],
+            approvalProgramTrace: typeof data['approval-program-trace'] !== 'undefined'
+                ? data['approval-program-trace'].map(SimulationOpcodeTraceUnit.from_obj_for_encoding)
+                : undefined,
+            clearStateProgramHash: data['clear-state-program-hash'],
+            clearStateProgramTrace: typeof data['clear-state-program-trace'] !== 'undefined'
+                ? data['clear-state-program-trace'].map(SimulationOpcodeTraceUnit.from_obj_for_encoding)
+                : undefined,
+            innerTrace: typeof data['inner-trace'] !== 'undefined'
+                ? data['inner-trace'].map(SimulationTransactionExecTrace.from_obj_for_encoding)
+                : undefined,
+            logicSigHash: data['logic-sig-hash'],
+            logicSigTrace: typeof data['logic-sig-trace'] !== 'undefined'
+                ? data['logic-sig-trace'].map(SimulationOpcodeTraceUnit.from_obj_for_encoding)
+                : undefined,
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Represents a state proof and its corresponding message
  */
@@ -2264,7 +2947,7 @@ export class TransactionGroupLedgerStateDeltasForRoundResponse extends BaseModel
         super();
         this.deltas = deltas;
         this.attribute_map = {
-            deltas: 'deltas',
+            deltas: 'Deltas',
         };
     }
     // eslint-disable-next-line camelcase