algosdk 3.7.0-beta.1 → 3.8.0

package/dist/types/signer.d.ts

@@ -21,14 +21,52 @@ export interface Addressable {
  *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
  */
 export type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+/**
+ * An address paired with a signer able to sign transactions on its behalf.
+ *
+ * @remarks
+ * `address` is the address transactions are sent from, which is not necessarily
+ * the address that authorizes them: for a rekeyed account the two differ, and
+ * `txnSigner` sets the transaction's `sgnr` field accordingly.
+ */
 export interface AddressWithTransactionSigner extends Addressable {
     txnSigner: TransactionSigner;
 }
-/** Function for signing logic signatures for delegation
- *  @param lsig - The logic signature that is being signed for delegation
- *  @param msig - Optional multisig account that should be set when a public key is signing as a subsigner of a multisig
- *  @returns The address of the delegator
- * */
+/**
+ * An address paired with a signer that produces placeholder signatures for it.
+ *
+ * @remarks
+ * Useful for post-quantum accounts, whose real signatures are large and slow to
+ * produce, when only a simulation of the group is needed.
+ */
+export interface AddressWithEmptyTransactionSigner extends Addressable {
+    /**
+     * A TransactionSigner that produces unsigned (or placeholder-signed)
+     * transactions. This must only be used to simulate transactions with the
+     * `allowEmptySignatures` option enabled.
+     */
+    emptyTxnSigner: TransactionSigner;
+}
+/**
+ * This type represents a function which can sign a LogicSig for delegation.
+ *
+ * @remarks
+ * Exactly one of `sig`, `lmsig` and `pqsig` is returned, according to the kind
+ * of key the signer holds and whether `msig` was supplied:
+ *
+ * - `sig` - an ed25519 signature from a single delegating account
+ * - `lmsig` - a multisig containing this signer's subsignature, returned when
+ *   `msig` is supplied
+ * - `pqsig` - a post-quantum signature from a single delegating account
+ *
+ * @param lsig - The logic signature that is being signed for delegation
+ * @param msig - Optional multisig account that should be set when a public key is signing as a subsigner of a multisig
+ * @returns A promise which resolves to the signature and the address that
+ *   produced it. When `msig` is omitted this is the delegating account; when
+ *   `msig` is supplied it is the individual subsigner rather than the multisig.
+ *   Either way it is an authorizing address, which is not necessarily the
+ *   address the signer sends transactions from.
+ */
 export type DelegatedLsigSigner = (lsig: LogicSig, msig?: MultisigMetadata) => Promise<{
     address: Address;
 } & ({
@@ -38,14 +76,47 @@ export type DelegatedLsigSigner = (lsig: LogicSig, msig?: MultisigMetadata) => P
 } | {
     pqsig: EncodedPQSig;
 })>;
+/**
+ * An address paired with a signer able to delegate a LogicSig to it.
+ */
 export interface AddressWithDelegatedLsigSigner extends Addressable {
     delegatedLsigSigner: DelegatedLsigSigner;
 }
+/**
+ * This type represents a function which can sign arbitrary bytes, for use with
+ * {@link verifyBytes}.
+ *
+ * @remarks
+ * The implementation is responsible for prepending the "MX" domain-separation
+ * prefix ({@link SIGN_BYTES_PREFIX}) before signing, so `bytesToSign` is the
+ * caller's bytes alone.
+ *
+ * @param bytesToSign - The bytes to sign, without any domain-separation prefix
+ * @returns A promise which resolves to the raw signature
+ */
 export type MxBytesSigner = (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+/**
+ * An address paired with a signer able to sign arbitrary bytes on its behalf.
+ */
 export interface AddressWithMxBytesSigner extends Addressable {
     mxBytesSigner: MxBytesSigner;
 }
+/**
+ * This type represents a function which can sign data for use with the
+ * `ed25519verify` opcode from within a LogicSig's program.
+ *
+ * @remarks
+ * The implementation is responsible for prepending the "ProgData" prefix
+ * ({@link SIGN_PROGRAM_DATA_PREFIX}) and the LogicSig's address before signing.
+ *
+ * @param data - The data to sign, without any prefix
+ * @param lsig - The LogicSig whose program will verify the signature
+ * @returns A promise which resolves to the raw signature
+ */
 export type ProgramDataSigner = (data: Uint8Array, lsig: LogicSig) => Promise<Uint8Array>;
+/**
+ * An address paired with a signer able to sign program data on its behalf.
+ */
 export interface AddressWithProgramDataSigner extends Addressable {
     programDataSigner: ProgramDataSigner;
 }

package/dist/types/signing.d.ts

@@ -3,6 +3,11 @@ import { SignedTransaction } from './signedTransaction.js';
 import { Transaction } from './transaction.js';
 import { LogicSig, LogicSigAccount } from './logicsig.js';
 import type { TransactionSigner } from './signer.js';
+/**
+ * The domain-separation prefix prepended to arbitrary bytes before signing them
+ * with {@link signBytes}, so that such a signature can never be mistaken for a
+ * signature over a transaction or a program.
+ */
 export declare const SIGN_BYTES_PREFIX: Uint8Array;
 /**
  * @deprecated Use signTransactionWithSigner
@@ -25,6 +30,23 @@ export declare function signTransaction(txn: Transaction, sk: Uint8Array): {
     txID: string;
     blob: Uint8Array;
 };
+/**
+ * signTransactionWithSigner signs a single transaction with the given signer.
+ *
+ * @remarks
+ * This is the replacement for the deprecated {@link signTransaction}, which can
+ * only sign with a raw ed25519 secret key. Because a `TransactionSigner` signs
+ * a group, the transaction is passed as a one-element group and the single
+ * result is returned.
+ *
+ * The decoded `stxn` is returned alongside the blob so callers can read what
+ * the signer produced — its `sig`, `pqsig` or `msig` field, and the `sgnr` field
+ * naming the key that signed when it is not the transaction sender.
+ *
+ * @param txn - the transaction to sign
+ * @param signer - the signer to sign with
+ * @returns an object with blob, txID and stxn properties
+ */
 export declare function signTransactionWithSigner(txn: Transaction, signer: TransactionSigner): Promise<ReturnType<typeof signTransaction> & {
     stxn: SignedTransaction;
 }>;

package/dist/types/transaction.d.ts

@@ -93,6 +93,7 @@ export interface HeartbeatTransactionFields {
     readonly seed: Uint8Array;
     readonly voteID: Uint8Array;
     readonly keyDilution: bigint;
+    readonly challengeDiscount: boolean;
 }
 /**
  * Transaction enables construction of Algorand transactions

package/dist/types/types/block.d.ts

@@ -49,9 +49,14 @@ export declare class TxnCommitments implements Encodable {
      * Root of transaction vector commitment merkle tree using SHA256 hash function
      */
     sha256Commitment: Uint8Array;
+    /**
+     * Root of transaction vector commitment merkle tree using SHA512 hash function
+     */
+    sha512Commitment: Uint8Array;
     constructor(params: {
         nativeSha512_256Commitment: Uint8Array;
         sha256Commitment: Uint8Array;
+        sha512Commitment?: Uint8Array;
     });
     getEncodingSchema(): Schema;
     toEncodingData(): Map<string, unknown>;
@@ -196,6 +201,10 @@ export declare class BlockHeader implements Encodable {
      * Previous block hash
      */
     branch: Uint8Array;
+    /**
+     * Previous block hash, using SHA-512
+     */
+    branch512: Uint8Array;
     /**
      * Sortition seed
      */
@@ -249,9 +258,20 @@ export declare class BlockHeader implements Encodable {
      */
     stateproofTracking: Map<number, StateProofTrackingData>;
     participationUpdates: ParticipationUpdates;
+    /**
+     * Load is the degree to which a block is full. Currently, it is based on the number of bytes in
+     * the final block, compared to the maximum allowed. It is expressed as a fixed-point integer with
+     * 6 digits of precision. So, 1,000,000 is a completely full block.
+     */
+    load: bigint;
+    /**
+     * CongestionTax is the fee required, beyond the MinFee, for "normal" transactions in this block.
+     */
+    congestionTax: bigint;
     constructor(params: {
         round: bigint;
         branch: Uint8Array;
+        branch512?: Uint8Array;
         seed: Uint8Array;
         txnCommitments: TxnCommitments;
         timestamp: bigint;
@@ -267,6 +287,8 @@ export declare class BlockHeader implements Encodable {
         txnCounter: bigint;
         stateproofTracking: Map<number, StateProofTrackingData>;
         participationUpdates: ParticipationUpdates;
+        load?: bigint;
+        congestionTax?: bigint;
     });
     getEncodingSchema(): Schema;
     toEncodingData(): Map<string, unknown>;

package/dist/types/types/statedelta.d.ts

@@ -48,6 +48,20 @@ export declare class AppParams implements Encodable {
     localStateSchema: StateSchema;
     globalStateSchema: StateSchema;
     extraProgramPages: number;
+    version: bigint;
+    /**
+     * If non-zero, the account that must hold MBR for extra program pages and the
+     * global schema.
+     */
+    sizeSponsor: Address;
+    /**
+     * When true, any app may read this app's boxes.
+     */
+    foreignBoxReads: boolean;
+    /**
+     * When true, apps with the same creator may read and write this app's boxes.
+     */
+    familyBoxAccess: boolean;
     constructor(params: {
         approvalProgram: Uint8Array;
         clearStateProgram: Uint8Array;
@@ -55,6 +69,10 @@ export declare class AppParams implements Encodable {
         localStateSchema: StateSchema;
         globalStateSchema: StateSchema;
         extraProgramPages: number;
+        version?: bigint;
+        sizeSponsor?: Address;
+        foreignBoxReads?: boolean;
+        familyBoxAccess?: boolean;
     });
     getEncodingSchema(): Schema;
     toEncodingData(): Map<string, unknown>;

package/dist/types/types/transactions/base.d.ts

@@ -473,6 +473,16 @@ export interface HeartbeatTransactionParams {
      * Must match hbAddress account's current KeyDilution.
      */
     keyDilution: bigint;
+    /**
+     * Requests the challenge fee discount: when set, the required fee is reduced
+     * by one min fee. The network verifies that hbAddress is actually under
+     * challenge before granting it, and a heartbeat claiming the discount may not
+     * carry any extra fields (note, lease, group, etc.).
+     *
+     * Only allowed once transaction size pricing is enabled. Before that, the
+     * discount was inferred from an underpaid singleton heartbeat instead.
+     */
+    challengeDiscount?: boolean;
 }
 /**
  * A full list of all available transaction parameters

package/dist/types/utils/utils.d.ts

@@ -55,3 +55,4 @@ export declare function ensureSafeInteger(value: unknown): number;
 export declare function ensureSafeUnsignedInteger(value: unknown): number;
 export declare function ensureBigInt(value: unknown): bigint;
 export declare function ensureUint64(value: unknown): bigint;
+export declare function isEmptyObject(obj: any): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "3.7.0-beta.1",
+  "version": "3.8.0",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -75,7 +75,7 @@
     "eslint-plugin-import": "^2.25.2",
     "eslint-plugin-tsdoc": "^0.2.11",
     "express": "^4.19.2",
-    "falcon-1024": "1.0.0-beta.2",
+    "@algorandfoundation/falcon-wasm": "1.0.0",
     "geckodriver": "^4.3.0",
     "husky": "^4.3.8",
     "lint-staged": "^10.5.4",

package/src/appAccess.ts

@@ -113,7 +113,12 @@ export function resourceReferencesToEncodingData(
           ],
         ])
       );
+      continue;
     }
+
+    // A reference that names no resource encodes as an empty ResourceRef, which
+    // the network reads as a request for a box I/O quota bump.
+    accessList.push(new Map<string, unknown>());
   }
   return accessList;
 }