algosdk 2.4.0 → 2.6.0

package/dist/types/client/v2/algod/models/types.d.ts

@@ -375,6 +375,88 @@ export declare class Application extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): Application;
 }
+/**
+ * An application's initial global/local/box states that were accessed during
+ * simulation.
+ */
+export declare class ApplicationInitialStates extends BaseModel {
+    /**
+     * Application index.
+     */
+    id: number | bigint;
+    /**
+     * An application's global/local/box state.
+     */
+    appBoxes?: ApplicationKVStorage;
+    /**
+     * An application's global/local/box state.
+     */
+    appGlobals?: ApplicationKVStorage;
+    /**
+     * An application's initial local states tied to different accounts.
+     */
+    appLocals?: ApplicationKVStorage[];
+    /**
+     * 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, }: {
+        id: number | bigint;
+        appBoxes?: ApplicationKVStorage;
+        appGlobals?: ApplicationKVStorage;
+        appLocals?: ApplicationKVStorage[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): ApplicationInitialStates;
+}
+/**
+ * An application's global/local/box state.
+ */
+export declare class ApplicationKVStorage extends BaseModel {
+    /**
+     * Key-Value pairs representing application states.
+     */
+    kvs: AvmKeyValue[];
+    /**
+     * The address of the account associated with the local state.
+     */
+    account?: string;
+    /**
+     * 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 }: {
+        kvs: AvmKeyValue[];
+        account?: string;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): ApplicationKVStorage;
+}
+/**
+ * References an account's local state for an application.
+ */
+export declare class ApplicationLocalReference extends BaseModel {
+    /**
+     * Address of the account with the local state.
+     */
+    account: string;
+    /**
+     * Application ID of the local state application.
+     */
+    app: number | bigint;
+    /**
+     * 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 }: {
+        account: string;
+        app: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): ApplicationLocalReference;
+}
 /**
  * Stores local state associated with an application.
  */
@@ -459,6 +541,51 @@ export declare class ApplicationParams extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): ApplicationParams;
 }
+/**
+ * An operation against an application's global/local/box state.
+ */
+export declare class ApplicationStateOperation extends BaseModel {
+    /**
+     * Type of application state. Value `g` is **global state**, `l` is **local
+     * state**, `b` is **boxes**.
+     */
+    appStateType: string;
+    /**
+     * The key (name) of the global/local/box state.
+     */
+    key: Uint8Array;
+    /**
+     * Operation type. Value `w` is **write**, `d` is **delete**.
+     */
+    operation: string;
+    /**
+     * For local state changes, the address of the account associated with the local
+     * state.
+     */
+    account?: string;
+    /**
+     * Represents an AVM value.
+     */
+    newValue?: AvmValue;
+    /**
+     * 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, }: {
+        appStateType: string;
+        key: string | Uint8Array;
+        operation: string;
+        account?: string;
+        newValue?: AvmValue;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): ApplicationStateOperation;
+}
 /**
  * Specifies maximums on the number of each type that may be stored.
  */
@@ -542,6 +669,29 @@ export declare class AssetHolding extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): AssetHolding;
 }
