algosdk 2.2.0 → 2.4.0

package/src/client/v2/algod/models/types.ts

@@ -877,17 +877,17 @@ export class ApplicationParams extends BaseModel {
   public extraProgramPages?: number | bigint;
 
   /**
-   * [\gs) global schema
+   * (gs) global state
    */
   public globalState?: TealKeyValue[];
 
   /**
-   * [\gsch) global schema
+   * (gsch) global schema
    */
   public globalStateSchema?: ApplicationStateSchema;
 
   /**
-   * [\lsch) local schema
+   * (lsch) local schema
    */
   public localStateSchema?: ApplicationStateSchema;
 
@@ -898,9 +898,9 @@ export class ApplicationParams extends BaseModel {
    * @param creator - The address that created this application. This is the address where the
    * parameters and global state for this application can be found.
    * @param extraProgramPages - (epp) the amount of extra program pages available to this app.
-   * @param globalState - [\gs) global schema
-   * @param globalStateSchema - [\gsch) global schema
-   * @param localStateSchema - [\lsch) local schema
+   * @param globalState - (gs) global state
+   * @param globalStateSchema - (gsch) global schema
+   * @param localStateSchema - (lsch) local schema
    */
   constructor({
     approvalProgram,
@@ -2432,6 +2432,178 @@ export class EvalDeltaKeyValue extends BaseModel {
   }
 }
 
+/**
+ * Response containing the timestamp offset in seconds
+ */
+export class GetBlockTimeStampOffsetResponse extends BaseModel {
+  /**
+   * Timestamp offset in seconds.
+   */
+  public offset: number | bigint;
+
+  /**
+   * Creates a new `GetBlockTimeStampOffsetResponse` object.
+   * @param offset - Timestamp offset in seconds.
+   */
+  constructor({ offset }: { offset: number | bigint }) {
+    super();
+    this.offset = offset;
+
+    this.attribute_map = {
+      offset: 'offset',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): GetBlockTimeStampOffsetResponse {
+    /* eslint-disable dot-notation */
+    if (typeof data['offset'] === 'undefined')
+      throw new Error(`Response is missing required field 'offset': ${data}`);
+    return new GetBlockTimeStampOffsetResponse({
+      offset: data['offset'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * Response containing the ledger's minimum sync round
+ */
+export class GetSyncRoundResponse extends BaseModel {
+  /**
+   * The minimum sync round for the ledger.
+   */
+  public round: number | bigint;
+
+  /**
+   * Creates a new `GetSyncRoundResponse` object.
+   * @param round - The minimum sync round for the ledger.
+   */
+  constructor({ round }: { round: number | bigint }) {
+    super();
+    this.round = round;
+
+    this.attribute_map = {
+      round: 'round',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): GetSyncRoundResponse {
+    /* eslint-disable dot-notation */
+    if (typeof data['round'] === 'undefined')
+      throw new Error(`Response is missing required field 'round': ${data}`);
+    return new GetSyncRoundResponse({
+      round: data['round'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * A single Delta containing the key, the previous value and the current value for
+ * a single round.
+ */
+export class KvDelta extends BaseModel {
+  /**
+   * The key, base64 encoded.
+   */
+  public key?: Uint8Array;
+
+  /**
+   * The new value of the KV store entry, base64 encoded.
+   */
+  public value?: Uint8Array;
+
+  /**
+   * Creates a new `KvDelta` object.
+   * @param key - The key, base64 encoded.
+   * @param value - The new value of the KV store entry, base64 encoded.
+   */
+  constructor({
+    key,
+    value,
+  }: {
+    key?: string | Uint8Array;
+    value?: string | Uint8Array;
+  }) {
+    super();
+    this.key =
+      typeof key === 'string'
+        ? new Uint8Array(Buffer.from(key, 'base64'))
+        : key;
+    this.value =
+      typeof value === 'string'
+        ? new Uint8Array(Buffer.from(value, 'base64'))
+        : value;
+
+    this.attribute_map = {
+      key: 'key',
+      value: 'value',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): KvDelta {
+    /* eslint-disable dot-notation */
+    return new KvDelta({
+      key: data['key'],
+      value: data['value'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * Contains a ledger delta for a single transaction group
+ */
+export class LedgerStateDeltaForTransactionGroup extends BaseModel {
+  /**
+   * Ledger StateDelta object
+   */
+  public delta: Record<string, any>;
+
+  public ids: string[];
+
+  /**
+   * Creates a new `LedgerStateDeltaForTransactionGroup` object.
+   * @param delta - Ledger StateDelta object
+   * @param ids -
+   */
+  constructor({ delta, ids }: { delta: Record<string, any>; ids: string[] }) {
+    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: Record<string, any>
+  ): LedgerStateDeltaForTransactionGroup {
+    /* 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.
  */
@@ -2607,6 +2779,46 @@ export class NodeStatusResponse extends BaseModel {
    */
   public lastCatchpoint?: string;
 
+  /**
+   * Upgrade delay
+   */
+  public upgradeDelay?: number | bigint;
+
+  /**
+   * Next protocol round
+   */
+  public upgradeNextProtocolVoteBefore?: number | bigint;
+
+  /**
+   * No votes cast for consensus upgrade
+   */
+  public upgradeNoVotes?: number | bigint;
+
+  /**
+   * This node's upgrade vote
+   */
+  public upgradeNodeVote?: boolean;
+
+  /**
+   * Total voting rounds for current upgrade
+   */
+  public upgradeVoteRounds?: number | bigint;
+
+  /**
+   * Total votes cast for consensus upgrade
+   */
+  public upgradeVotes?: number | bigint;
+
+  /**
+   * Yes votes required for consensus upgrade
+   */
+  public upgradeVotesRequired?: number | bigint;
+
+  /**
+   * Yes votes cast for consensus upgrade
+   */
+  public upgradeYesVotes?: number | bigint;
+
   /**
    * Creates a new `NodeStatusResponse` object.
    * @param catchupTime - CatchupTime in nanoseconds
@@ -2635,6 +2847,14 @@ export class NodeStatusResponse extends BaseModel {
    * @param catchpointVerifiedKvs - The number of key-values (KVs) from the current catchpoint that have been
    * verified so far as part of the catchup
    * @param lastCatchpoint - The last catchpoint seen by the node
+   * @param upgradeDelay - Upgrade delay
+   * @param upgradeNextProtocolVoteBefore - Next protocol round
+   * @param upgradeNoVotes - No votes cast for consensus upgrade
+   * @param upgradeNodeVote - This node's upgrade vote
+   * @param upgradeVoteRounds - Total voting rounds for current upgrade
+   * @param upgradeVotes - Total votes cast for consensus upgrade
+   * @param upgradeVotesRequired - Yes votes required for consensus upgrade
+   * @param upgradeYesVotes - Yes votes cast for consensus upgrade
    */
   constructor({
     catchupTime,
@@ -2655,6 +2875,14 @@ export class NodeStatusResponse extends BaseModel {
     catchpointVerifiedAccounts,
     catchpointVerifiedKvs,
     lastCatchpoint,
+    upgradeDelay,
+    upgradeNextProtocolVoteBefore,
+    upgradeNoVotes,
+    upgradeNodeVote,
+    upgradeVoteRounds,
+    upgradeVotes,
+    upgradeVotesRequired,
+    upgradeYesVotes,
   }: {
     catchupTime: number | bigint;
     lastRound: number | bigint;
@@ -2674,6 +2902,14 @@ export class NodeStatusResponse extends BaseModel {
     catchpointVerifiedAccounts?: number | bigint;
     catchpointVerifiedKvs?: number | bigint;
     lastCatchpoint?: string;
+    upgradeDelay?: number | bigint;
+    upgradeNextProtocolVoteBefore?: number | bigint;
+    upgradeNoVotes?: number | bigint;
+    upgradeNodeVote?: boolean;
+    upgradeVoteRounds?: number | bigint;
+    upgradeVotes?: number | bigint;
+    upgradeVotesRequired?: number | bigint;
+    upgradeYesVotes?: number | bigint;
   }) {
     super();
     this.catchupTime = catchupTime;
@@ -2694,6 +2930,14 @@ export class NodeStatusResponse extends BaseModel {
     this.catchpointVerifiedAccounts = catchpointVerifiedAccounts;
     this.catchpointVerifiedKvs = catchpointVerifiedKvs;
     this.lastCatchpoint = lastCatchpoint;
+    this.upgradeDelay = upgradeDelay;
+    this.upgradeNextProtocolVoteBefore = upgradeNextProtocolVoteBefore;
+    this.upgradeNoVotes = upgradeNoVotes;
+    this.upgradeNodeVote = upgradeNodeVote;
+    this.upgradeVoteRounds = upgradeVoteRounds;
+    this.upgradeVotes = upgradeVotes;
+    this.upgradeVotesRequired = upgradeVotesRequired;
+    this.upgradeYesVotes = upgradeYesVotes;
 
     this.attribute_map = {
       catchupTime: 'catchup-time',
@@ -2714,6 +2958,14 @@ export class NodeStatusResponse extends BaseModel {
       catchpointVerifiedAccounts: 'catchpoint-verified-accounts',
       catchpointVerifiedKvs: 'catchpoint-verified-kvs',
       lastCatchpoint: 'last-catchpoint',
+      upgradeDelay: 'upgrade-delay',
+      upgradeNextProtocolVoteBefore: 'upgrade-next-protocol-vote-before',
+      upgradeNoVotes: 'upgrade-no-votes',
+      upgradeNodeVote: 'upgrade-node-vote',
+      upgradeVoteRounds: 'upgrade-vote-rounds',
+      upgradeVotes: 'upgrade-votes',
+      upgradeVotesRequired: 'upgrade-votes-required',
+      upgradeYesVotes: 'upgrade-yes-votes',
     };
   }
 
@@ -2771,6 +3023,14 @@ export class NodeStatusResponse extends BaseModel {
       catchpointVerifiedAccounts: data['catchpoint-verified-accounts'],
       catchpointVerifiedKvs: data['catchpoint-verified-kvs'],
       lastCatchpoint: data['last-catchpoint'],
+      upgradeDelay: data['upgrade-delay'],
+      upgradeNextProtocolVoteBefore: data['upgrade-next-protocol-vote-before'],
+      upgradeNoVotes: data['upgrade-no-votes'],
+      upgradeNodeVote: data['upgrade-node-vote'],
+      upgradeVoteRounds: data['upgrade-vote-rounds'],
+      upgradeVotes: data['upgrade-votes'],
+      upgradeVotesRequired: data['upgrade-votes-required'],
+      upgradeYesVotes: data['upgrade-yes-votes'],
     });
     /* eslint-enable dot-notation */
   }
@@ -2825,7 +3085,7 @@ export class PendingTransactionResponse extends BaseModel {
   public confirmedRound?: number | bigint;
 
   /**
-   * (gd) Global state key/value changes for the application being executed by this
+   * Global state key/value changes for the application being executed by this
    * transaction.
    */
   public globalStateDelta?: EvalDeltaKeyValue[];
@@ -2836,13 +3096,13 @@ export class PendingTransactionResponse extends BaseModel {
   public innerTxns?: PendingTransactionResponse[];
 
   /**
-   * (ld) Local state key/value changes for the application being executed by this
+   * Local state key/value changes for the application being executed by this
    * transaction.
    */
   public localStateDelta?: AccountStateDelta[];
 
   /**
-   * (lg) Logs for the application being executed by this transaction.
+   * Logs for the application being executed by this transaction.
    */
   public logs?: Uint8Array[];
 
@@ -2869,12 +3129,12 @@ export class PendingTransactionResponse extends BaseModel {
    * @param closeRewards - Rewards in microalgos applied to the close remainder to account.
    * @param closingAmount - Closing amount for the transaction.
    * @param confirmedRound - The round where this transaction was confirmed, if present.
-   * @param globalStateDelta - (gd) Global state key/value changes for the application being executed by this
+   * @param globalStateDelta - Global state key/value changes for the application being executed by this
    * transaction.
    * @param innerTxns - Inner transactions produced by application execution.
-   * @param localStateDelta - (ld) Local state key/value changes for the application being executed by this
+   * @param localStateDelta - Local state key/value changes for the application being executed by this
    * transaction.
-   * @param logs - (lg) Logs for the application being executed by this transaction.
+   * @param logs - Logs for the application being executed by this transaction.
    * @param receiverRewards - Rewards in microalgos applied to the receiver account.
    * @param senderRewards - Rewards in microalgos applied to the sender account.
    */
@@ -3084,6 +3344,121 @@ export class PostTransactionsResponse extends BaseModel {
   }
 }
 
+/**
+ * Request type for simulation endpoint.
+ */
+export class SimulateRequest extends BaseModel {
+  /**
+   * The transaction groups to simulate.
+   */
+  public txnGroups: SimulateRequestTransactionGroup[];
+
+  /**
+   * Allow transactions without signatures to be simulated as if they had correct
+   * signatures.
+   */
+  public allowEmptySignatures?: boolean;
+
+  /**
+   * Lifts limits on log opcode usage during simulation.
+   */
+  public allowMoreLogging?: boolean;
+
+  /**
+   * Applies extra opcode budget during simulation for each transaction group.
+   */
+  public extraOpcodeBudget?: 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
+   * signatures.
+   * @param allowMoreLogging - Lifts limits on log opcode usage during simulation.
+   * @param extraOpcodeBudget - Applies extra opcode budget during simulation for each transaction group.
+   */
+  constructor({
+    txnGroups,
+    allowEmptySignatures,
+    allowMoreLogging,
+    extraOpcodeBudget,
+  }: {
+    txnGroups: SimulateRequestTransactionGroup[];
+    allowEmptySignatures?: boolean;
+    allowMoreLogging?: boolean;
+    extraOpcodeBudget?: number | bigint;
+  }) {
+    super();
+    this.txnGroups = txnGroups;
+    this.allowEmptySignatures = allowEmptySignatures;
+    this.allowMoreLogging = allowMoreLogging;
+    this.extraOpcodeBudget = extraOpcodeBudget;
+
+    this.attribute_map = {
+      txnGroups: 'txn-groups',
+      allowEmptySignatures: 'allow-empty-signatures',
+      allowMoreLogging: 'allow-more-logging',
+      extraOpcodeBudget: 'extra-opcode-budget',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): SimulateRequest {
+    /* eslint-disable dot-notation */
+    if (!Array.isArray(data['txn-groups']))
+      throw new Error(
+        `Response is missing required array field 'txn-groups': ${data}`
+      );
+    return new SimulateRequest({
+      txnGroups: data['txn-groups'].map(
+        SimulateRequestTransactionGroup.from_obj_for_encoding
+      ),
+      allowEmptySignatures: data['allow-empty-signatures'],
+      allowMoreLogging: data['allow-more-logging'],
+      extraOpcodeBudget: data['extra-opcode-budget'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * A transaction group to simulate.
+ */
+export class SimulateRequestTransactionGroup extends BaseModel {
+  /**
+   * An atomic transaction group.
+   */
+  public txns: EncodedSignedTransaction[];
+
+  /**
+   * Creates a new `SimulateRequestTransactionGroup` object.
+   * @param txns - An atomic transaction group.
+   */
+  constructor({ txns }: { txns: EncodedSignedTransaction[] }) {
+    super();
+    this.txns = txns;
+
+    this.attribute_map = {
+      txns: 'txns',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): SimulateRequestTransactionGroup {
+    /* eslint-disable dot-notation */
+    if (!Array.isArray(data['txns']))
+      throw new Error(
+        `Response is missing required array field 'txns': ${data}`
+      );
+    return new SimulateRequestTransactionGroup({
+      txns: data['txns'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Result of a transaction group simulation.
  */
@@ -3105,11 +3480,11 @@ export class SimulateResponse extends BaseModel {
   public version: number | bigint;
 
   /**
-   * Indicates whether the simulated transactions would have succeeded during an
-   * actual submission. If any transaction fails or is missing a signature, this will
-   * be false.
+   * 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.
    */
-  public wouldSucceed: boolean;
+  public evalOverrides?: SimulationEvalOverrides;
 
   /**
    * Creates a new `SimulateResponse` object.
@@ -3117,32 +3492,32 @@ export class SimulateResponse extends BaseModel {
    * round were used to run this simulation.
    * @param txnGroups - A result object for each transaction group that was simulated.
    * @param version - The version of this response object.
-   * @param wouldSucceed - Indicates whether the simulated transactions would have succeeded during an
-   * actual submission. If any transaction fails or is missing a signature, this will
-   * be false.
+   * @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.
    */
   constructor({
     lastRound,
     txnGroups,
     version,
-    wouldSucceed,
+    evalOverrides,
   }: {
     lastRound: number | bigint;
     txnGroups: SimulateTransactionGroupResult[];
     version: number | bigint;
-    wouldSucceed: boolean;
+    evalOverrides?: SimulationEvalOverrides;
   }) {
     super();
     this.lastRound = lastRound;
     this.txnGroups = txnGroups;
     this.version = version;
-    this.wouldSucceed = wouldSucceed;
+    this.evalOverrides = evalOverrides;
 
     this.attribute_map = {
       lastRound: 'last-round',
       txnGroups: 'txn-groups',
       version: 'version',
-      wouldSucceed: 'would-succeed',
+      evalOverrides: 'eval-overrides',
     };
   }
 
@@ -3159,17 +3534,18 @@ export class SimulateResponse extends BaseModel {
       );
     if (typeof data['version'] === 'undefined')
       throw new Error(`Response is missing required field 'version': ${data}`);
-    if (typeof data['would-succeed'] === 'undefined')
-      throw new Error(
-        `Response is missing required field 'would-succeed': ${data}`
-      );
     return new SimulateResponse({
       lastRound: data['last-round'],
       txnGroups: data['txn-groups'].map(
         SimulateTransactionGroupResult.from_obj_for_encoding
       ),
       version: data['version'],
-      wouldSucceed: data['would-succeed'],
+      evalOverrides:
+        typeof data['eval-overrides'] !== 'undefined'
+          ? SimulationEvalOverrides.from_obj_for_encoding(
+              data['eval-overrides']
+            )
+          : undefined,
     });
     /* eslint-enable dot-notation */
   }
@@ -3184,6 +3560,16 @@ export class SimulateTransactionGroupResult extends BaseModel {
    */
   public txnResults: SimulateTransactionResult[];
 
+  /**
+   * Total budget added during execution of app calls in the transaction group.
+   */
+  public appBudgetAdded?: number | bigint;
+
+  /**
+   * Total budget consumed during execution of app calls in the transaction group.
+   */
+  public appBudgetConsumed?: number | bigint;
+
   /**
    * If present, indicates which transaction in this group caused the failure. This
    * array represents the path to the failing transaction. Indexes are zero based,
@@ -3201,6 +3587,8 @@ export class SimulateTransactionGroupResult extends BaseModel {
   /**
    * Creates a new `SimulateTransactionGroupResult` object.
    * @param txnResults - Simulation result for individual transactions
+   * @param appBudgetAdded - Total budget added during execution of app calls in the transaction group.
+   * @param appBudgetConsumed - Total budget consumed during execution of app calls in the transaction group.
    * @param failedAt - If present, indicates which transaction in this group caused the failure. This
    * array represents the path to the failing transaction. Indexes are zero based,
    * the first element indicates the top-level transaction, and successive elements
@@ -3210,20 +3598,28 @@ export class SimulateTransactionGroupResult extends BaseModel {
    */
   constructor({
     txnResults,
+    appBudgetAdded,
+    appBudgetConsumed,
     failedAt,
     failureMessage,
   }: {
     txnResults: SimulateTransactionResult[];
+    appBudgetAdded?: number | bigint;
+    appBudgetConsumed?: number | bigint;
     failedAt?: (number | bigint)[];
     failureMessage?: string;
   }) {
     super();
     this.txnResults = txnResults;
+    this.appBudgetAdded = appBudgetAdded;
+    this.appBudgetConsumed = appBudgetConsumed;
     this.failedAt = failedAt;
     this.failureMessage = failureMessage;
 
     this.attribute_map = {
       txnResults: 'txn-results',
+      appBudgetAdded: 'app-budget-added',
+      appBudgetConsumed: 'app-budget-consumed',
       failedAt: 'failed-at',
       failureMessage: 'failure-message',
     };
@@ -3242,6 +3638,8 @@ export class SimulateTransactionGroupResult extends BaseModel {
       txnResults: data['txn-results'].map(
         SimulateTransactionResult.from_obj_for_encoding
       ),
+      appBudgetAdded: data['app-budget-added'],
+      appBudgetConsumed: data['app-budget-consumed'],
       failedAt: data['failed-at'],
       failureMessage: data['failure-message'],
     });
@@ -3260,30 +3658,42 @@ export class SimulateTransactionResult extends BaseModel {
   public txnResult: PendingTransactionResponse;
 
   /**
-   * A boolean indicating whether this transaction is missing signatures
+   * Budget used during execution of an app call transaction. This value includes
+   * budged used by inner app calls spawned by this transaction.
    */
-  public missingSignature?: boolean;
+  public appBudgetConsumed?: number | bigint;
+
+  /**
+   * Budget used during execution of a logic sig transaction.
+   */
+  public logicSigBudgetConsumed?: number | bigint;
 
   /**
    * 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 missingSignature - A boolean indicating whether this transaction is missing signatures
+   * @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 logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
    */
   constructor({
     txnResult,
-    missingSignature,
+    appBudgetConsumed,
+    logicSigBudgetConsumed,
   }: {
     txnResult: PendingTransactionResponse;
-    missingSignature?: boolean;
+    appBudgetConsumed?: number | bigint;
+    logicSigBudgetConsumed?: number | bigint;
   }) {
     super();
     this.txnResult = txnResult;
-    this.missingSignature = missingSignature;
+    this.appBudgetConsumed = appBudgetConsumed;
+    this.logicSigBudgetConsumed = logicSigBudgetConsumed;
 
     this.attribute_map = {
       txnResult: 'txn-result',
-      missingSignature: 'missing-signature',
+      appBudgetConsumed: 'app-budget-consumed',
+      logicSigBudgetConsumed: 'logic-sig-budget-consumed',
     };
   }
 
@@ -3300,7 +3710,83 @@ export class SimulateTransactionResult extends BaseModel {
       txnResult: PendingTransactionResponse.from_obj_for_encoding(
         data['txn-result']
       ),
-      missingSignature: data['missing-signature'],
+      appBudgetConsumed: data['app-budget-consumed'],
+      logicSigBudgetConsumed: data['logic-sig-budget-consumed'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * 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.
+ */
+export class SimulationEvalOverrides extends BaseModel {
+  /**
+   * If true, transactions without signatures are allowed and simulated as if they
+   * were properly signed.
+   */
+  public allowEmptySignatures?: boolean;
+
+  /**
+   * The extra opcode budget added to each transaction group during simulation
+   */
+  public extraOpcodeBudget?: number | bigint;
+
+  /**
+   * The maximum log calls one can make during simulation
+   */
+  public maxLogCalls?: number | bigint;
+
+  /**
+   * The maximum byte number to log during simulation
+   */
+  public maxLogSize?: number | bigint;
+
+  /**
+   * 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,
+    extraOpcodeBudget,
+    maxLogCalls,
+    maxLogSize,
+  }: {
+    allowEmptySignatures?: boolean;
+    extraOpcodeBudget?: number | bigint;
+    maxLogCalls?: number | bigint;
+    maxLogSize?: number | bigint;
+  }) {
+    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',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): SimulationEvalOverrides {
+    /* 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 */
   }
@@ -3648,6 +4134,44 @@ export class TealValue extends BaseModel {
   }
 }
 
+/**
+ * Response containing all ledger state deltas for transaction groups, with their
+ * associated Ids, in a single round.
+ */
+export class TransactionGroupLedgerStateDeltasForRoundResponse extends BaseModel {
+  public deltas: LedgerStateDeltaForTransactionGroup[];
+
+  /**
+   * Creates a new `TransactionGroupLedgerStateDeltasForRoundResponse` object.
+   * @param deltas -
+   */
+  constructor({ deltas }: { deltas: LedgerStateDeltaForTransactionGroup[] }) {
+    super();
+    this.deltas = deltas;
+
+    this.attribute_map = {
+      deltas: 'deltas',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): TransactionGroupLedgerStateDeltasForRoundResponse {
+    /* 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.