algosdk 2.3.0 → 2.5.0

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

@@ -721,6 +721,43 @@ export class AssetParams extends BaseModel {
         /* 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.
  */
@@ -785,20 +822,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 +847,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 */
@@ -1443,6 +1486,38 @@ export class KvDelta extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Contains a ledger delta for a single transaction group
+ */
+export class LedgerStateDeltaForTransactionGroup extends BaseModel {
+    /**
+     * Creates a new `LedgerStateDeltaForTransactionGroup` object.
+     * @param delta - Ledger StateDelta object
+     * @param ids -
+     */
+    constructor({ delta, ids }) {
+        super();
+        this.delta = delta;
+        this.ids = ids;
+        this.attribute_map = {
+            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}`);
+        return new LedgerStateDeltaForTransactionGroup({
+            delta: data['Delta'],
+            ids: data['Ids'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Proof of membership and position of a light block header.
  */
@@ -1785,6 +1860,38 @@ 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 */
+    }
+}
 /**
  * Request type for simulation endpoint.
  */
@@ -1795,16 +1902,22 @@ export class SimulateRequest extends BaseModel {
      * @param allowEmptySignatures - Allow transactions without signatures to be simulated as if they had correct
      * signatures.
      * @param allowMoreLogging - Lifts limits on log opcode usage during simulation.
+     * @param execTraceConfig - An object that configures simulation execution trace.
+     * @param extraOpcodeBudget - Applies extra opcode budget during simulation for each transaction group.
      */
-    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, }) {
+    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, execTraceConfig, extraOpcodeBudget, }) {
         super();
         this.txnGroups = txnGroups;
         this.allowEmptySignatures = allowEmptySignatures;
         this.allowMoreLogging = allowMoreLogging;
+        this.execTraceConfig = execTraceConfig;
+        this.extraOpcodeBudget = extraOpcodeBudget;
         this.attribute_map = {
             txnGroups: 'txn-groups',
             allowEmptySignatures: 'allow-empty-signatures',
             allowMoreLogging: 'allow-more-logging',
+            execTraceConfig: 'exec-trace-config',
+            extraOpcodeBudget: 'extra-opcode-budget',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1816,6 +1929,10 @@ 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'],
+            execTraceConfig: typeof data['exec-trace-config'] !== 'undefined'
+                ? SimulateTraceConfig.from_obj_for_encoding(data['exec-trace-config'])
+                : undefined,
+            extraOpcodeBudget: data['extra-opcode-budget'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1859,18 +1976,21 @@ 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.
      */
-    constructor({ lastRound, txnGroups, version, evalOverrides, }) {
+    constructor({ lastRound, txnGroups, version, evalOverrides, execTraceConfig, }) {
         super();
         this.lastRound = lastRound;
         this.txnGroups = txnGroups;
         this.version = version;
         this.evalOverrides = evalOverrides;
+        this.execTraceConfig = execTraceConfig;
         this.attribute_map = {
             lastRound: 'last-round',
             txnGroups: 'txn-groups',
             version: 'version',
             evalOverrides: 'eval-overrides',
+            execTraceConfig: 'exec-trace-config',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1889,6 +2009,43 @@ 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,
+        });
+        /* 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.
+     */
+    constructor({ enable, scratchChange, stackChange, }) {
+        super();
+        this.enable = enable;
+        this.scratchChange = scratchChange;
+        this.stackChange = stackChange;
+        this.attribute_map = {
+            enable: 'enable',
+            scratchChange: 'scratch-change',
+            stackChange: 'stack-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'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1949,16 +2106,20 @@ 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.
      */
-    constructor({ txnResult, appBudgetConsumed, logicSigBudgetConsumed, }) {
+    constructor({ txnResult, appBudgetConsumed, execTrace, logicSigBudgetConsumed, }) {
         super();
         this.txnResult = txnResult;
         this.appBudgetConsumed = appBudgetConsumed;
+        this.execTrace = execTrace;
         this.logicSigBudgetConsumed = logicSigBudgetConsumed;
         this.attribute_map = {
             txnResult: 'txn-result',
             appBudgetConsumed: 'app-budget-consumed',
+            execTrace: 'exec-trace',
             logicSigBudgetConsumed: 'logic-sig-budget-consumed',
         };
     }
@@ -1970,6 +2131,9 @@ 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'],
         });
         /* eslint-enable dot-notation */
@@ -1985,16 +2149,19 @@ 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 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, maxLogCalls, maxLogSize, }) {
+    constructor({ allowEmptySignatures, extraOpcodeBudget, maxLogCalls, maxLogSize, }) {
         super();
         this.allowEmptySignatures = allowEmptySignatures;
+        this.extraOpcodeBudget = extraOpcodeBudget;
         this.maxLogCalls = maxLogCalls;
         this.maxLogSize = maxLogSize;
         this.attribute_map = {
             allowEmptySignatures: 'allow-empty-signatures',
+            extraOpcodeBudget: 'extra-opcode-budget',
             maxLogCalls: 'max-log-calls',
             maxLogSize: 'max-log-size',
         };
@@ -2004,12 +2171,105 @@ export class SimulationEvalOverrides extends BaseModel {
         /* eslint-disable dot-notation */
         return new SimulationEvalOverrides({
             allowEmptySignatures: data['allow-empty-signatures'],
+            extraOpcodeBudget: data['extra-opcode-budget'],
             maxLogCalls: data['max-log-calls'],
             maxLogSize: data['max-log-size'],
         });
         /* 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.
+     */
+    constructor({ pc, scratchChanges, spawnedInners, stackAdditions, stackPopCount, }) {
+        super();
+        this.pc = pc;
+        this.scratchChanges = scratchChanges;
+        this.spawnedInners = spawnedInners;
+        this.stackAdditions = stackAdditions;
+        this.stackPopCount = stackPopCount;
+        this.attribute_map = {
+            pc: 'pc',
+            scratchChanges: 'scratch-changes',
+            spawnedInners: 'spawned-inners',
+            stackAdditions: 'stack-additions',
+            stackPopCount: 'stack-pop-count',
+        };
+    }
+    // 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'],
+        });
+        /* 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 approvalProgramTrace - Program trace that contains a trace of opcode effects in an approval program.
+     * @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 logicSigTrace - Program trace that contains a trace of opcode effects in a logic sig.
+     */
+    constructor({ approvalProgramTrace, clearStateProgramTrace, innerTrace, logicSigTrace, }) {
+        super();
+        this.approvalProgramTrace = approvalProgramTrace;
+        this.clearStateProgramTrace = clearStateProgramTrace;
+        this.innerTrace = innerTrace;
+        this.logicSigTrace = logicSigTrace;
+        this.attribute_map = {
+            approvalProgramTrace: 'approval-program-trace',
+            clearStateProgramTrace: 'clear-state-program-trace',
+            innerTrace: 'inner-trace',
+            logicSigTrace: 'logic-sig-trace',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulationTransactionExecTrace({
+            approvalProgramTrace: typeof data['approval-program-trace'] !== 'undefined'
+                ? data['approval-program-trace'].map(SimulationOpcodeTraceUnit.from_obj_for_encoding)
+                : undefined,
+            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,
+            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
  */
@@ -2211,6 +2471,33 @@ export class TealValue extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Response containing all ledger state deltas for transaction groups, with their
+ * associated Ids, in a single round.
+ */
+export class TransactionGroupLedgerStateDeltasForRoundResponse extends BaseModel {
+    /**
+     * Creates a new `TransactionGroupLedgerStateDeltasForRoundResponse` object.
+     * @param deltas -
+     */
+    constructor({ deltas }) {
+        super();
+        this.deltas = deltas;
+        this.attribute_map = {
+            deltas: 'Deltas',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (!Array.isArray(data['Deltas']))
+            throw new Error(`Response is missing required array field 'Deltas': ${data}`);
+        return new TransactionGroupLedgerStateDeltasForRoundResponse({
+            deltas: data['Deltas'].map(LedgerStateDeltaForTransactionGroup.from_obj_for_encoding),
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * TransactionParams contains the parameters that help a client construct a new
  * transaction.