+/**
+ * References an asset held by an account.
+ */
+export declare class AssetHoldingReference extends BaseModel {
+    /**
+     * Address of the account holding the asset.
+     */
+    account: string;
+    /**
+     * Asset ID of the holding.
+     */
+    asset: number | bigint;
+    /**
+     * Creates a new `AssetHoldingReference` object.
+     * @param account - Address of the account holding the asset.
+     * @param asset - Asset ID of the holding.
+     */
+    constructor({ account, asset }: {
+        account: string;
+        asset: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AssetHoldingReference;
+}
 /**
  * AssetParams specifies the parameters for an asset.
  * (apar) when part of an AssetConfig transaction.
@@ -668,6 +818,55 @@ export declare class AssetParams extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): AssetParams;
 }
+/**
+ * Represents an AVM key-value pair in an application store.
+ */
+export declare class AvmKeyValue extends BaseModel {
+    key: Uint8Array;
+    /**
+     * Represents an AVM value.
+     */
+    value: AvmValue;
+    /**
+     * Creates a new `AvmKeyValue` object.
+     * @param key -
+     * @param value - Represents an AVM value.
+     */
+    constructor({ key, value }: {
+        key: string | Uint8Array;
+        value: AvmValue;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AvmKeyValue;
+}
+/**
+ * Represents an AVM value.
+ */
+export declare class AvmValue extends BaseModel {
+    /**
+     * value type. Value `1` refers to **bytes**, value `2` refers to **uint64**
+     */
+    type: number | bigint;
+    /**
+     * bytes value.
+     */
+    bytes?: Uint8Array;
+    /**
+     * uint value.
+     */
+    uint?: number | bigint;
+    /**
+     * 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, }: {
+        type: number | bigint;
+        bytes?: string | Uint8Array;
+        uint?: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AvmValue;
+}
 /**
  * Hash of a block header.
  */
@@ -710,6 +909,23 @@ export declare class BlockResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): BlockResponse;
 }
+/**
+ * Top level transaction IDs in a block.
+ */
+export declare class BlockTxidsResponse extends BaseModel {
+    /**
+     * Block transaction IDs.
+     */
+    blocktxids: string[];
+    /**
+     * Creates a new `BlockTxidsResponse` object.
+     * @param blocktxids - Block transaction IDs.
+     */
+    constructor({ blocktxids }: {
+        blocktxids: string[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): BlockTxidsResponse;
+}
 /**
  * Box name and its content.
  */
@@ -718,6 +934,10 @@ export declare class Box extends BaseModel {
      * (name) box name, base64 encoded
      */
     name: Uint8Array;
+    /**
+     * The round for which this information is relevant
+     */
+    round: number | bigint;
     /**
      * (value) box value, base64 encoded.
      */
@@ -725,10 +945,12 @@ export declare 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, }: {
         name: string | Uint8Array;
+        round: number | bigint;
         value: string | Uint8Array;
     });
     static from_obj_for_encoding(data: Record<string, any>): Box;
@@ -750,6 +972,29 @@ export declare class BoxDescriptor extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): BoxDescriptor;
 }
+/**
+ * References a box of an application.
+ */
+export declare class BoxReference extends BaseModel {
+    /**
+     * Application ID which this box belongs to
+     */
+    app: number | bigint;
+    /**
+     * Base64 encoded box name
+     */
+    name: Uint8Array;
+    /**
+     * Creates a new `BoxReference` object.
+     * @param app - Application ID which this box belongs to
+     * @param name - Base64 encoded box name
+     */
+    constructor({ app, name, }: {
+        app: number | bigint;
+        name: string | Uint8Array;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): BoxReference;
+}
 /**
  * Box names of an application
  */
@@ -1539,6 +1784,48 @@ export declare class PostTransactionsResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): PostTransactionsResponse;
 }
+/**
+ * A write operation into a scratch slot.
+ */
+export declare class ScratchChange extends BaseModel {
+    /**
+     * Represents an AVM value.
+     */
+    newValue: AvmValue;
+    /**
+     * The scratch slot written.
+     */
+    slot: number | bigint;
+    /**
+     * Creates a new `ScratchChange` object.
+     * @param newValue - Represents an AVM value.
+     * @param slot - The scratch slot written.
+     */
+    constructor({ newValue, slot, }: {
+        newValue: AvmValue;
+        slot: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): ScratchChange;
+}
+/**
+ * Initial states of resources that were accessed during simulation.
+ */
+export declare class SimulateInitialStates extends BaseModel {
+    /**
+     * The initial states of accessed application before simulation. The order of this
+     * array is arbitrary.
+     */
+    appInitialStates?: ApplicationInitialStates[];
+    /**
+     * Creates a new `SimulateInitialStates` object.
+     * @param appInitialStates - The initial states of accessed application before simulation. The order of this
+     * array is arbitrary.
+     */
+    constructor({ appInitialStates, }: {
+        appInitialStates?: ApplicationInitialStates[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateInitialStates;
+}
 /**
  * Request type for simulation endpoint.
  */
@@ -1548,7 +1835,7 @@ export declare class SimulateRequest extends BaseModel {
      */
     txnGroups: SimulateRequestTransactionGroup[];
     /**
-     * Allow transactions without signatures to be simulated as if they had correct
+     * Allows transactions without signatures to be simulated as if they had correct
      * signatures.
      */
     allowEmptySignatures?: boolean;
@@ -1556,23 +1843,47 @@ export declare class SimulateRequest extends BaseModel {
      * Lifts limits on log opcode usage during simulation.
      */
     allowMoreLogging?: boolean;
+    /**
+     * Allows access to unnamed resources during simulation.
+     */
+    allowUnnamedResources?: boolean;
+    /**
+     * An object that configures simulation execution trace.
+     */
+    execTraceConfig?: SimulateTraceConfig;
     /**
      * Applies extra opcode budget during simulation for each transaction group.
      */
     extraOpcodeBudget?: number | bigint;
+    /**
+     * 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.
+     */
+    round?: number | bigint;
     /**
      * 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, }: {
         txnGroups: SimulateRequestTransactionGroup[];
         allowEmptySignatures?: boolean;
         allowMoreLogging?: boolean;
+        allowUnnamedResources?: boolean;
+        execTraceConfig?: SimulateTraceConfig;
         extraOpcodeBudget?: number | bigint;
+        round?: number | bigint;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateRequest;
 }
@@ -1616,6 +1927,14 @@ export declare class SimulateResponse extends BaseModel {
      * evaluation in certain ways.
      */
     evalOverrides?: SimulationEvalOverrides;
+    /**
+     * An object that configures simulation execution trace.
+     */
+    execTraceConfig?: SimulateTraceConfig;
+    /**
+     * Initial states of resources that were accessed during simulation.
+     */
+    initialStates?: SimulateInitialStates;
     /**
      * Creates a new `SimulateResponse` object.
      * @param lastRound - The round immediately preceding this simulation. State changes through this
@@ -1625,15 +1944,60 @@ export declare 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, }: {
         lastRound: number | bigint;
         txnGroups: SimulateTransactionGroupResult[];
         version: number | bigint;
         evalOverrides?: SimulationEvalOverrides;
+        execTraceConfig?: SimulateTraceConfig;
+        initialStates?: SimulateInitialStates;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateResponse;
 }
+/**
+ * An object that configures simulation execution trace.
+ */
+export declare class SimulateTraceConfig extends BaseModel {
+    /**
+     * A boolean option for opting in execution trace features simulation endpoint.
+     */
+    enable?: boolean;
+    /**
+     * A boolean option enabling returning scratch slot changes together with execution
+     * trace during simulation.
+     */
+    scratchChange?: boolean;
+    /**
+     * A boolean option enabling returning stack changes together with execution trace
+     * during simulation.
+     */
+    stackChange?: boolean;
+    /**
+     * A boolean option enabling returning application state changes (global, local,
+     * and box changes) with the execution trace during simulation.
+     */
+    stateChange?: boolean;
+    /**
+     * 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, }: {
+        enable?: boolean;
+        scratchChange?: boolean;
+        stackChange?: boolean;
+        stateChange?: boolean;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateTraceConfig;
+}
 /**
  * Simulation result for an atomic transaction group
  */
@@ -1662,6 +2026,18 @@ export declare class SimulateTransactionGroupResult extends BaseModel {
      * happened
      */
     failureMessage?: string;
+    /**
+     * 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.
+     */
+    unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
     /**
      * Creates a new `SimulateTransactionGroupResult` object.
      * @param txnResults - Simulation result for individual transactions
@@ -1673,13 +2049,23 @@ export declare class SimulateTransactionGroupResult extends BaseModel {
      * indicate deeper inner transactions.
      * @param failureMessage - If present, indicates that the transaction group failed and specifies why that
      * happened
-     */
-    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, }: {
+     * @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, unnamedResourcesAccessed, }: {
         txnResults: SimulateTransactionResult[];
         appBudgetAdded?: number | bigint;
         appBudgetConsumed?: number | bigint;
         failedAt?: (number | bigint)[];
         failureMessage?: string;
+        unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateTransactionGroupResult;
 }
@@ -1697,25 +2083,126 @@ export declare class SimulateTransactionResult extends BaseModel {
      * budged used by inner app calls spawned by this transaction.
      */
     appBudgetConsumed?: number | bigint;
+    /**
+     * The execution trace of calling an app or a logic sig, containing the inner app
+     * call trace in a recursive way.
+     */
+    execTrace?: SimulationTransactionExecTrace;
     /**
      * Budget used during execution of a logic sig transaction.
      */
     logicSigBudgetConsumed?: number | bigint;
+    /**
+     * 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.
+     */
+    unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
     /**
      * Creates a new `SimulateTransactionResult` object.
      * @param txnResult - Details about a pending transaction. If the transaction was recently confirmed,
      * 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.
-     */
-    constructor({ txnResult, appBudgetConsumed, logicSigBudgetConsumed, }: {
+     * @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, execTrace, logicSigBudgetConsumed, unnamedResourcesAccessed, }: {
         txnResult: PendingTransactionResponse;
         appBudgetConsumed?: number | bigint;
+        execTrace?: SimulationTransactionExecTrace;
         logicSigBudgetConsumed?: number | bigint;
+        unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateTransactionResult;
 }
+/**
+ * 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 declare class SimulateUnnamedResourcesAccessed extends BaseModel {
+    /**
+     * The unnamed accounts that were referenced. The order of this array is arbitrary.
+     */
+    accounts?: string[];
+    /**
+     * The unnamed application local states that were referenced. The order of this
+     * array is arbitrary.
+     */
+    appLocals?: ApplicationLocalReference[];
+    /**
+     * The unnamed applications that were referenced. The order of this array is
+     * arbitrary.
+     */
+    apps?: (number | bigint)[];
+    /**
+     * The unnamed asset holdings that were referenced. The order of this array is
+     * arbitrary.
+     */
+    assetHoldings?: AssetHoldingReference[];
+    /**
+     * The unnamed assets that were referenced. The order of this array is arbitrary.
+     */
+    assets?: (number | bigint)[];
+    /**
+     * The unnamed boxes that were referenced. The order of this array is arbitrary.
+     */
+    boxes?: BoxReference[];
+    /**
+     * 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.
+     */
+    extraBoxRefs?: number | bigint;
+    /**
+     * 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, }: {
+        accounts?: string[];
+        appLocals?: ApplicationLocalReference[];
+        apps?: (number | bigint)[];
+        assetHoldings?: AssetHoldingReference[];
+        assets?: (number | bigint)[];
+        boxes?: BoxReference[];
+        extraBoxRefs?: number | bigint;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulateUnnamedResourcesAccessed;
+}
 /**
  * The set of parameters and limits override during simulation. If this set of
  * parameters is present, then evaluation parameters may differ from standard
@@ -1727,6 +2214,10 @@ export declare class SimulationEvalOverrides extends BaseModel {
      * were properly signed.
      */
     allowEmptySignatures?: boolean;
+    /**
+     * If true, allows access to unnamed resources during simulation.
+     */
+    allowUnnamedResources?: boolean;
     /**
      * The extra opcode budget added to each transaction group during simulation
      */
@@ -1743,18 +2234,123 @@ export declare 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, }: {
         allowEmptySignatures?: boolean;
+        allowUnnamedResources?: boolean;
         extraOpcodeBudget?: number | bigint;
         maxLogCalls?: number | bigint;
         maxLogSize?: number | bigint;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulationEvalOverrides;
 }
+/**
+ * The set of trace information and effect from evaluating a single opcode.
+ */
+export declare class SimulationOpcodeTraceUnit extends BaseModel {
+    /**
+     * The program counter of the current opcode being evaluated.
+     */
+    pc: number | bigint;
+    /**
+     * The writes into scratch slots.
+     */
+    scratchChanges?: ScratchChange[];
+    /**
+     * The indexes of the traces for inner transactions spawned by this opcode, if any.
+     */
+    spawnedInners?: (number | bigint)[];
+    /**
+     * The values added by this opcode to the stack.
+     */
+    stackAdditions?: AvmValue[];
+    /**
+     * The number of deleted stack values by this opcode.
+     */
+    stackPopCount?: number | bigint;
+    /**
+     * The operations against the current application's states.
+     */
+    stateChanges?: ApplicationStateOperation[];
+    /**
+     * 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, }: {
+        pc: number | bigint;
+        scratchChanges?: ScratchChange[];
+        spawnedInners?: (number | bigint)[];
+        stackAdditions?: AvmValue[];
+        stackPopCount?: number | bigint;
+        stateChanges?: ApplicationStateOperation[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulationOpcodeTraceUnit;
+}
+/**
+ * The execution trace of calling an app or a logic sig, containing the inner app
+ * call trace in a recursive way.
+ */
+export declare class SimulationTransactionExecTrace extends BaseModel {
+    /**
+     * SHA512_256 hash digest of the approval program executed in transaction.
+     */
+    approvalProgramHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in an approval program.
+     */
+    approvalProgramTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * SHA512_256 hash digest of the clear state program executed in transaction.
+     */
+    clearStateProgramHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in a clear state program.
+     */
+    clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * An array of SimulationTransactionExecTrace representing the execution trace of
+     * any inner transactions executed.
+     */
+    innerTrace?: SimulationTransactionExecTrace[];
+    /**
+     * SHA512_256 hash digest of the logic sig executed in transaction.
+     */
+    logicSigHash?: Uint8Array;
+    /**
+     * Program trace that contains a trace of opcode effects in a logic sig.
+     */
+    logicSigTrace?: SimulationOpcodeTraceUnit[];
+    /**
+     * 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, }: {
+        approvalProgramHash?: string | Uint8Array;
+        approvalProgramTrace?: SimulationOpcodeTraceUnit[];
+        clearStateProgramHash?: string | Uint8Array;
+        clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+        innerTrace?: SimulationTransactionExecTrace[];
+        logicSigHash?: string | Uint8Array;
+        logicSigTrace?: SimulationOpcodeTraceUnit[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): SimulationTransactionExecTrace;
+}
 /**
  * Represents a state proof and its corresponding message
  */