algosdk 3.6.0 → 3.7.0

package/dist/types/ed25519-signer.d.ts

@@ -0,0 +1,7 @@
+import { Address } from './encoding/address.js';
+import { AddressWithDelegatedLsigSigner, AddressWithMxBytesSigner, AddressWithProgramDataSigner, AddressWithTransactionSigner } from './signer.js';
+export interface Ed25519SigningKey {
+    ed25519PublicKey: Uint8Array;
+    ed25519Signer: (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+}
+export declare function addressWithSignersFromRawEd25519Signer(ed25519SigningKey: Ed25519SigningKey, sendingAddress?: Address): AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithMxBytesSigner & AddressWithProgramDataSigner;

package/dist/types/encoding/address.d.ts

@@ -1,9 +1,19 @@
+import type { EncodedPQSig } from '../types/transactions/encoded.js';
 export declare const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
 export declare const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
 export declare const ALGORAND_ADDRESS_LENGTH = 58;
 export declare const ALGORAND_ZERO_ADDRESS_STRING = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ";
 export declare const MALFORMED_ADDRESS_ERROR_MSG = "address seems to be malformed";
 export declare const CHECKSUM_ADDRESS_ERROR_MSG = "wrong checksum for address";
+/**
+ * The required byte length of a post-quantum signature scheme identifier.
+ */
+export declare const PQ_SCHEME_SIZE = 2;
+/**
+ * The largest value a post-quantum address salt may take. The salt occupies a
+ * single byte of the address preimage.
+ */
+export declare const PQ_SALT_MAX = 255;
 /**
  * Represents an Algorand address
  */
@@ -64,3 +74,30 @@ export declare function encodeAddress(address: Uint8Array): string;
  * @returns The address corresponding to that application's escrow account.
  */
 export declare function getApplicationAddress(appID: number | bigint): Address;
+/**
+ * Derive a post-quantum (PQ) account address together with the canonical salt
+ * used to derive it.
+ *
+ * @param schemeBytes - The 2-byte ASCII PQ scheme identifier (e.g. "f1" for Falcon-1024).
+ * @param key - The scheme's canonical public key.
+ * @returns The derived Address and the canonical 1-byte salt.
+ */
+export declare function addressFromPQKey(schemeBytes: Uint8Array, key: Uint8Array): {
+    address: Address;
+    salt: number;
+};
+/**
+ * Derive the account address that a post-quantum signature authorizes.
+ *
+ * Unlike an Ed25519 signature, a PQ signature carries the scheme, salt and
+ * public key of the signing account, so the address it authorizes is fully
+ * determined by the signature and does not have to be supplied out of band.
+ *
+ * This also validates the signature's self-consistency: the salt must be the
+ * canonical one for the given scheme and public key, which is what the network
+ * requires.
+ *
+ * @param pqsig - The post-quantum signature to derive the address from.
+ * @returns The address of the account the signature authorizes.
+ */
+export declare function addressFromPQSig(pqsig: EncodedPQSig): Address;

package/dist/types/falcon-signer.d.ts

@@ -0,0 +1,11 @@
+import { Address } from './encoding/address.js';
+import { AddressWithDelegatedLsigSigner, AddressWithEmptyTransactionSigner, AddressWithTransactionSigner } from './signer.js';
+/**
+ * The 2-byte ASCII identifier of the Falcon-1024 post-quantum signature scheme.
+ */
+export declare const FALCON_1024_SCHEME: Uint8Array;
+export interface Falcon1024SigningKey {
+    falcon1024PublicKey: Uint8Array;
+    falcon1024Signer: (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+}
+export declare function addressWithSignersFromRawFalcon1024Signer(falconSigningKey: Falcon1024SigningKey, sendingAddress?: Address): AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithEmptyTransactionSigner;

package/dist/types/heartbeat.d.ts

@@ -26,12 +26,14 @@ export declare class Heartbeat implements Encodable {
     seed: Uint8Array;
     voteID: Uint8Array;
     keyDilution: bigint;
+    challengeDiscount: boolean;
     constructor(params: {
         address: Address;
         proof: HeartbeatProof;
         seed: Uint8Array;
         voteID: Uint8Array;
         keyDilution: bigint;
+        challengeDiscount?: boolean;
     });
     getEncodingSchema(): Schema;
     toEncodingData(): Map<string, unknown>;

package/dist/types/logicsig.d.ts

@@ -2,13 +2,17 @@ import { Address } from './encoding/address.js';
 import * as encoding from './encoding/encoding.js';
 import { NamedMapSchema } from './encoding/schema/index.js';
 import { MultisigMetadata } from './multisig.js';
-import { EncodedMultisig } from './types/transactions/encoded.js';
+import { EncodedMultisig, EncodedPQSig } from './types/transactions/encoded.js';
+import type { DelegatedLsigSigner, ProgramDataSigner } from './signer.js';
 /** sanityCheckProgram performs heuristic program validation:
  * check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes
  *
  * @param program - Program bytes to check
  */
 export declare function sanityCheckProgram(program: Uint8Array): void;
+export declare const PROGRAM_TAG: Uint8Array;
+export declare const PQ_PROGRAM_TAG: Uint8Array;
+export declare const MSIG_PROGRAM_TAG: Uint8Array;
 /**
  LogicSig implementation
 
@@ -21,11 +25,15 @@ export declare class LogicSig implements encoding.Encodable {
     sig?: Uint8Array;
     msig?: EncodedMultisig;
     lmsig?: EncodedMultisig;
+    pqsig?: EncodedPQSig;
     constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null);
     getEncodingSchema(): encoding.Schema;
     toEncodingData(): Map<string, unknown>;
     static fromEncodingData(data: unknown): LogicSig;
     /**
+     * @deprecated This function does not perform full verification and should not be fully trusted on its own.
+     * For example, it does not evaluate programs and does not have the ability to validate PQ signatures.
+     *
      * Performs signature verification
      * @param publicKey - Verification key (derived from sender address or escrow address)
      */
@@ -36,21 +44,64 @@ export declare class LogicSig implements encoding.Encodable {
      */
     address(): Address;
     /**
+     * @deprecated Use `signWithSigner` instead
+     *
      * Creates signature (if no msig provided) or multi signature otherwise
      * @param secretKey - Secret key to sign with
      * @param msig - Multisig account as \{version, threshold, addrs\}
      */
     sign(secretKey: Uint8Array, msig?: MultisigMetadata): void;
     /**
+     * Signs this LogicSig for delegation using the given signer.
+     *
+     * @param signer - The signer to delegate to
+     * @param msig - Optional multisig account the signer is a subsigner of
+     * @returns The address the signer signed as. When `msig` is omitted this is
+     *   the delegating account. When `msig` is given it is the individual
+     *   subsigner, not the multisig, so the delegating account is
+     *   `multisigAddress(msig)`. Either way it is an authorizing address, which
+     *   is not necessarily the address a signer sends transactions from.
+     *
+     * Re-signing an already-signed LogicSig is allowed, and replaces the previous
+     * delegation signature. At most one of `sig`, `msig`, `lmsig` and `pqsig` may
+     * be set, so any signature left over from an earlier call is cleared.
+     */
+    signWithSigner(signer: DelegatedLsigSigner, msig?: MultisigMetadata): Promise<Address>;
+    /**
+     * Removes every delegation signature from this LogicSig, so that exactly one
+     * of them can be set afterwards.
+     */
+    private clearSignatures;
+    /**
+     * @deprecated Use `appendToMultisigWithSigner` instead
+     *
      * Appends a signature to multi signature
      * @param secretKey - Secret key to sign with
      */
     appendToMultisig(secretKey: Uint8Array): void;
+    appendToMultisigWithSigner(signer: DelegatedLsigSigner): Promise<void>;
+    /**
+     * @deprecated Use `signWithSigner` followed by `.sig` instead
+     */
     signProgram(secretKey: Uint8Array): Uint8Array;
+    /**
+     * @deprecated Use `signWithSigner` followed by `.sig` instead
+     */
     signProgramMultisig(secretKey: Uint8Array, msig: EncodedMultisig): Uint8Array;
+    /**
+     * @deprecated Use `signWithSigner` followed by `.sig` instead
+     */
     singleSignMultisig(secretKey: Uint8Array, msig: EncodedMultisig): [sig: Uint8Array, index: number];
     toByte(): Uint8Array;
     static fromByte(encoded: ArrayLike<any>): LogicSig;
+    /**
+     * Signs arbitrary data for use with the `ed25519verify` opcode from within
+     * this LogicSig's program.
+     *
+     * @param signer - The signer to sign the data with
+     * @param data - The data to sign
+     */
+    signDataWithSigner(signer: ProgramDataSigner, data: Uint8Array): Promise<Uint8Array>;
 }
 /**
  * Represents an account that can sign with a LogicSig program.
@@ -90,6 +141,9 @@ export declare class LogicSigAccount implements encoding.Encodable {
      */
     isDelegated(): boolean;
     /**
+     * @deprecated This function does not perform full verification and should not be fully trusted on its own.
+     * For example, it does not evaluate programs and does not have the ability to validate PQ signatures.
+     *
      * Verifies this LogicSig's program and signatures.
      * @returns true if and only if the LogicSig program and signatures are valid.
      */
@@ -105,6 +159,8 @@ export declare class LogicSigAccount implements encoding.Encodable {
      */
     address(): Address;
     /**
+     * @deprecated Use `signMultisigWithSigner` instead
+     *
      * Turns this LogicSigAccount into a delegated LogicSig. This type of LogicSig
      * has the authority to sign transactions on behalf of another account, called
      * the delegating account. Use this function if the delegating account is a
@@ -116,7 +172,10 @@ export declare class LogicSigAccount implements encoding.Encodable {
      *   from other members.
      */
     signMultisig(msig: MultisigMetadata, secretKey: Uint8Array): void;
+    signMultisigWithSigner(msig: MultisigMetadata, signer: DelegatedLsigSigner): Promise<void>;
     /**
+     * @deprecated Use appendToMultisigWithSigner
+     *
      * Adds an additional signature from a member of the delegating multisig
      * account.
      *
@@ -124,7 +183,10 @@ export declare class LogicSigAccount implements encoding.Encodable {
      *   multisig account.
      */
     appendToMultisig(secretKey: Uint8Array): void;
+    appendToMultisigWithSigner(signer: DelegatedLsigSigner): Promise<void>;
     /**
+     * @deprecated Use `signWithSigner` instead
+     *
      * Turns this LogicSigAccount into a delegated LogicSig. This type of LogicSig
      * has the authority to sign transactions on behalf of another account, called
      * the delegating account. If the delegating account is a multisig account,
@@ -133,12 +195,21 @@ export declare class LogicSigAccount implements encoding.Encodable {
      * @param secretKey - The secret key of the delegating account.
      */
     sign(secretKey: Uint8Array): void;
+    /**
+     * Turns this LogicSigAccount into a delegated LogicSig, signed by the given
+     * signer. If the delegating account is a multisig account, use
+     * `signMultisigWithSigner` instead.
+     *
+     * @param signer - The signer of the delegating account.
+     */
+    signWithSigner(signer: DelegatedLsigSigner): Promise<void>;
 }
 /**
  * logicSigFromByte accepts encoded logic sig bytes and attempts to call logicsig.fromByte on it,
  * returning the result
  */
 export declare function logicSigFromByte(encoded: Uint8Array): LogicSig;
+export declare const SIGN_PROGRAM_DATA_PREFIX: Uint8Array;
 /**
  * tealSign creates a signature compatible with ed25519verify opcode from program hash
  * @param sk - Uint8Array with secret key

package/dist/types/main.d.ts

@@ -1,42 +1,4 @@
-import { Address } from './encoding/address.js';
-import { Transaction } from './transaction.js';
 export declare const MULTISIG_BAD_SENDER_ERROR_MSG = "The transaction sender address and multisig preimage do not match.";
-/**
- * signTransaction takes an object with either payment or key registration fields and
- * a secret key and returns a signed blob.
- *
- * Payment transaction fields: from, to, amount, fee, firstValid, lastValid, genesisHash,
- * note(optional), GenesisID(optional), closeRemainderTo(optional)
- *
- * Key registration fields: fee, firstValid, lastValid, voteKey, selectionKey, voteFirst,
- * voteLast, voteKeyDilution, genesisHash, note(optional), GenesisID(optional)
- *
- * If flatFee is not set and the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
- * @param txn - object with either payment or key registration fields
- * @param sk - Algorand Secret Key
- * @returns object contains the binary signed transaction and its txID
- */
-export declare function signTransaction(txn: Transaction, sk: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
-/**
- * signBytes takes arbitrary bytes and a secret key, prepends the bytes with "MX" for domain separation, signs the bytes
- * with the private key, and returns the signature.
- * @param bytes - Uint8array
- * @param sk - Algorand secret key
- * @returns binary signature
- */
-export declare function signBytes(bytes: Uint8Array, sk: Uint8Array): Uint8Array;
-/**
- * verifyBytes takes array of bytes, an address, and a signature and verifies if the signature is correct for the public
- * key and the bytes (the bytes should have been signed with "MX" prepended for domain separation).
- * @param bytes - Uint8Array
- * @param signature - binary signature
- * @param addr - string address
- * @returns bool
- */
-export declare function verifyBytes(bytes: Uint8Array, signature: Uint8Array, addr: string | Address): boolean;
 export declare const ERROR_MULTISIG_BAD_SENDER: Error;
 export declare const ERROR_INVALID_MICROALGOS: Error;
 export { AlgodClient as Algodv2 } from './client/v2/algod/algod.js';
@@ -48,7 +10,7 @@ export { BaseHTTPClient, BaseHTTPClientResponse, BaseHTTPClientError, } from './
 export { AlgodTokenHeader, IndexerTokenHeader, KMDTokenHeader, CustomTokenHeader, TokenHeader, } from './client/urlTokenBaseHTTPClient.js';
 export { waitForConfirmation } from './wait.js';
 export { MsgpackEncodingData, JSONEncodingData, Encodable, EncodableClass, encodeObj, decodeObj, msgpackRawEncode, msgpackRawDecode, msgpackRawDecodeAsMap, encodeMsgpack, decodeMsgpack, encodeJSON, decodeJSON, } from './encoding/encoding.js';
-export { Address, isValidAddress, encodeAddress, decodeAddress, getApplicationAddress, ALGORAND_ZERO_ADDRESS_STRING, } from './encoding/address.js';
+export { Address, isValidAddress, encodeAddress, decodeAddress, getApplicationAddress, addressFromPQKey, addressFromPQSig, PQ_SCHEME_SIZE, PQ_SALT_MAX, ALGORAND_ZERO_ADDRESS_STRING, } from './encoding/address.js';
 export { bytesToBigInt, bigIntToBytes } from './encoding/bigint.js';
 export { base64ToBytes, bytesToBase64, bytesToString, coerceToBytes, bytesToHex, hexToBytes, } from './encoding/binarydata.js';
 export { encodeUint64, decodeUint64 } from './encoding/uint64.js';
@@ -60,16 +22,18 @@ export * from './stateproof.js';
 export { UntypedValue } from './client/v2/untypedmodel.js';
 export * as modelsv2 from './client/v2/algod/models/types.js';
 export * as indexerModels from './client/v2/indexer/models/types.js';
-export { mnemonicToMasterDerivationKey, masterDerivationKeyToMnemonic, secretKeyToMnemonic, mnemonicToSecretKey, seedFromMnemonic, mnemonicFromSeed, } from './mnemonic/mnemonic.js';
+export { mnemonicToMasterDerivationKey, masterDerivationKeyToMnemonic, secretKeyToMnemonic, mnemonicToSecretKey, seedFromMnemonic, mnemonicFromSeed, pq25WordMnemonicToSeed, } from './mnemonic/mnemonic.js';
 export { microalgosToAlgos, algosToMicroalgos, INVALID_MICROALGOS_ERROR_MSG, } from './convert.js';
 export { computeGroupID, assignGroupID } from './group.js';
 export { SignedTransaction, decodeSignedTransaction, encodeUnsignedSimulateTransaction, } from './signedTransaction.js';
-export { signLogicSigTransaction, signLogicSigTransactionObject, } from './signing.js';
-export { LogicSig, LogicSigAccount, logicSigFromByte, tealSign, tealSignFromProgram, verifyTealSign, } from './logicsig.js';
+export { SIGN_BYTES_PREFIX, signTransaction, signTransactionWithSigner, signBytes, verifyBytes, signLogicSigTransaction, signLogicSigTransactionObject, } from './signing.js';
+export { LogicSig, LogicSigAccount, logicSigFromByte, tealSign, tealSignFromProgram, verifyTealSign, PROGRAM_TAG, PQ_PROGRAM_TAG, MSIG_PROGRAM_TAG, SIGN_PROGRAM_DATA_PREFIX, } from './logicsig.js';
 export { MultisigMetadata, verifyMultisig, multisigAddress, } from './multisig.js';
-export { signMultisigTransaction, mergeMultisigTransactions, appendSignMultisigTransaction, createMultisigTransaction, appendSignRawMultisigSignature, } from './multisigSigning.js';
+export { signMultisigTransaction, mergeMultisigTransactions, appendSignMultisigTransaction, createMultisigTransaction, appendSignRawMultisigSignature, signMultisigTransactionWithSigner, appendSignMultisigTransactionWithSigner, } from './multisigSigning.js';
 export { ProgramSourceMap, SourceLocation, PcLineLocation, } from './logic/sourcemap.js';
-export * from './dryrun.js';
+export { Ed25519SigningKey, addressWithSignersFromRawEd25519Signer, } from './ed25519-signer.js';
+export { FALCON_1024_SCHEME, Falcon1024SigningKey, addressWithSignersFromRawFalcon1024Signer, } from './falcon-signer.js';
+export { PQSigningKey, addressWithSignersFromRawPQSigner, } from './pq-signer.js';
 export * from './makeTxn.js';
 export * from './transaction.js';
 export * from './signer.js';

package/dist/types/makeTxn.d.ts

@@ -128,11 +128,17 @@ export declare function makeApplicationCallTxnFromObject({ sender, appIndex, onC
  */
 export declare function makeApplicationCreateTxnFromObject({ sender, onComplete, appArgs, accounts, foreignApps, foreignAssets, boxes, convertToAccess, holdings, locals, access, approvalProgram, clearProgram, numLocalInts, numLocalByteSlices, numGlobalInts, numGlobalByteSlices, extraPages, note, lease, rekeyTo, suggestedParams, }: Omit<ApplicationCallTransactionParams, 'appIndex' | 'approvalProgram' | 'clearProgram'> & Required<Pick<ApplicationCallTransactionParams, 'approvalProgram' | 'clearProgram'>> & CommonTransactionParams & ApplicationCallReferenceParams): Transaction;
 /**
- * Make a transaction that changes an application's approval and clear programs
+ * Make a transaction that changes an application's approval and clear programs.
+ *
+ * The application's global state schema and extra program pages may also be changed during an
+ * update by providing numGlobalInts, numGlobalByteSlices, and/or extraPages. The local state schema
+ * cannot be changed after application creation. If the pages or global schema increases in size, the entire
+ * MBR for the application will move to the sender of the update and that account will become the `sizeSponsor`
+ * in the application's parameters. A decrease in schema or pages does not affect MBR or `sizeSponsor`.
  *
  * @param options - Application update transaction parameters
  */
-export declare function makeApplicationUpdateTxnFromObject({ sender, appIndex, appArgs, accounts, foreignApps, foreignAssets, boxes, convertToAccess, holdings, locals, access, approvalProgram, clearProgram, note, lease, rekeyTo, suggestedParams, }: Omit<ApplicationCallTransactionParams, 'onComplete' | 'numLocalInts' | 'numLocalByteSlices' | 'numGlobalInts' | 'numGlobalByteSlices' | 'extraPages' | 'approvalProgram' | 'clearProgram'> & Required<Pick<ApplicationCallTransactionParams, 'approvalProgram' | 'clearProgram'>> & CommonTransactionParams & ApplicationCallReferenceParams): Transaction;
+export declare function makeApplicationUpdateTxnFromObject({ sender, appIndex, appArgs, accounts, foreignApps, foreignAssets, boxes, convertToAccess, holdings, locals, access, approvalProgram, clearProgram, numGlobalInts, numGlobalByteSlices, extraPages, note, lease, rekeyTo, suggestedParams, }: Omit<ApplicationCallTransactionParams, 'onComplete' | 'numLocalInts' | 'numLocalByteSlices' | 'approvalProgram' | 'clearProgram'> & Required<Pick<ApplicationCallTransactionParams, 'approvalProgram' | 'clearProgram'>> & CommonTransactionParams & ApplicationCallReferenceParams): Transaction;
 /**
  * Make a transaction that deletes an application
  *

package/dist/types/mnemonic/mnemonic.d.ts

@@ -41,3 +41,16 @@ export declare function mnemonicToMasterDerivationKey(mn: string): Uint8Array;
  * @returns string mnemonic
  */
 export declare function masterDerivationKeyToMnemonic(mdk: Uint8Array): string;
+/**
+ * pq25WordMnemonicToSeed derives a post-quantum key seed from a standard 25-word
+ * Algorand mnemonic.
+ *
+ * The seed is domain-separated by the PQ scheme, so the same mnemonic yields a
+ * different key for each scheme, and a different key again from the ed25519
+ * account that `mnemonicToSecretKey` derives from it.
+ *
+ * @param mn - A 25-word Algorand mnemonic
+ * @param scheme - The 2-byte ASCII PQ scheme identifier (e.g. "f1" for Falcon-1024)
+ * @returns The 32-byte seed to hand to the scheme's key generator
+ */
+export declare function pq25WordMnemonicToSeed(mn: string, scheme: Uint8Array): Uint8Array;

package/dist/types/multisigSigning.d.ts

@@ -1,6 +1,7 @@
 import { Address } from './encoding/address.js';
 import { Transaction } from './transaction.js';
 import { MultisigMetadata } from './multisig.js';
+import type { TransactionSigner } from './signer.js';
 export declare const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = "Not enough multisig transactions to merge. Need at least two";
 export declare const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
 export declare const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
@@ -25,6 +26,8 @@ export declare function createMultisigTransaction(txn: Transaction, { version, t
  */
 export declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
 /**
+ * @deprecated Use {@link signMultisigTransactionWithSigner} instead
+ *
  * signMultisigTransaction takes a raw transaction (see signTransaction), a multisig preimage, a secret key, and returns
  * a multisig transaction, which is a blob representing a transaction and multisignature account preimage. The returned
  * multisig txn can accumulate additional signatures through mergeMultisigTransactions or appendSignMultisigTransaction.
@@ -41,6 +44,31 @@ export declare function signMultisigTransaction(txn: Transaction, { version, thr
     blob: Uint8Array;
 };
 /**
+ * signMultisigTransactionWithSigner takes a raw transaction, a multisig preimage and a signer, and
+ * returns a multisig transaction: a blob representing a transaction and multisignature account
+ * preimage. The returned multisig txn can accumulate additional signatures through
+ * mergeMultisigTransactions or appendSignMultisigTransactionWithSigner.
+ *
+ * The signer must hold a key belonging to the multisig. That key is taken from the `sgnr` field of
+ * the transaction the signer returns, falling back to the transaction sender when `sgnr` is absent
+ * — which is the same convention signers use when writing it. Every signer this SDK provides
+ * follows it. Note that `AddressWithTransactionSigner.address` cannot be used for this: it is the
+ * address the signer sends transactions from, which for a rekeyed account is not the signing key.
+ *
+ * @param txn - the transaction to sign
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
+ * @param txnSigner - the signer to sign with
+ * @returns an object with txID and blob properties
+ */
+export declare function signMultisigTransactionWithSigner(txn: Transaction, { version, threshold, addrs }: MultisigMetadata, txnSigner: TransactionSigner): Promise<{
+    txID: string;
+    blob: Uint8Array;
+}>;
+/**
+ * @deprecated Use {@link appendSignMultisigTransactionWithSigner} instead
+ *
  * appendSignMultisigTransaction takes a multisig transaction blob, and appends our signature to it.
  * While we could derive public key preimagery from the partially-signed multisig transaction,
  * we ask the caller to pass it back in, to ensure they know what they are signing.
@@ -55,6 +83,27 @@ export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Arra
     txID: string;
     blob: Uint8Array;
 };
+/**
+ * appendSignMultisigTransactionWithSigner takes a multisig transaction blob, and appends the given
+ * signer's signature to it. While we could derive public key preimagery from the partially-signed
+ * multisig transaction, we ask the caller to pass it back in, to ensure they know what they are
+ * signing.
+ *
+ * As with {@link signMultisigTransactionWithSigner}, the signer's key is taken from the `sgnr`
+ * field of the transaction it returns, falling back to the transaction sender when `sgnr` is
+ * absent.
+ *
+ * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
+ * @param txnSigner - the signer to sign with
+ * @returns an object with txID and blob properties
+ */
+export declare function appendSignMultisigTransactionWithSigner(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, txnSigner: TransactionSigner): Promise<{
+    txID: string;
+    blob: Uint8Array;
+}>;
 /**
  * appendMultisigTransactionSignature takes a multisig transaction blob, and appends a given raw signature to it.
  * This makes it possible to compile a multisig signature using only raw signatures from external methods.

package/dist/types/pq-signer.d.ts

@@ -0,0 +1,8 @@
+import { Address } from './encoding/address.js';
+import { AddressWithDelegatedLsigSigner, AddressWithEmptyTransactionSigner, AddressWithTransactionSigner } from './signer.js';
+export interface PQSigningKey {
+    pqScheme: Uint8Array;
+    pqPublicKey: Uint8Array;
+    pqSigner: (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+}
+export declare function addressWithSignersFromRawPQSigner(signingKey: PQSigningKey, sendingAddress?: Address): AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithEmptyTransactionSigner;

package/dist/types/signedTransaction.d.ts

@@ -2,7 +2,7 @@ import { Encodable } from './encoding/encoding.js';
 import { Address } from './encoding/address.js';
 import { Transaction } from './transaction.js';
 import { LogicSig } from './logicsig.js';
-import { EncodedMultisig } from './types/transactions/index.js';
+import { EncodedMultisig, EncodedPQSig } from './types/transactions/index.js';
 import { NamedMapSchema } from './encoding/schema/index.js';
 export declare class SignedTransaction implements Encodable {
     static readonly encodingSchema: NamedMapSchema;
@@ -22,15 +22,20 @@ export declare class SignedTransaction implements Encodable {
      * Logic signature
      */
     readonly lsig?: LogicSig;
+    /**
+     * Post-quantum signature
+     */
+    readonly pqsig?: EncodedPQSig;
     /**
      * The signer, if signing with a different key than the Transaction type `sender` property indicates
      */
     readonly sgnr?: Address;
-    constructor({ txn, sig, msig, lsig, sgnr, }: {
+    constructor({ txn, sig, msig, lsig, pqsig, sgnr, }: {
         txn: Transaction;
         sig?: Uint8Array;
         msig?: EncodedMultisig;
         lsig?: LogicSig;
+        pqsig?: EncodedPQSig;
         sgnr?: Address;
     });
     getEncodingSchema(): NamedMapSchema;

package/dist/types/signer.d.ts

@@ -2,6 +2,16 @@ import Account from './types/account.js';
 import { Transaction } from './transaction.js';
 import { LogicSigAccount } from './logicsig.js';
 import { MultisigMetadata } from './multisig.js';
+import type { Address } from './encoding/address.js';
+import type { EncodedMultisig, EncodedPQSig } from './types/transactions/encoded.js';
+import type { LogicSig } from './logicsig.js';
+/**
+ * Something that has an Algorand address associated with it.
+ * It could be logic sig, single-signer account, multisig, app, etc.
+ */
+export interface Addressable {
+    address: Address;
+}
 /**
  * This type represents a function which can sign transactions from an atomic transaction group.
  * @param txnGroup - The atomic group containing transactions to be signed
@@ -11,6 +21,42 @@ import { MultisigMetadata } from './multisig.js';
  *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
  */
 export type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+export interface AddressWithTransactionSigner extends Addressable {
+    txnSigner: TransactionSigner;
+}
+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;
+}
+/** 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
+ * */
+export type DelegatedLsigSigner = (lsig: LogicSig, msig?: MultisigMetadata) => Promise<{
+    address: Address;
+} & ({
+    sig: Uint8Array;
+} | {
+    lmsig: EncodedMultisig;
+} | {
+    pqsig: EncodedPQSig;
+})>;
+export interface AddressWithDelegatedLsigSigner extends Addressable {
+    delegatedLsigSigner: DelegatedLsigSigner;
+}
+export type MxBytesSigner = (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+export interface AddressWithMxBytesSigner extends Addressable {
+    mxBytesSigner: MxBytesSigner;
+}
+export type ProgramDataSigner = (data: Uint8Array, lsig: LogicSig) => Promise<Uint8Array>;
+export interface AddressWithProgramDataSigner extends Addressable {
+    programDataSigner: ProgramDataSigner;
+}
 /**
  * Create a TransactionSigner that can sign transactions for the provided basic Account.
  */

package/dist/types/signing.d.ts

@@ -1,5 +1,50 @@
+import { Address } from './encoding/address.js';
+import { SignedTransaction } from './signedTransaction.js';
 import { Transaction } from './transaction.js';
 import { LogicSig, LogicSigAccount } from './logicsig.js';
+import type { TransactionSigner } from './signer.js';
+export declare const SIGN_BYTES_PREFIX: Uint8Array;
+/**
+ * @deprecated Use signTransactionWithSigner
+ *
+ * signTransaction takes an object with either payment or key registration fields and
+ * a secret key and returns a signed blob.
+ *
+ * Payment transaction fields: from, to, amount, fee, firstValid, lastValid, genesisHash,
+ * note(optional), GenesisID(optional), closeRemainderTo(optional)
+ *
+ * Key registration fields: fee, firstValid, lastValid, voteKey, selectionKey, voteFirst,
+ * voteLast, voteKeyDilution, genesisHash, note(optional), GenesisID(optional)
+ *
+ * If flatFee is not set and the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
+ * @param txn - object with either payment or key registration fields
+ * @param sk - Algorand Secret Key
+ * @returns object contains the binary signed transaction and its txID
+ */
+export declare function signTransaction(txn: Transaction, sk: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};
+export declare function signTransactionWithSigner(txn: Transaction, signer: TransactionSigner): Promise<ReturnType<typeof signTransaction> & {
+    stxn: SignedTransaction;
+}>;
+/**
+ * signBytes takes arbitrary bytes and a secret key, prepends the bytes with "MX" for domain separation, signs the bytes
+ * with the private key, and returns the signature.
+ * @param bytes - Uint8array
+ * @param sk - Algorand secret key
+ * @returns binary signature
+ */
+export declare function signBytes(bytes: Uint8Array, sk: Uint8Array): Uint8Array;
+/**
+ * verifyBytes takes array of bytes, an address, and a signature and verifies if the signature is correct for the public
+ * key and the bytes (the bytes should have been signed with "MX" prepended for domain separation).
+ * @param bytes - Uint8Array
+ * @param signature - binary signature
+ * @param addr - string address
+ * @returns bool
+ */
+export declare function verifyBytes(bytes: Uint8Array, signature: Uint8Array, addr: string | Address): boolean;
 /**
  * signLogicSigTransactionObject takes a transaction and a LogicSig object and
  * returns a signed transaction.

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
@@ -129,7 +130,16 @@ export declare class Transaction implements encoding.Encodable {
     private estimateSize;
     bytesToSign(): Uint8Array;
     toByte(): Uint8Array;
+    /**
+     * @deprecated Use `(await signTransactionWithSigner(txn, signer)).stxn.sig` instead
+     *
+     * returns the raw signature
+     *
+     */
     rawSignTxn(sk: Uint8Array): Uint8Array;
+    /**
+     * @deprecated Use `await signTransactionWithSigner(txn, signer)`
+     */
     signTxn(sk: Uint8Array): Uint8Array;
     attachSignature(signerAddr: string | Address, signature: Uint8Array): Uint8Array;
     rawTxID(): Uint8Array;

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>;