algosdk 3.7.0-beta.1 → 3.8.0

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

@@ -176,6 +176,7 @@ export class Account {
      * * sig
      * * msig
      * * lsig
+     * * pqsig
      * * or null if unknown
      */
     constructor({ address, amount, amountWithoutPendingRewards, minBalance, pendingRewards, rewards, round, status, totalAppsOptedIn, totalAssetsOptedIn, totalBoxBytes, totalBoxes, totalCreatedApps, totalCreatedAssets, appsLocalState, appsTotalExtraPages, appsTotalSchema, assets, authAddr, closedAtRound, createdApps, createdAssets, createdAtRound, deleted, incentiveEligible, lastHeartbeat, lastProposed, participation, rewardBase, sigType, }) {
@@ -1793,10 +1794,18 @@ export class Block {
                 key: 'bonus',
                 valueSchema: new OptionalSchema(new Uint64Schema()),
                 omitEmpty: true,
+            }, {
+                key: 'congestion-tax',
+                valueSchema: new OptionalSchema(new Uint64Schema()),
+                omitEmpty: true,
             }, {
                 key: 'fees-collected',
                 valueSchema: new OptionalSchema(new Uint64Schema()),
                 omitEmpty: true,
+            }, {
+                key: 'load',
+                valueSchema: new OptionalSchema(new Uint64Schema()),
+                omitEmpty: true,
             }, {
                 key: 'participation-updates',
                 valueSchema: new OptionalSchema(ParticipationUpdates.encodingSchema),
@@ -1864,7 +1873,12 @@ export class Block {
      * the default SHA512_256. This commitment can be used on environments where only
      * the SHA256 function exists.
      * @param bonus - the potential bonus payout for this block.
+     * @param congestionTax - the fee required, beyond the minimum fee, for "normal" transactions in this
+     * block.
      * @param feesCollected - the sum of all fees paid by transactions in this block.
+     * @param load - the degree to which this block is full, based on the number of bytes in the
+     * final block compared to the maximum allowed. Expressed as a fixed-point integer
+     * with 6 digits of precision, so 1,000,000 is a completely full block.
      * @param participationUpdates - Participation account data that needs to be checked/acted on by the network.
      * @param previousBlockHash512 - (prev512) Previous block hash, using SHA-512.
      * @param proposer - the proposer of this block.
@@ -1883,7 +1897,7 @@ export class Block {
      * @param upgradeState - Fields relating to a protocol upgrade.
      * @param upgradeVote - Fields relating to voting for a protocol upgrade.
      */
-    constructor({ genesisHash, genesisId, previousBlockHash, round, seed, timestamp, transactionsRoot, transactionsRootSha256, bonus, feesCollected, participationUpdates, previousBlockHash512, proposer, proposerPayout, rewards, stateProofTracking, transactions, transactionsRootSha512, txnCounter, upgradeState, upgradeVote, }) {
+    constructor({ genesisHash, genesisId, previousBlockHash, round, seed, timestamp, transactionsRoot, transactionsRootSha256, bonus, congestionTax, feesCollected, load, participationUpdates, previousBlockHash512, proposer, proposerPayout, rewards, stateProofTracking, transactions, transactionsRootSha512, txnCounter, upgradeState, upgradeVote, }) {
         this.genesisHash =
             typeof genesisHash === 'string'
                 ? base64ToBytes(genesisHash)
@@ -1906,10 +1920,16 @@ export class Block {
                 : transactionsRootSha256;
         this.bonus =
             typeof bonus === 'undefined' ? undefined : ensureSafeInteger(bonus);
+        this.congestionTax =
+            typeof congestionTax === 'undefined'
+                ? undefined
+                : ensureSafeInteger(congestionTax);
         this.feesCollected =
             typeof feesCollected === 'undefined'
                 ? undefined
                 : ensureSafeInteger(feesCollected);
+        this.load =
+            typeof load === 'undefined' ? undefined : ensureSafeInteger(load);
         this.participationUpdates = participationUpdates;
         this.previousBlockHash512 =
             typeof previousBlockHash512 === 'string'
@@ -1950,7 +1970,9 @@ export class Block {
             ['transactions-root', this.transactionsRoot],
             ['transactions-root-sha256', this.transactionsRootSha256],
             ['bonus', this.bonus],
+            ['congestion-tax', this.congestionTax],
             ['fees-collected', this.feesCollected],
+            ['load', this.load],
             [
                 'participation-updates',
                 typeof this.participationUpdates !== 'undefined'
@@ -2013,7 +2035,9 @@ export class Block {
             transactionsRoot: data.get('transactions-root'),
             transactionsRootSha256: data.get('transactions-root-sha256'),
             bonus: data.get('bonus'),
+            congestionTax: data.get('congestion-tax'),
             feesCollected: data.get('fees-collected'),
+            load: data.get('load'),
             participationUpdates: typeof data.get('participation-updates') !== 'undefined'
                 ? ParticipationUpdates.fromEncodingData(data.get('participation-updates'))
                 : undefined,
@@ -2368,15 +2392,15 @@ export class Box {
     }
 }
 /**
- * Box descriptor describes an app box without a value.
+ * Box descriptor describes an app box.
  */
 export class BoxDescriptor {
     static get encodingSchema() {
         if (!this.encodingSchemaValue) {
             this.encodingSchemaValue = new NamedMapSchema([]);
-            this.encodingSchemaValue.pushEntries({
-                key: 'name',
-                valueSchema: new ByteArraySchema(),
+            this.encodingSchemaValue.pushEntries({ key: 'name', valueSchema: new ByteArraySchema(), omitEmpty: true }, {
+                key: 'value',
+                valueSchema: new OptionalSchema(new ByteArraySchema()),
                 omitEmpty: true,
             });
         }
@@ -2385,16 +2409,22 @@ export class BoxDescriptor {
     /**
      * Creates a new `BoxDescriptor` object.
      * @param name - Base64 encoded box name
+     * @param value - Base64 encoded box value. Present only when the `values` query parameter is set
+     * to true.
      */
-    constructor({ name }) {
+    constructor({ name, value, }) {
         this.name = typeof name === 'string' ? base64ToBytes(name) : name;
+        this.value = typeof value === 'string' ? base64ToBytes(value) : value;
     }
     // eslint-disable-next-line class-methods-use-this
     getEncodingSchema() {
         return BoxDescriptor.encodingSchema;
     }
     toEncodingData() {
-        return new Map([['name', this.name]]);
+        return new Map([
+            ['name', this.name],
+            ['value', this.value],
+        ]);
     }
     static fromEncodingData(data) {
         if (!(data instanceof Map)) {
@@ -2402,6 +2432,7 @@ export class BoxDescriptor {
         }
         return new BoxDescriptor({
             name: data.get('name'),
+            value: data.get('value'),
         });
     }
 }
@@ -2465,6 +2496,10 @@ export class BoxesResponse {
                 key: 'next-token',
                 valueSchema: new OptionalSchema(new StringSchema()),
                 omitEmpty: true,
+            }, {
+                key: 'round',
+                valueSchema: new OptionalSchema(new Uint64Schema()),
+                omitEmpty: true,
             });
         }
         return this.encodingSchemaValue;
@@ -2475,11 +2510,14 @@ export class BoxesResponse {
      * @param boxes -
      * @param nextToken - Used for pagination, when making another request provide this token with the
      * next parameter.
+     * @param round - The round for which this information is relevant.
      */
-    constructor({ applicationId, boxes, nextToken, }) {
+    constructor({ applicationId, boxes, nextToken, round, }) {
         this.applicationId = ensureBigInt(applicationId);
         this.boxes = boxes;
         this.nextToken = nextToken;
+        this.round =
+            typeof round === 'undefined' ? undefined : ensureSafeInteger(round);
     }
     // eslint-disable-next-line class-methods-use-this
     getEncodingSchema() {
@@ -2490,6 +2528,7 @@ export class BoxesResponse {
             ['application-id', this.applicationId],
             ['boxes', this.boxes.map((v) => v.toEncodingData())],
             ['next-token', this.nextToken],
+            ['round', this.round],
         ]);
     }
     static fromEncodingData(data) {
@@ -2500,6 +2539,7 @@ export class BoxesResponse {
             applicationId: data.get('application-id'),
             boxes: (data.get('boxes') ?? []).map((v) => BoxDescriptor.fromEncodingData(v)),
             nextToken: data.get('next-token'),
+            round: data.get('round'),
         });
     }
 }
@@ -4859,6 +4899,10 @@ export class TransactionHeartbeat {
                 key: 'hb-vote-id',
                 valueSchema: new ByteArraySchema(),
                 omitEmpty: true,
+            }, {
+                key: 'hb-challenge-discount',
+                valueSchema: new OptionalSchema(new BooleanSchema()),
+                omitEmpty: true,
             });
         }
         return this.encodingSchemaValue;
@@ -4872,14 +4916,18 @@ export class TransactionHeartbeat {
      * @param hbSeed - (hbsd) HbSeed must be the block seed for the this transaction's firstValid
      * block.
      * @param hbVoteId - (hbvid) HbVoteID must match the HbAddress account's current VoteID.
+     * @param hbChallengeDiscount - (hbc) HbChallengeDiscount requests the challenge fee discount, reducing the
+     * required fee by one min fee. It is a request, not an assertion: it is granted
+     * only if HbAddress is actually under challenge.
      */
-    constructor({ hbAddress, hbKeyDilution, hbProof, hbSeed, hbVoteId, }) {
+    constructor({ hbAddress, hbKeyDilution, hbProof, hbSeed, hbVoteId, hbChallengeDiscount, }) {
         this.hbAddress = hbAddress;
         this.hbKeyDilution = ensureBigInt(hbKeyDilution);
         this.hbProof = hbProof;
         this.hbSeed = typeof hbSeed === 'string' ? base64ToBytes(hbSeed) : hbSeed;
         this.hbVoteId =
             typeof hbVoteId === 'string' ? base64ToBytes(hbVoteId) : hbVoteId;
+        this.hbChallengeDiscount = hbChallengeDiscount;
     }
     // eslint-disable-next-line class-methods-use-this
     getEncodingSchema() {
@@ -4892,6 +4940,7 @@ export class TransactionHeartbeat {
             ['hb-proof', this.hbProof.toEncodingData()],
             ['hb-seed', this.hbSeed],
             ['hb-vote-id', this.hbVoteId],
+            ['hb-challenge-discount', this.hbChallengeDiscount],
         ]);
     }
     static fromEncodingData(data) {
@@ -4904,6 +4953,7 @@ export class TransactionHeartbeat {
             hbProof: HbProofFields.fromEncodingData(data.get('hb-proof') ?? new Map()),
             hbSeed: data.get('hb-seed'),
             hbVoteId: data.get('hb-vote-id'),
+            hbChallengeDiscount: data.get('hb-challenge-discount'),
         });
     }
 }
@@ -5147,6 +5197,10 @@ export class TransactionSignature {
                 key: 'multisig',
                 valueSchema: new OptionalSchema(TransactionSignatureMultisig.encodingSchema),
                 omitEmpty: true,
+            }, {
+                key: 'pqsig',
+                valueSchema: new OptionalSchema(TransactionSignaturePQsig.encodingSchema),
+                omitEmpty: true,
             }, {
                 key: 'sig',
                 valueSchema: new OptionalSchema(new ByteArraySchema()),
@@ -5163,11 +5217,15 @@ export class TransactionSignature {
      * @param multisig - structure holding multiple subsignatures.
      * Definition:
      * crypto/multisig.go : MultisigSig
+     * @param pqsig - structure holding a post-quantum signature.
+     * Definition:
+     * data/transactions/pqsig.go : PQSig
      * @param sig - (sig) Standard ed25519 signature.
      */
-    constructor({ logicsig, multisig, sig, }) {
+    constructor({ logicsig, multisig, pqsig, sig, }) {
         this.logicsig = logicsig;
         this.multisig = multisig;
+        this.pqsig = pqsig;
         this.sig = typeof sig === 'string' ? base64ToBytes(sig) : sig;
     }
     // eslint-disable-next-line class-methods-use-this
@@ -5188,6 +5246,12 @@ export class TransactionSignature {
                     ? this.multisig.toEncodingData()
                     : undefined,
             ],
+            [
+                'pqsig',
+                typeof this.pqsig !== 'undefined'
+                    ? this.pqsig.toEncodingData()
+                    : undefined,
+            ],
             ['sig', this.sig],
         ]);
     }
@@ -5202,6 +5266,9 @@ export class TransactionSignature {
             multisig: typeof data.get('multisig') !== 'undefined'
                 ? TransactionSignatureMultisig.fromEncodingData(data.get('multisig'))
                 : undefined,
+            pqsig: typeof data.get('pqsig') !== 'undefined'
+                ? TransactionSignaturePQsig.fromEncodingData(data.get('pqsig'))
+                : undefined,
             sig: data.get('sig'),
         });
     }
@@ -5227,6 +5294,10 @@ export class TransactionSignatureLogicsig {
                 key: 'multisig-signature',
                 valueSchema: new OptionalSchema(TransactionSignatureMultisig.encodingSchema),
                 omitEmpty: true,
+            }, {
+                key: 'pqsig',
+                valueSchema: new OptionalSchema(TransactionSignaturePQsig.encodingSchema),
+                omitEmpty: true,
             }, {
                 key: 'signature',
                 valueSchema: new OptionalSchema(new ByteArraySchema()),
@@ -5246,13 +5317,17 @@ export class TransactionSignatureLogicsig {
      * @param multisigSignature - structure holding multiple subsignatures.
      * Definition:
      * crypto/multisig.go : MultisigSig
+     * @param pqsig - structure holding a post-quantum signature.
+     * Definition:
+     * data/transactions/pqsig.go : PQSig
      * @param signature - (sig) ed25519 signature.
      */
-    constructor({ logic, args, logicMultisigSignature, multisigSignature, signature, }) {
+    constructor({ logic, args, logicMultisigSignature, multisigSignature, pqsig, signature, }) {
         this.logic = typeof logic === 'string' ? base64ToBytes(logic) : logic;
         this.args = args;
         this.logicMultisigSignature = logicMultisigSignature;
         this.multisigSignature = multisigSignature;
+        this.pqsig = pqsig;
         this.signature =
             typeof signature === 'string' ? base64ToBytes(signature) : signature;
     }
@@ -5276,6 +5351,12 @@ export class TransactionSignatureLogicsig {
                     ? this.multisigSignature.toEncodingData()
                     : undefined,
             ],
+            [
+                'pqsig',
+                typeof this.pqsig !== 'undefined'
+                    ? this.pqsig.toEncodingData()
+                    : undefined,
+            ],
             ['signature', this.signature],
         ]);
     }
@@ -5292,6 +5373,9 @@ export class TransactionSignatureLogicsig {
             multisigSignature: typeof data.get('multisig-signature') !== 'undefined'
                 ? TransactionSignatureMultisig.fromEncodingData(data.get('multisig-signature'))
                 : undefined,
+            pqsig: typeof data.get('pqsig') !== 'undefined'
+                ? TransactionSignaturePQsig.fromEncodingData(data.get('pqsig'))
+                : undefined,
             signature: data.get('signature'),
         });
     }
@@ -5414,6 +5498,72 @@ export class TransactionSignatureMultisigSubsignature {
         });
     }
 }
+/**
+ * structure holding a post-quantum signature.
+ * Definition:
+ * data/transactions/pqsig.go : PQSig
+ */
+export class TransactionSignaturePQsig {
+    static get encodingSchema() {
+        if (!this.encodingSchemaValue) {
+            this.encodingSchemaValue = new NamedMapSchema([]);
+            this.encodingSchemaValue.pushEntries({
+                key: 'public-key',
+                valueSchema: new ByteArraySchema(),
+                omitEmpty: true,
+            }, { key: 'scheme', valueSchema: new StringSchema(), omitEmpty: true }, {
+                key: 'signature',
+                valueSchema: new ByteArraySchema(),
+                omitEmpty: true,
+            }, {
+                key: 'salt',
+                valueSchema: new OptionalSchema(new Uint64Schema()),
+                omitEmpty: true,
+            });
+        }
+        return this.encodingSchemaValue;
+    }
+    /**
+     * Creates a new `TransactionSignaturePQsig` object.
+     * @param publicKey - (pk)
+     * @param scheme - (sch) identifies the internal signature scheme.
+     * @param signature - (sig)
+     * @param salt - (slt) a single byte, added to ensure the hashed address is not an Ed25519 curve
+     * point
+     */
+    constructor({ publicKey, scheme, signature, salt, }) {
+        this.publicKey =
+            typeof publicKey === 'string' ? base64ToBytes(publicKey) : publicKey;
+        this.scheme = scheme;
+        this.signature =
+            typeof signature === 'string' ? base64ToBytes(signature) : signature;
+        this.salt =
+            typeof salt === 'undefined' ? undefined : ensureSafeInteger(salt);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getEncodingSchema() {
+        return TransactionSignaturePQsig.encodingSchema;
+    }
+    toEncodingData() {
+        return new Map([
+            ['public-key', this.publicKey],
+            ['scheme', this.scheme],
+            ['signature', this.signature],
+            ['salt', this.salt],
+        ]);
+    }
+    static fromEncodingData(data) {
+        if (!(data instanceof Map)) {
+            throw new Error(`Invalid decoded TransactionSignaturePQsig: ${data}`);
+        }
+        return new TransactionSignaturePQsig({
+            publicKey: data.get('public-key'),
+            scheme: data.get('scheme'),
+            signature: data.get('signature'),
+            salt: data.get('salt'),
+        });
+    }
+}
 /**
  * Fields for a state proof transaction.
  * Definition: