algosdk 2.7.0 → 2.8.0

package/dist/types/makeTxn.d.ts

@@ -45,7 +45,7 @@ export declare function makePaymentTxnWithSuggestedParamsFromObject(o: Expand<Pi
  * @param stateProofKey - state proof key. for key deregistration, leave undefined
  */
 export declare function makeKeyRegistrationTxnWithSuggestedParams(from: KeyRegistrationTxn['from'], note: KeyRegistrationTxn['note'], voteKey: KeyRegistrationTxn['voteKey'], selectionKey: KeyRegistrationTxn['selectionKey'], voteFirst: KeyRegistrationTxn['voteFirst'], voteLast: KeyRegistrationTxn['voteLast'], voteKeyDilution: KeyRegistrationTxn['voteKeyDilution'], suggestedParams: MustHaveSuggestedParams<KeyRegistrationTxn>['suggestedParams'], rekeyTo?: KeyRegistrationTxn['reKeyTo'], nonParticipation?: false, stateProofKey?: KeyRegistrationTxn['stateProofKey']): txnBuilder.Transaction;
-export declare function makeKeyRegistrationTxnWithSuggestedParams(from: KeyRegistrationTxn['from'], note: KeyRegistrationTxn['note'], voteKey: undefined, selectionKey: undefined, voteFirst: undefined, voteLast: undefined, voteKeyDilution: undefined, suggestedParams: MustHaveSuggestedParams<KeyRegistrationTxn>['suggestedParams'], rekeyTo?: KeyRegistrationTxn['reKeyTo'], nonParticipation?: true, stateProofKey?: undefined): txnBuilder.Transaction;
+export declare function makeKeyRegistrationTxnWithSuggestedParams(from: KeyRegistrationTxn['from'], note: KeyRegistrationTxn['note'], voteKey: undefined, selectionKey: undefined, voteFirst: undefined, voteLast: undefined, voteKeyDilution: undefined, suggestedParams: MustHaveSuggestedParams<KeyRegistrationTxn>['suggestedParams'], rekeyTo?: KeyRegistrationTxn['reKeyTo'], nonParticipation?: boolean, stateProofKey?: undefined): txnBuilder.Transaction;
 export declare function makeKeyRegistrationTxnWithSuggestedParamsFromObject(o: Expand<Pick<RenameProperty<MustHaveSuggestedParams<KeyRegistrationTxn>, 'reKeyTo', 'rekeyTo'>, 'from' | 'note' | 'voteKey' | 'selectionKey' | 'stateProofKey' | 'voteFirst' | 'voteLast' | 'voteKeyDilution' | 'suggestedParams' | 'rekeyTo'> & {
     nonParticipation?: false;
 }>): txnBuilder.Transaction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -37,7 +37,7 @@
     "@typescript-eslint/eslint-plugin": "^4.26.1",
     "@typescript-eslint/parser": "^4.26.1",
     "assert": "^2.0.0",
-    "chromedriver": "^116.0.0",
+    "chromedriver": "^122.0.3",
     "concurrently": "^6.2.0",
     "cucumber": "^5.1.0",
     "es-abstract": "^1.18.3",

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.
  */
@@ -4931,6 +5201,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 +5236,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 +5251,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
     approvalProgramTrace,
     clearStateProgramHash,
     clearStateProgramTrace,
+    clearStateRollback,
+    clearStateRollbackError,
     innerTrace,
     logicSigHash,
     logicSigTrace,
@@ -4971,6 +5261,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 +5278,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 +5292,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 +5320,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(