algosdk 2.7.0 → 2.9.0

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

@@ -49,6 +49,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
@@ -61,7 +66,7 @@ export class Account extends BaseModel {
      * values.
      * @param totalBoxes - (tbx) The number of existing boxes created by this account's app.
      */
-    constructor({ address, amount, amountWithoutPendingRewards, minBalance, pendingRewards, rewards, round, status, totalAppsOptedIn, totalAssetsOptedIn, totalCreatedApps, totalCreatedAssets, appsLocalState, appsTotalExtraPages, appsTotalSchema, assets, authAddr, createdApps, createdAssets, participation, rewardBase, sigType, totalBoxBytes, totalBoxes, }) {
+    constructor({ address, amount, amountWithoutPendingRewards, minBalance, pendingRewards, rewards, round, status, totalAppsOptedIn, totalAssetsOptedIn, totalCreatedApps, totalCreatedAssets, appsLocalState, appsTotalExtraPages, appsTotalSchema, assets, authAddr, createdApps, createdAssets, incentiveEligible, lastHeartbeat, lastProposed, participation, rewardBase, sigType, totalBoxBytes, totalBoxes, }) {
         super();
         this.address = address;
         this.amount = amount;
@@ -82,6 +87,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;
@@ -107,6 +115,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',
@@ -171,6 +182,9 @@ export class Account extends BaseModel {
             createdAssets: 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'])
                 : undefined,
@@ -226,6 +240,41 @@ export class AccountApplicationResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * AccountAssetHolding describes the account's asset holding and asset parameters
+ * (if either exist) for a specific asset ID.
+ */
+export class AccountAssetHolding extends BaseModel {
+    /**
+     * 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, }) {
+        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) {
+        /* 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
@@ -268,6 +317,43 @@ export class AccountAssetResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * AccountAssetsInformationResponse contains a list of assets held by an account.
+ */
+export class AccountAssetsInformationResponse extends BaseModel {
+    /**
+     * 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, }) {
+        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) {
+        /* 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.
@@ -365,6 +451,45 @@ export class AccountStateDelta extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * 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 {
+    /**
+     * 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, }) {
+        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) {
+        /* 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
  */
@@ -1011,6 +1136,38 @@ export class BlockHashResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * 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 {
+    /**
+     * Creates a new `BlockLogsResponse` object.
+     * @param logs -
+     */
+    constructor({ logs }) {
+        super();
+        this.logs = logs;
+        this.attribute_map = {
+            logs: 'logs',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* 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.
  */
@@ -2220,12 +2377,14 @@ 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).
      * If not specified, defaults to the latest available round.
      */
-    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, allowUnnamedResources, execTraceConfig, extraOpcodeBudget, round, }) {
+    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, allowUnnamedResources, execTraceConfig, extraOpcodeBudget, fixSigners, round, }) {
         super();
         this.txnGroups = txnGroups;
         this.allowEmptySignatures = allowEmptySignatures;
@@ -2233,6 +2392,7 @@ export class SimulateRequest extends BaseModel {
         this.allowUnnamedResources = allowUnnamedResources;
         this.execTraceConfig = execTraceConfig;
         this.extraOpcodeBudget = extraOpcodeBudget;
+        this.fixSigners = fixSigners;
         this.round = round;
         this.attribute_map = {
             txnGroups: 'txn-groups',
@@ -2241,6 +2401,7 @@ export class SimulateRequest extends BaseModel {
             allowUnnamedResources: 'allow-unnamed-resources',
             execTraceConfig: 'exec-trace-config',
             extraOpcodeBudget: 'extra-opcode-budget',
+            fixSigners: 'fix-signers',
             round: 'round',
         };
     }
@@ -2258,6 +2419,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 */
@@ -2459,6 +2621,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
@@ -2470,17 +2634,19 @@ export class SimulateTransactionResult extends BaseModel {
      * transaction of the group; otherwise, resources must be placed in the same
      * transaction which accessed them.
      */
-    constructor({ txnResult, appBudgetConsumed, execTrace, logicSigBudgetConsumed, unnamedResourcesAccessed, }) {
+    constructor({ txnResult, appBudgetConsumed, execTrace, fixedSigner, logicSigBudgetConsumed, unnamedResourcesAccessed, }) {
         super();
         this.txnResult = txnResult;
         this.appBudgetConsumed = appBudgetConsumed;
         this.execTrace = execTrace;
+        this.fixedSigner = fixedSigner;
         this.logicSigBudgetConsumed = logicSigBudgetConsumed;
         this.unnamedResourcesAccessed = unnamedResourcesAccessed;
         this.attribute_map = {
             txnResult: 'txn-result',
             appBudgetConsumed: 'app-budget-consumed',
             execTrace: 'exec-trace',
+            fixedSigner: 'fixed-signer',
             logicSigBudgetConsumed: 'logic-sig-budget-consumed',
             unnamedResourcesAccessed: 'unnamed-resources-accessed',
         };
@@ -2496,6 +2662,7 @@ export class SimulateTransactionResult extends BaseModel {
             execTrace: typeof data['exec-trace'] !== 'undefined'
                 ? SimulationTransactionExecTrace.from_obj_for_encoding(data['exec-trace'])
                 : undefined,
+            fixedSigner: data['fixed-signer'],
             logicSigBudgetConsumed: data['logic-sig-budget-consumed'],
             unnamedResourcesAccessed: typeof data['unnamed-resources-accessed'] !== 'undefined'
                 ? SimulateUnnamedResourcesAccessed.from_obj_for_encoding(data['unnamed-resources-accessed'])
@@ -2583,20 +2750,24 @@ 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
      */
-    constructor({ allowEmptySignatures, allowUnnamedResources, extraOpcodeBudget, maxLogCalls, maxLogSize, }) {
+    constructor({ allowEmptySignatures, allowUnnamedResources, extraOpcodeBudget, fixSigners, maxLogCalls, maxLogSize, }) {
         super();
         this.allowEmptySignatures = allowEmptySignatures;
         this.allowUnnamedResources = allowUnnamedResources;
         this.extraOpcodeBudget = extraOpcodeBudget;
+        this.fixSigners = fixSigners;
         this.maxLogCalls = maxLogCalls;
         this.maxLogSize = maxLogSize;
         this.attribute_map = {
             allowEmptySignatures: 'allow-empty-signatures',
             allowUnnamedResources: 'allow-unnamed-resources',
             extraOpcodeBudget: 'extra-opcode-budget',
+            fixSigners: 'fix-signers',
             maxLogCalls: 'max-log-calls',
             maxLogSize: 'max-log-size',
         };
@@ -2608,6 +2779,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'],
         });
@@ -2677,12 +2849,17 @@ 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.
      * @param logicSigTrace - Program trace that contains a trace of opcode effects in a logic sig.
      */
-    constructor({ approvalProgramHash, approvalProgramTrace, clearStateProgramHash, clearStateProgramTrace, innerTrace, logicSigHash, logicSigTrace, }) {
+    constructor({ approvalProgramHash, approvalProgramTrace, clearStateProgramHash, clearStateProgramTrace, clearStateRollback, clearStateRollbackError, innerTrace, logicSigHash, logicSigTrace, }) {
         super();
         this.approvalProgramHash =
             typeof approvalProgramHash === 'string'
@@ -2694,6 +2871,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'
@@ -2705,6 +2884,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',
@@ -2722,6 +2903,8 @@ export class SimulationTransactionExecTrace extends BaseModel {
             clearStateProgramTrace: typeof data['clear-state-program-trace'] !== 'undefined'
                 ? data['clear-state-program-trace'].map(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(SimulationTransactionExecTrace.from_obj_for_encoding)
                 : undefined,