algosdk 2.7.0 → 2.9.0

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

@@ -127,6 +127,23 @@ export class Account extends BaseModel {
    */
   public createdAssets?: Asset[];
 
+  /**
+   * Whether or not the account can receive block incentives if its balance is in
+   * range at proposal time.
+   */
+  public incentiveEligible?: boolean;
+
+  /**
+   * The round in which this account last went online, or explicitly renewed their
+   * online status.
+   */
+  public lastHeartbeat?: number | bigint;
+
+  /**
+   * The round in which this account last proposed the block.
+   */
+  public lastProposed?: number | bigint;
+
   /**
    * AccountParticipation describes the parameters used by this account in consensus
    * protocol.
@@ -197,6 +214,11 @@ export class Account extends BaseModel {
    * Note: the raw account uses `map[int] -> AppParams` for this type.
    * @param createdAssets - (apar) parameters of assets created by this account.
    * Note: the raw account uses `map[int] -> Asset` for this type.
+   * @param incentiveEligible - Whether or not the account can receive block incentives if its balance is in
+   * range at proposal time.
+   * @param lastHeartbeat - The round in which this account last went online, or explicitly renewed their
+   * online status.
+   * @param lastProposed - The round in which this account last proposed the block.
    * @param participation - AccountParticipation describes the parameters used by this account in consensus
    * protocol.
    * @param rewardBase - (ebase) used as part of the rewards computation. Only applicable to accounts
@@ -229,6 +251,9 @@ export class Account extends BaseModel {
     authAddr,
     createdApps,
     createdAssets,
+    incentiveEligible,
+    lastHeartbeat,
+    lastProposed,
     participation,
     rewardBase,
     sigType,
@@ -254,6 +279,9 @@ export class Account extends BaseModel {
     authAddr?: string;
     createdApps?: Application[];
     createdAssets?: Asset[];
+    incentiveEligible?: boolean;
+    lastHeartbeat?: number | bigint;
+    lastProposed?: number | bigint;
     participation?: AccountParticipation;
     rewardBase?: number | bigint;
     sigType?: string;
@@ -280,6 +308,9 @@ export class Account extends BaseModel {
     this.authAddr = authAddr;
     this.createdApps = createdApps;
     this.createdAssets = createdAssets;
+    this.incentiveEligible = incentiveEligible;
+    this.lastHeartbeat = lastHeartbeat;
+    this.lastProposed = lastProposed;
     this.participation = participation;
     this.rewardBase = rewardBase;
     this.sigType = sigType;
@@ -306,6 +337,9 @@ export class Account extends BaseModel {
       authAddr: 'auth-addr',
       createdApps: 'created-apps',
       createdAssets: 'created-assets',
+      incentiveEligible: 'incentive-eligible',
+      lastHeartbeat: 'last-heartbeat',
+      lastProposed: 'last-proposed',
       participation: 'participation',
       rewardBase: 'reward-base',
       sigType: 'sig-type',
@@ -394,6 +428,9 @@ export class Account extends BaseModel {
         typeof data['created-assets'] !== 'undefined'
           ? data['created-assets'].map(Asset.from_obj_for_encoding)
           : undefined,
+      incentiveEligible: data['incentive-eligible'],
+      lastHeartbeat: data['last-heartbeat'],
+      lastProposed: data['last-proposed'],
       participation:
         typeof data['participation'] !== 'undefined'
           ? AccountParticipation.from_obj_for_encoding(data['participation'])
@@ -484,6 +521,65 @@ export class AccountApplicationResponse extends BaseModel {
   }
 }
 
+/**
+ * AccountAssetHolding describes the account's asset holding and asset parameters
+ * (if either exist) for a specific asset ID.
+ */
+export class AccountAssetHolding extends BaseModel {
+  /**
+   * (asset) Details about the asset held by this account.
+   * The raw account uses `AssetHolding` for this type.
+   */
+  public assetHolding: AssetHolding;
+
+  /**
+   * (apar) parameters of the asset held by this account.
+   * The raw account uses `AssetParams` for this type.
+   */
+  public assetParams?: AssetParams;
+
+  /**
+   * Creates a new `AccountAssetHolding` object.
+   * @param assetHolding - (asset) Details about the asset held by this account.
+   * The raw account uses `AssetHolding` for this type.
+   * @param assetParams - (apar) parameters of the asset held by this account.
+   * The raw account uses `AssetParams` for this type.
+   */
+  constructor({
+    assetHolding,
+    assetParams,
+  }: {
+    assetHolding: AssetHolding;
+    assetParams?: AssetParams;
+  }) {
+    super();
+    this.assetHolding = assetHolding;
+    this.assetParams = assetParams;
+
+    this.attribute_map = {
+      assetHolding: 'asset-holding',
+      assetParams: 'asset-params',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): AccountAssetHolding {
+    /* eslint-disable dot-notation */
+    if (typeof data['asset-holding'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'asset-holding': ${data}`
+      );
+    return new AccountAssetHolding({
+      assetHolding: AssetHolding.from_obj_for_encoding(data['asset-holding']),
+      assetParams:
+        typeof data['asset-params'] !== 'undefined'
+          ? AssetParams.from_obj_for_encoding(data['asset-params'])
+          : undefined,
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * AccountAssetResponse describes the account's asset holding and asset parameters
  * (if either exist) for a specific asset ID. Asset parameters will only be
@@ -558,6 +654,72 @@ export class AccountAssetResponse extends BaseModel {
   }
 }
 
+/**
+ * AccountAssetsInformationResponse contains a list of assets held by an account.
+ */
+export class AccountAssetsInformationResponse extends BaseModel {
+  /**
+   * The round for which this information is relevant.
+   */
+  public round: number | bigint;
+
+  public assetHoldings?: AccountAssetHolding[];
+
+  /**
+   * Used for pagination, when making another request provide this token with the
+   * next parameter.
+   */
+  public nextToken?: string;
+
+  /**
+   * Creates a new `AccountAssetsInformationResponse` object.
+   * @param round - The round for which this information is relevant.
+   * @param assetHoldings -
+   * @param nextToken - Used for pagination, when making another request provide this token with the
+   * next parameter.
+   */
+  constructor({
+    round,
+    assetHoldings,
+    nextToken,
+  }: {
+    round: number | bigint;
+    assetHoldings?: AccountAssetHolding[];
+    nextToken?: string;
+  }) {
+    super();
+    this.round = round;
+    this.assetHoldings = assetHoldings;
+    this.nextToken = nextToken;
+
+    this.attribute_map = {
+      round: 'round',
+      assetHoldings: 'asset-holdings',
+      nextToken: 'next-token',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): AccountAssetsInformationResponse {
+    /* eslint-disable dot-notation */
+    if (typeof data['round'] === 'undefined')
+      throw new Error(`Response is missing required field 'round': ${data}`);
+    return new AccountAssetsInformationResponse({
+      round: data['round'],
+      assetHoldings:
+        typeof data['asset-holdings'] !== 'undefined'
+          ? data['asset-holdings'].map(
+              AccountAssetHolding.from_obj_for_encoding
+            )
+          : undefined,
+      nextToken: data['next-token'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * AccountParticipation describes the parameters used by this account in consensus
  * protocol.
@@ -733,6 +895,75 @@ export class AccountStateDelta extends BaseModel {
   }
 }
 
+/**
+ * The logged messages from an app call along with the app ID and outer transaction
+ * ID. Logs appear in the same order that they were emitted.
+ */
+export class AppCallLogs extends BaseModel {
+  /**
+   * The application from which the logs were generated
+   */
+  public applicationIndex: number | bigint;
+
+  /**
+   * An array of logs
+   */
+  public logs: Uint8Array[];
+
+  /**
+   * The transaction ID of the outer app call that lead to these logs
+   */
+  public txid: string;
+
+  /**
+   * Creates a new `AppCallLogs` object.
+   * @param applicationIndex - The application from which the logs were generated
+   * @param logs - An array of logs
+   * @param txid - The transaction ID of the outer app call that lead to these logs
+   */
+  constructor({
+    applicationIndex,
+    logs,
+    txid,
+  }: {
+    applicationIndex: number | bigint;
+    logs: Uint8Array[];
+    txid: string;
+  }) {
+    super();
+    this.applicationIndex = applicationIndex;
+    this.logs = logs;
+    this.txid = txid;
+
+    this.attribute_map = {
+      applicationIndex: 'application-index',
+      logs: 'logs',
+      txid: 'txId',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): AppCallLogs {
+    /* eslint-disable dot-notation */
+    if (typeof data['application-index'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'application-index': ${data}`
+      );
+    if (!Array.isArray(data['logs']))
+      throw new Error(
+        `Response is missing required array field 'logs': ${data}`
+      );
+    if (typeof data['txId'] === 'undefined')
+      throw new Error(`Response is missing required field 'txId': ${data}`);
+    return new AppCallLogs({
+      applicationIndex: data['application-index'],
+      logs: data['logs'],
+      txid: data['txId'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Application index and its parameters
  */
@@ -1867,6 +2098,45 @@ export class BlockHashResponse extends BaseModel {
   }
 }
 
+/**
+ * All logs emitted in the given round. Each app call, whether top-level or inner,
+ * that contains logs results in a separate AppCallLogs object. Therefore there may
+ * be multiple AppCallLogs with the same application ID and outer transaction ID in
+ * the event of multiple inner app calls to the same app. App calls with no logs
+ * are not included in the response. AppCallLogs are returned in the same order
+ * that their corresponding app call appeared in the block (pre-order traversal of
+ * inner app calls)
+ */
+export class BlockLogsResponse extends BaseModel {
+  public logs: AppCallLogs[];
+
+  /**
+   * Creates a new `BlockLogsResponse` object.
+   * @param logs -
+   */
+  constructor({ logs }: { logs: AppCallLogs[] }) {
+    super();
+    this.logs = logs;
+
+    this.attribute_map = {
+      logs: 'logs',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): BlockLogsResponse {
+    /* eslint-disable dot-notation */
+    if (!Array.isArray(data['logs']))
+      throw new Error(
+        `Response is missing required array field 'logs': ${data}`
+      );
+    return new BlockLogsResponse({
+      logs: data['logs'].map(AppCallLogs.from_obj_for_encoding),
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Encoded block object.
  */
@@ -4014,6 +4284,12 @@ export class SimulateRequest extends BaseModel {
    */
   public extraOpcodeBudget?: number | bigint;
 
+  /**
+   * If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
+   */
+  public fixSigners?: boolean;
+
   /**
    * 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
@@ -4031,6 +4307,8 @@ export class SimulateRequest extends BaseModel {
    * @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 fixSigners - If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
    * @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).
@@ -4043,6 +4321,7 @@ export class SimulateRequest extends BaseModel {
     allowUnnamedResources,
     execTraceConfig,
     extraOpcodeBudget,
+    fixSigners,
     round,
   }: {
     txnGroups: SimulateRequestTransactionGroup[];
@@ -4051,6 +4330,7 @@ export class SimulateRequest extends BaseModel {
     allowUnnamedResources?: boolean;
     execTraceConfig?: SimulateTraceConfig;
     extraOpcodeBudget?: number | bigint;
+    fixSigners?: boolean;
     round?: number | bigint;
   }) {
     super();
@@ -4060,6 +4340,7 @@ export class SimulateRequest extends BaseModel {
     this.allowUnnamedResources = allowUnnamedResources;
     this.execTraceConfig = execTraceConfig;
     this.extraOpcodeBudget = extraOpcodeBudget;
+    this.fixSigners = fixSigners;
     this.round = round;
 
     this.attribute_map = {
@@ -4069,6 +4350,7 @@ export class SimulateRequest extends BaseModel {
       allowUnnamedResources: 'allow-unnamed-resources',
       execTraceConfig: 'exec-trace-config',
       extraOpcodeBudget: 'extra-opcode-budget',
+      fixSigners: 'fix-signers',
       round: 'round',
     };
   }
@@ -4092,6 +4374,7 @@ export class SimulateRequest extends BaseModel {
           ? SimulateTraceConfig.from_obj_for_encoding(data['exec-trace-config'])
           : undefined,
       extraOpcodeBudget: data['extra-opcode-budget'],
+      fixSigners: data['fix-signers'],
       round: data['round'],
     });
     /* eslint-enable dot-notation */
@@ -4481,6 +4764,12 @@ export class SimulateTransactionResult extends BaseModel {
    */
   public execTrace?: SimulationTransactionExecTrace;
 
+  /**
+   * The account that needed to sign this transaction when no signature was provided
+   * and the provided signer was incorrect.
+   */
+  public fixedSigner?: string;
+
   /**
    * Budget used during execution of a logic sig transaction.
    */
@@ -4507,6 +4796,8 @@ export class SimulateTransactionResult extends BaseModel {
    * 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 fixedSigner - The account that needed to sign this transaction when no signature was provided
+   * and the provided signer was incorrect.
    * @param logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
    * @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
@@ -4522,12 +4813,14 @@ export class SimulateTransactionResult extends BaseModel {
     txnResult,
     appBudgetConsumed,
     execTrace,
+    fixedSigner,
     logicSigBudgetConsumed,
     unnamedResourcesAccessed,
   }: {
     txnResult: PendingTransactionResponse;
     appBudgetConsumed?: number | bigint;
     execTrace?: SimulationTransactionExecTrace;
+    fixedSigner?: string;
     logicSigBudgetConsumed?: number | bigint;
     unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
   }) {
@@ -4535,6 +4828,7 @@ export class SimulateTransactionResult extends BaseModel {
     this.txnResult = txnResult;
     this.appBudgetConsumed = appBudgetConsumed;
     this.execTrace = execTrace;
+    this.fixedSigner = fixedSigner;
     this.logicSigBudgetConsumed = logicSigBudgetConsumed;
     this.unnamedResourcesAccessed = unnamedResourcesAccessed;
 
@@ -4542,6 +4836,7 @@ export class SimulateTransactionResult extends BaseModel {
       txnResult: 'txn-result',
       appBudgetConsumed: 'app-budget-consumed',
       execTrace: 'exec-trace',
+      fixedSigner: 'fixed-signer',
       logicSigBudgetConsumed: 'logic-sig-budget-consumed',
       unnamedResourcesAccessed: 'unnamed-resources-accessed',
     };
@@ -4567,6 +4862,7 @@ export class SimulateTransactionResult extends BaseModel {
               data['exec-trace']
             )
           : undefined,
+      fixedSigner: data['fixed-signer'],
       logicSigBudgetConsumed: data['logic-sig-budget-consumed'],
       unnamedResourcesAccessed:
         typeof data['unnamed-resources-accessed'] !== 'undefined'
@@ -4736,6 +5032,12 @@ export class SimulationEvalOverrides extends BaseModel {
    */
   public extraOpcodeBudget?: number | bigint;
 
+  /**
+   * If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
+   */
+  public fixSigners?: boolean;
+
   /**
    * The maximum log calls one can make during simulation
    */
@@ -4752,6 +5054,8 @@ export class SimulationEvalOverrides extends BaseModel {
    * 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 fixSigners - If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
    * @param maxLogCalls - The maximum log calls one can make during simulation
    * @param maxLogSize - The maximum byte number to log during simulation
    */
@@ -4759,12 +5063,14 @@ export class SimulationEvalOverrides extends BaseModel {
     allowEmptySignatures,
     allowUnnamedResources,
     extraOpcodeBudget,
+    fixSigners,
     maxLogCalls,
     maxLogSize,
   }: {
     allowEmptySignatures?: boolean;
     allowUnnamedResources?: boolean;
     extraOpcodeBudget?: number | bigint;
+    fixSigners?: boolean;
     maxLogCalls?: number | bigint;
     maxLogSize?: number | bigint;
   }) {
@@ -4772,6 +5078,7 @@ export class SimulationEvalOverrides extends BaseModel {
     this.allowEmptySignatures = allowEmptySignatures;
     this.allowUnnamedResources = allowUnnamedResources;
     this.extraOpcodeBudget = extraOpcodeBudget;
+    this.fixSigners = fixSigners;
     this.maxLogCalls = maxLogCalls;
     this.maxLogSize = maxLogSize;
 
@@ -4779,6 +5086,7 @@ export class SimulationEvalOverrides extends BaseModel {
       allowEmptySignatures: 'allow-empty-signatures',
       allowUnnamedResources: 'allow-unnamed-resources',
       extraOpcodeBudget: 'extra-opcode-budget',
+      fixSigners: 'fix-signers',
       maxLogCalls: 'max-log-calls',
       maxLogSize: 'max-log-size',
     };
@@ -4793,6 +5101,7 @@ export class SimulationEvalOverrides extends BaseModel {
       allowEmptySignatures: data['allow-empty-signatures'],
       allowUnnamedResources: data['allow-unnamed-resources'],
       extraOpcodeBudget: data['extra-opcode-budget'],
+      fixSigners: data['fix-signers'],
       maxLogCalls: data['max-log-calls'],
       maxLogSize: data['max-log-size'],
     });
@@ -4931,6 +5240,19 @@ export class SimulationTransactionExecTrace extends BaseModel {
    */
   public clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
 
+  /**
+   * If true, indicates that the clear state program failed and any persistent state
+   * changes it produced should be reverted once the program exits.
+   */
+  public clearStateRollback?: boolean;
+
+  /**
+   * The error message explaining why the clear state program failed. This field will
+   * only be populated if clear-state-rollback is true and the failure was due to an
+   * execution error.
+   */
+  public clearStateRollbackError?: string;
+
   /**
    * An array of SimulationTransactionExecTrace representing the execution trace of
    * any inner transactions executed.
@@ -4953,6 +5275,11 @@ export class SimulationTransactionExecTrace extends BaseModel {
    * @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 clearStateRollback - If true, indicates that the clear state program failed and any persistent state
+   * changes it produced should be reverted once the program exits.
+   * @param clearStateRollbackError - The error message explaining why the clear state program failed. This field will
+   * only be populated if clear-state-rollback is true and the failure was due to an
+   * execution error.
    * @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.
@@ -4963,6 +5290,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
     approvalProgramTrace,
     clearStateProgramHash,
     clearStateProgramTrace,
+    clearStateRollback,
+    clearStateRollbackError,
     innerTrace,
     logicSigHash,
     logicSigTrace,
@@ -4971,6 +5300,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
     approvalProgramTrace?: SimulationOpcodeTraceUnit[];
     clearStateProgramHash?: string | Uint8Array;
     clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+    clearStateRollback?: boolean;
+    clearStateRollbackError?: string;
     innerTrace?: SimulationTransactionExecTrace[];
     logicSigHash?: string | Uint8Array;
     logicSigTrace?: SimulationOpcodeTraceUnit[];
@@ -4986,6 +5317,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
         ? new Uint8Array(Buffer.from(clearStateProgramHash, 'base64'))
         : clearStateProgramHash;
     this.clearStateProgramTrace = clearStateProgramTrace;
+    this.clearStateRollback = clearStateRollback;
+    this.clearStateRollbackError = clearStateRollbackError;
     this.innerTrace = innerTrace;
     this.logicSigHash =
       typeof logicSigHash === 'string'
@@ -4998,6 +5331,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
       approvalProgramTrace: 'approval-program-trace',
       clearStateProgramHash: 'clear-state-program-hash',
       clearStateProgramTrace: 'clear-state-program-trace',
+      clearStateRollback: 'clear-state-rollback',
+      clearStateRollbackError: 'clear-state-rollback-error',
       innerTrace: 'inner-trace',
       logicSigHash: 'logic-sig-hash',
       logicSigTrace: 'logic-sig-trace',
@@ -5024,6 +5359,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
               SimulationOpcodeTraceUnit.from_obj_for_encoding
             )
           : undefined,
+      clearStateRollback: data['clear-state-rollback'],
+      clearStateRollbackError: data['clear-state-rollback-error'],
       innerTrace:
         typeof data['inner-trace'] !== 'undefined'
           ? data['inner-trace'].map(