algosdk 2.2.0 → 2.4.0

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

@@ -446,9 +446,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, clearStateProgram, creator, extraProgramPages, globalState, globalStateSchema, localStateSchema, }) {
         super();
@@ -1356,6 +1356,125 @@ export class EvalDeltaKeyValue extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Response containing the timestamp offset in seconds
+ */
+export class GetBlockTimeStampOffsetResponse extends BaseModel {
+    /**
+     * Creates a new `GetBlockTimeStampOffsetResponse` object.
+     * @param offset - Timestamp offset in seconds.
+     */
+    constructor({ offset }) {
+        super();
+        this.offset = offset;
+        this.attribute_map = {
+            offset: 'offset',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* 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 {
+    /**
+     * Creates a new `GetSyncRoundResponse` object.
+     * @param round - The minimum sync round for the ledger.
+     */
+    constructor({ round }) {
+        super();
+        this.round = round;
+        this.attribute_map = {
+            round: 'round',
+        };
+    }
+    // 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 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 {
+    /**
+     * 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, }) {
+        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) {
+        /* eslint-disable dot-notation */
+        return new KvDelta({
+            key: data['key'],
+            value: data['value'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * Contains a ledger delta for a single transaction group
+ */
+export class LedgerStateDeltaForTransactionGroup extends BaseModel {
+    /**
+     * Creates a new `LedgerStateDeltaForTransactionGroup` object.
+     * @param delta - Ledger StateDelta object
+     * @param ids -
+     */
+    constructor({ delta, ids }) {
+        super();
+        this.delta = delta;
+        this.ids = ids;
+        this.attribute_map = {
+            delta: 'delta',
+            ids: 'ids',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (typeof data['delta'] === 'undefined')
+            throw new Error(`Response is missing required field 'delta': ${data}`);
+        if (!Array.isArray(data['ids']))
+            throw new Error(`Response is missing required array field 'ids': ${data}`);
+        return new LedgerStateDeltaForTransactionGroup({
+            delta: data['delta'],
+            ids: data['ids'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * Proof of membership and position of a light block header.
  */
@@ -1430,8 +1549,16 @@ 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, lastRound, lastVersion, nextVersion, nextVersionRound, nextVersionSupported, stoppedAtUnsupportedRound, timeSinceLastRound, catchpoint, catchpointAcquiredBlocks, catchpointProcessedAccounts, catchpointProcessedKvs, catchpointTotalAccounts, catchpointTotalBlocks, catchpointTotalKvs, catchpointVerifiedAccounts, catchpointVerifiedKvs, lastCatchpoint, }) {
+    constructor({ catchupTime, lastRound, lastVersion, nextVersion, nextVersionRound, nextVersionSupported, stoppedAtUnsupportedRound, timeSinceLastRound, catchpoint, catchpointAcquiredBlocks, catchpointProcessedAccounts, catchpointProcessedKvs, catchpointTotalAccounts, catchpointTotalBlocks, catchpointTotalKvs, catchpointVerifiedAccounts, catchpointVerifiedKvs, lastCatchpoint, upgradeDelay, upgradeNextProtocolVoteBefore, upgradeNoVotes, upgradeNodeVote, upgradeVoteRounds, upgradeVotes, upgradeVotesRequired, upgradeYesVotes, }) {
         super();
         this.catchupTime = catchupTime;
         this.lastRound = lastRound;
@@ -1451,6 +1578,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',
             lastRound: 'last-round',
@@ -1470,6 +1605,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',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1510,6 +1653,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 */
     }
@@ -1532,12 +1683,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.
      */
@@ -1666,6 +1817,71 @@ export class PostTransactionsResponse extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Request type for simulation endpoint.
+ */
+export class SimulateRequest extends BaseModel {
+    /**
+     * 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.
+     * @param extraOpcodeBudget - Applies extra opcode budget during simulation for each transaction group.
+     */
+    constructor({ txnGroups, allowEmptySignatures, allowMoreLogging, extraOpcodeBudget, }) {
+        super();
+        this.txnGroups = txnGroups;
+        this.allowEmptySignatures = allowEmptySignatures;
+        this.allowMoreLogging = allowMoreLogging;
+        this.extraOpcodeBudget = extraOpcodeBudget;
+        this.attribute_map = {
+            txnGroups: 'txn-groups',
+            allowEmptySignatures: 'allow-empty-signatures',
+            allowMoreLogging: 'allow-more-logging',
+            extraOpcodeBudget: 'extra-opcode-budget',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* 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'],
+            extraOpcodeBudget: data['extra-opcode-budget'],
+        });
+        /* eslint-enable dot-notation */
+    }
+}
+/**
+ * A transaction group to simulate.
+ */
+export class SimulateRequestTransactionGroup extends BaseModel {
+    /**
+     * Creates a new `SimulateRequestTransactionGroup` object.
+     * @param txns - An atomic transaction group.
+     */
+    constructor({ txns }) {
+        super();
+        this.txns = txns;
+        this.attribute_map = {
+            txns: 'txns',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* 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.
  */
@@ -1676,21 +1892,21 @@ export class SimulateResponse extends BaseModel {
      * 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 wouldSucceed - Indicates whether the simulated transactions would have succeeded during an
-     * actual submission. If any transaction fails or is missing a signature, this will
-     * be false.
+     * @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, wouldSucceed, }) {
+    constructor({ lastRound, txnGroups, version, evalOverrides, }) {
         super();
         this.lastRound = lastRound;
         this.txnGroups = txnGroups;
         this.version = version;
-        this.wouldSucceed = wouldSucceed;
+        this.evalOverrides = evalOverrides;
         this.attribute_map = {
             lastRound: 'last-round',
             txnGroups: 'txn-groups',
             version: 'version',
-            wouldSucceed: 'would-succeed',
+            evalOverrides: 'eval-overrides',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1702,13 +1918,13 @@ export class SimulateResponse extends BaseModel {
             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}`);
-        if (typeof data['would-succeed'] === 'undefined')
-            throw new Error(`Response is missing required field 'would-succeed': ${data}`);
         return new SimulateResponse({
             lastRound: data['last-round'],
             txnGroups: data['txn-groups'].map(SimulateTransactionGroupResult.from_obj_for_encoding),
             version: data['version'],
-            wouldSucceed: data['would-succeed'],
+            evalOverrides: typeof data['eval-overrides'] !== 'undefined'
+                ? SimulationEvalOverrides.from_obj_for_encoding(data['eval-overrides'])
+                : undefined,
         });
         /* eslint-enable dot-notation */
     }
@@ -1720,6 +1936,8 @@ export class SimulateTransactionGroupResult extends BaseModel {
     /**
      * 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
@@ -1727,13 +1945,17 @@ export class SimulateTransactionGroupResult extends BaseModel {
      * @param failureMessage - If present, indicates that the transaction group failed and specifies why that
      * happened
      */
-    constructor({ txnResults, failedAt, failureMessage, }) {
+    constructor({ txnResults, appBudgetAdded, appBudgetConsumed, failedAt, failureMessage, }) {
         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',
         };
@@ -1745,6 +1967,8 @@ export class SimulateTransactionGroupResult extends BaseModel {
             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'],
         });
@@ -1759,15 +1983,19 @@ export class SimulateTransactionResult extends BaseModel {
      * 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 missingSignature - A boolean indicating whether this transaction is missing signatures
+     * @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, missingSignature, }) {
+    constructor({ txnResult, appBudgetConsumed, logicSigBudgetConsumed, }) {
         super();
         this.txnResult = txnResult;
-        this.missingSignature = missingSignature;
+        this.appBudgetConsumed = appBudgetConsumed;
+        this.logicSigBudgetConsumed = logicSigBudgetConsumed;
         this.attribute_map = {
             txnResult: 'txn-result',
-            missingSignature: 'missing-signature',
+            appBudgetConsumed: 'app-budget-consumed',
+            logicSigBudgetConsumed: 'logic-sig-budget-consumed',
         };
     }
     // eslint-disable-next-line camelcase
@@ -1777,7 +2005,47 @@ export class SimulateTransactionResult extends BaseModel {
             throw new Error(`Response is missing required field 'txn-result': ${data}`);
         return new SimulateTransactionResult({
             txnResult: PendingTransactionResponse.from_obj_for_encoding(data['txn-result']),
-            missingSignature: data['missing-signature'],
+            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 {
+    /**
+     * Creates a new `SimulationEvalOverrides` object.
+     * @param allowEmptySignatures - If true, transactions without signatures are allowed and simulated as if they
+     * were properly signed.
+     * @param extraOpcodeBudget - The extra opcode budget added to each transaction group during simulation
+     * @param maxLogCalls - The maximum log calls one can make during simulation
+     * @param maxLogSize - The maximum byte number to log during simulation
+     */
+    constructor({ allowEmptySignatures, extraOpcodeBudget, maxLogCalls, maxLogSize, }) {
+        super();
+        this.allowEmptySignatures = allowEmptySignatures;
+        this.extraOpcodeBudget = extraOpcodeBudget;
+        this.maxLogCalls = maxLogCalls;
+        this.maxLogSize = maxLogSize;
+        this.attribute_map = {
+            allowEmptySignatures: 'allow-empty-signatures',
+            extraOpcodeBudget: 'extra-opcode-budget',
+            maxLogCalls: 'max-log-calls',
+            maxLogSize: 'max-log-size',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        return new SimulationEvalOverrides({
+            allowEmptySignatures: data['allow-empty-signatures'],
+            extraOpcodeBudget: data['extra-opcode-budget'],
+            maxLogCalls: data['max-log-calls'],
+            maxLogSize: data['max-log-size'],
         });
         /* eslint-enable dot-notation */
     }
@@ -1983,6 +2251,33 @@ export class TealValue extends BaseModel {
         /* eslint-enable dot-notation */
     }
 }
+/**
+ * Response containing all ledger state deltas for transaction groups, with their
+ * associated Ids, in a single round.
+ */
+export class TransactionGroupLedgerStateDeltasForRoundResponse extends BaseModel {
+    /**
+     * Creates a new `TransactionGroupLedgerStateDeltasForRoundResponse` object.
+     * @param deltas -
+     */
+    constructor({ deltas }) {
+        super();
+        this.deltas = deltas;
+        this.attribute_map = {
+            deltas: 'deltas',
+        };
+    }
+    // eslint-disable-next-line camelcase
+    static from_obj_for_encoding(data) {
+        /* eslint-disable dot-notation */
+        if (!Array.isArray(data['Deltas']))
+            throw new Error(`Response is missing required array field 'Deltas': ${data}`);
+        return new TransactionGroupLedgerStateDeltasForRoundResponse({
+            deltas: data['Deltas'].map(LedgerStateDeltaForTransactionGroup.from_obj_for_encoding),
+        });
+        /* eslint-enable dot-notation */
+    }
+}
 /**
  * TransactionParams contains the parameters that help a client construct a new
  * transaction.