algosdk 2.1.0 → 2.3.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,132 @@ 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 */
+  }
+}
+
 /**
  * Proof of membership and position of a light block header.
  */
@@ -2607,6 +2733,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 +2801,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 +2829,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 +2856,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 +2884,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 +2912,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 +2977,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 +3039,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 +3050,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 +3083,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 +3298,432 @@ 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;
+
+  /**
+   * 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.
+   */
+  constructor({
+    txnGroups,
+    allowEmptySignatures,
+    allowMoreLogging,
+  }: {
+    txnGroups: SimulateRequestTransactionGroup[];
+    allowEmptySignatures?: boolean;
+    allowMoreLogging?: boolean;
+  }) {
+    super();
+    this.txnGroups = txnGroups;
+    this.allowEmptySignatures = allowEmptySignatures;
+    this.allowMoreLogging = allowMoreLogging;
+
+    this.attribute_map = {
+      txnGroups: 'txn-groups',
+      allowEmptySignatures: 'allow-empty-signatures',
+      allowMoreLogging: 'allow-more-logging',
+    };
+  }
+
+  // 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'],
+    });
+    /* 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.
+ */
+export class SimulateResponse extends BaseModel {
+  /**
+   * The round immediately preceding this simulation. State changes through this
+   * round were used to run this simulation.
+   */
+  public lastRound: number | bigint;
+
+  /**
+   * A result object for each transaction group that was simulated.
+   */
+  public txnGroups: SimulateTransactionGroupResult[];
+
+  /**
+   * The version of this response object.
+   */
+  public version: number | bigint;
+
+  /**
+   * 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 evalOverrides?: SimulationEvalOverrides;
+
+  /**
+   * Creates a new `SimulateResponse` object.
+   * @param lastRound - The round immediately preceding this simulation. State changes through this
+   * 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 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,
+    evalOverrides,
+  }: {
+    lastRound: number | bigint;
+    txnGroups: SimulateTransactionGroupResult[];
+    version: number | bigint;
+    evalOverrides?: SimulationEvalOverrides;
+  }) {
+    super();
+    this.lastRound = lastRound;
+    this.txnGroups = txnGroups;
+    this.version = version;
+    this.evalOverrides = evalOverrides;
+
+    this.attribute_map = {
+      lastRound: 'last-round',
+      txnGroups: 'txn-groups',
+      version: 'version',
+      evalOverrides: 'eval-overrides',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): SimulateResponse {
+    /* eslint-disable dot-notation */
+    if (typeof data['last-round'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'last-round': ${data}`
+      );
+    if (!Array.isArray(data['txn-groups']))
+      throw new Error(
+        `Response is missing required array field 'txn-groups': ${data}`
+      );
+    if (typeof data['version'] === 'undefined')
+      throw new Error(`Response is missing required field 'version': ${data}`);
+    return new SimulateResponse({
+      lastRound: data['last-round'],
+      txnGroups: data['txn-groups'].map(
+        SimulateTransactionGroupResult.from_obj_for_encoding
+      ),
+      version: data['version'],
+      evalOverrides:
+        typeof data['eval-overrides'] !== 'undefined'
+          ? SimulationEvalOverrides.from_obj_for_encoding(
+              data['eval-overrides']
+            )
+          : undefined,
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * Simulation result for an atomic transaction group
+ */
+export class SimulateTransactionGroupResult extends BaseModel {
+  /**
+   * Simulation result for individual transactions
+   */
+  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,
+   * the first element indicates the top-level transaction, and successive elements
+   * indicate deeper inner transactions.
+   */
+  public failedAt?: (number | bigint)[];
+
+  /**
+   * If present, indicates that the transaction group failed and specifies why that
+   * happened
+   */
+  public failureMessage?: string;
+
+  /**
+   * 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
+   * 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,
+  }: {
+    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',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): SimulateTransactionGroupResult {
+    /* eslint-disable dot-notation */
+    if (!Array.isArray(data['txn-results']))
+      throw new Error(
+        `Response is missing required array field 'txn-results': ${data}`
+      );
+    return new SimulateTransactionGroupResult({
+      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'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
+/**
+ * Simulation result for an individual transaction
+ */
+export class SimulateTransactionResult extends BaseModel {
+  /**
+   * Details about a pending transaction. If the transaction was recently confirmed,
+   * includes confirmation details like the round and reward details.
+   */
+  public txnResult: PendingTransactionResponse;
+
+  /**
+   * Budget used during execution of an app call transaction. This value includes
+   * budged used by inner app calls spawned by this transaction.
+   */
+  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 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,
+    appBudgetConsumed,
+    logicSigBudgetConsumed,
+  }: {
+    txnResult: PendingTransactionResponse;
+    appBudgetConsumed?: number | bigint;
+    logicSigBudgetConsumed?: number | bigint;
+  }) {
+    super();
+    this.txnResult = txnResult;
+    this.appBudgetConsumed = appBudgetConsumed;
+    this.logicSigBudgetConsumed = logicSigBudgetConsumed;
+
+    this.attribute_map = {
+      txnResult: 'txn-result',
+      appBudgetConsumed: 'app-budget-consumed',
+      logicSigBudgetConsumed: 'logic-sig-budget-consumed',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): SimulateTransactionResult {
+    /* eslint-disable dot-notation */
+    if (typeof data['txn-result'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'txn-result': ${data}`
+      );
+    return new SimulateTransactionResult({
+      txnResult: PendingTransactionResponse.from_obj_for_encoding(
+        data['txn-result']
+      ),
+      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 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 maxLogCalls - The maximum log calls one can make during simulation
+   * @param maxLogSize - The maximum byte number to log during simulation
+   */
+  constructor({
+    allowEmptySignatures,
+    maxLogCalls,
+    maxLogSize,
+  }: {
+    allowEmptySignatures?: boolean;
+    maxLogCalls?: number | bigint;
+    maxLogSize?: number | bigint;
+  }) {
+    super();
+    this.allowEmptySignatures = allowEmptySignatures;
+    this.maxLogCalls = maxLogCalls;
+    this.maxLogSize = maxLogSize;
+
+    this.attribute_map = {
+      allowEmptySignatures: 'allow-empty-signatures',
+      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'],
+      maxLogCalls: data['max-log-calls'],
+      maxLogSize: data['max-log-size'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Represents a state proof and its corresponding message
  */