algosdk 2.7.0 → 2.9.0

package/dist/types/client/v2/algod/models/types.d.ts

@@ -104,6 +104,20 @@ export declare class Account extends BaseModel {
      * Note: the raw account uses `map[int] -> Asset` for this type.
      */
     createdAssets?: Asset[];
+    /**
+     * Whether or not the account can receive block incentives if its balance is in
+     * range at proposal time.
+     */
+    incentiveEligible?: boolean;
+    /**
+     * The round in which this account last went online, or explicitly renewed their
+     * online status.
+     */
+    lastHeartbeat?: number | bigint;
+    /**
+     * The round in which this account last proposed the block.
+     */
+    lastProposed?: number | bigint;
     /**
      * AccountParticipation describes the parameters used by this account in consensus
      * protocol.
@@ -169,6 +183,11 @@ export declare 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
@@ -181,7 +200,7 @@ export declare 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, }: {
         address: string;
         amount: number | bigint;
         amountWithoutPendingRewards: number | bigint;
@@ -201,6 +220,9 @@ export declare 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;
@@ -247,6 +269,34 @@ export declare class AccountApplicationResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): AccountApplicationResponse;
 }
+/**
+ * AccountAssetHolding describes the account's asset holding and asset parameters
+ * (if either exist) for a specific asset ID.
+ */
+export declare class AccountAssetHolding extends BaseModel {
+    /**
+     * (asset) Details about the asset held by this account.
+     * The raw account uses `AssetHolding` for this type.
+     */
+    assetHolding: AssetHolding;
+    /**
+     * (apar) parameters of the asset held by this account.
+     * The raw account uses `AssetParams` for this type.
+     */
+    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;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AccountAssetHolding;
+}
 /**
  * AccountAssetResponse describes the account's asset holding and asset parameters
  * (if either exist) for a specific asset ID. Asset parameters will only be
@@ -282,6 +332,34 @@ export declare class AccountAssetResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): AccountAssetResponse;
 }
+/**
+ * AccountAssetsInformationResponse contains a list of assets held by an account.
+ */
+export declare class AccountAssetsInformationResponse extends BaseModel {
+    /**
+     * The round for which this information is relevant.
+     */
+    round: number | bigint;
+    assetHoldings?: AccountAssetHolding[];
+    /**
+     * Used for pagination, when making another request provide this token with the
+     * next parameter.
+     */
+    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;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AccountAssetsInformationResponse;
+}
 /**
  * AccountParticipation describes the parameters used by this account in consensus
  * protocol.
@@ -352,6 +430,36 @@ export declare class AccountStateDelta extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): AccountStateDelta;
 }
+/**
+ * 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 declare class AppCallLogs extends BaseModel {
+    /**
+     * The application from which the logs were generated
+     */
+    applicationIndex: number | bigint;
+    /**
+     * An array of logs
+     */
+    logs: Uint8Array[];
+    /**
+     * The transaction ID of the outer app call that lead to these logs
+     */
+    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;
+    });
+    static from_obj_for_encoding(data: Record<string, any>): AppCallLogs;
+}
 /**
  * Application index and its parameters
  */
@@ -884,6 +992,26 @@ export declare class BlockHashResponse extends BaseModel {
     });
     static from_obj_for_encoding(data: Record<string, any>): BlockHashResponse;
 }
+/**
+ * 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 declare class BlockLogsResponse extends BaseModel {
+    logs: AppCallLogs[];
+    /**
+     * Creates a new `BlockLogsResponse` object.
+     * @param logs -
+     */
+    constructor({ logs }: {
+        logs: AppCallLogs[];
+    });
+    static from_obj_for_encoding(data: Record<string, any>): BlockLogsResponse;
+}
 /**
  * Encoded block object.
  */
@@ -1855,6 +1983,11 @@ export declare class SimulateRequest extends BaseModel {
      * Applies extra opcode budget during simulation for each transaction group.
      */
     extraOpcodeBudget?: number | bigint;
+    /**
+     * If true, signers for transactions that are missing signatures will be fixed
+     * during evaluation.
+     */
+    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
@@ -1871,18 +2004,21 @@ export declare 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, }: {
         txnGroups: SimulateRequestTransactionGroup[];
         allowEmptySignatures?: boolean;
         allowMoreLogging?: boolean;
         allowUnnamedResources?: boolean;
         execTraceConfig?: SimulateTraceConfig;
         extraOpcodeBudget?: number | bigint;
+        fixSigners?: boolean;
         round?: number | bigint;
     });
     static from_obj_for_encoding(data: Record<string, any>): SimulateRequest;
@@ -2088,6 +2224,11 @@ export declare class SimulateTransactionResult extends BaseModel {
      * call trace in a recursive way.
      */
     execTrace?: SimulationTransactionExecTrace;
+    /**
+     * The account that needed to sign this transaction when no signature was provided
+     * and the provided signer was incorrect.
+     */
+    fixedSigner?: string;
     /**
      * Budget used during execution of a logic sig transaction.
      */
@@ -2112,6 +2253,8 @@ export declare 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
@@ -2123,10 +2266,11 @@ export declare 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, }: {
         txnResult: PendingTransactionResponse;
         appBudgetConsumed?: number | bigint;
         execTrace?: SimulationTransactionExecTrace;
+        fixedSigner?: string;
         logicSigBudgetConsumed?: number | bigint;
         unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
     });
@@ -2222,6 +2366,11 @@ export declare class SimulationEvalOverrides extends BaseModel {
      * The extra opcode budget added to each transaction group during simulation
      */
     extraOpcodeBudget?: number | bigint;
+    /**
+     * If true, signers for transactions that are missing signatures will be fixed
+     * during evaluation.
+     */
+    fixSigners?: boolean;
     /**
      * The maximum log calls one can make during simulation
      */
@@ -2236,13 +2385,16 @@ export declare 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, }: {
         allowEmptySignatures?: boolean;
         allowUnnamedResources?: boolean;
         extraOpcodeBudget?: number | bigint;
+        fixSigners?: boolean;
         maxLogCalls?: number | bigint;
         maxLogSize?: number | bigint;
     });
@@ -2316,6 +2468,17 @@ export declare class SimulationTransactionExecTrace extends BaseModel {
      * Program trace that contains a trace of opcode effects in a clear state program.
      */
     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.
+     */
+    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.
+     */
+    clearStateRollbackError?: string;
     /**
      * An array of SimulationTransactionExecTrace representing the execution trace of
      * any inner transactions executed.
@@ -2335,16 +2498,23 @@ export declare 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, }: {
         approvalProgramHash?: string | Uint8Array;
         approvalProgramTrace?: SimulationOpcodeTraceUnit[];
         clearStateProgramHash?: string | Uint8Array;
         clearStateProgramTrace?: SimulationOpcodeTraceUnit[];
+        clearStateRollback?: boolean;
+        clearStateRollbackError?: string;
         innerTrace?: SimulationTransactionExecTrace[];
         logicSigHash?: string | Uint8Array;
         logicSigTrace?: SimulationOpcodeTraceUnit[];