algosdk 2.5.0 → 2.7.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,26 @@ 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.
  */
@@ -739,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.
  */
@@ -785,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
  */
@@ -1597,6 +1807,25 @@ export declare class ScratchChange extends BaseModel {
     });
     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.
  */
@@ -1606,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;
@@ -1614,6 +1843,10 @@ 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.
      */
@@ -1622,21 +1855,35 @@ export declare class SimulateRequest extends BaseModel {
      * 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, execTraceConfig, 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;
 }
@@ -1684,6 +1931,10 @@ export declare class SimulateResponse extends BaseModel {
      * 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
@@ -1694,13 +1945,15 @@ export declare class SimulateResponse extends BaseModel {
      * 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, execTraceConfig, }: {
+    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;
 }
@@ -1722,6 +1975,11 @@ export declare class SimulateTraceConfig extends BaseModel {
      * 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.
@@ -1729,11 +1987,14 @@ export declare class SimulateTraceConfig extends BaseModel {
      * 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, }: {
+    constructor({ enable, scratchChange, stackChange, stateChange, }: {
         enable?: boolean;
         scratchChange?: boolean;
         stackChange?: boolean;
+        stateChange?: boolean;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateTraceConfig;
 }
@@ -1765,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
@@ -1776,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;
 }
@@ -1809,6 +2092,18 @@ export declare class SimulateTransactionResult extends BaseModel {
      * 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,
@@ -1818,15 +2113,96 @@ export declare class SimulateTransactionResult extends BaseModel {
      * @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, execTrace, 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
@@ -1838,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
      */
@@ -1854,12 +2234,14 @@ 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;
@@ -1890,6 +2272,10 @@ export declare class SimulationOpcodeTraceUnit extends BaseModel {
      * 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.
@@ -1897,13 +2283,15 @@ export declare class SimulationOpcodeTraceUnit extends BaseModel {
      * @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, }: {
+    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;
 }
@@ -1912,10 +2300,18 @@ export declare class SimulationOpcodeTraceUnit extends BaseModel {
  * 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.
      */
@@ -1925,22 +2321,32 @@ export declare class SimulationTransactionExecTrace extends BaseModel {
      * 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({ approvalProgramTrace, clearStateProgramTrace, innerTrace, logicSigTrace, }: {
+    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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -23,7 +23,6 @@
   "dependencies": {
     "algo-msgpack-with-bigint": "^2.1.1",
     "buffer": "^6.0.3",
-    "cross-fetch": "^4.0.0",
     "hi-base32": "^0.5.1",
     "js-sha256": "^0.9.0",
     "js-sha3": "^0.8.0",
@@ -80,6 +79,6 @@
   "author": "Algorand, llc",
   "license": "MIT",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   }
 }

package/src/client/urlTokenBaseHTTPClient.ts

@@ -1,5 +1,4 @@
 import { Buffer } from 'buffer';
-import { fetch, Response, Headers } from 'cross-fetch';
 import {
   BaseHTTPClient,
   BaseHTTPClientResponse,