algosdk 3.6.0 → 3.7.0-beta.1

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

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,34 @@ 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;
+}
+/** 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

@@ -129,7 +129,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/transactions/encoded.d.ts

@@ -33,3 +33,30 @@ export interface EncodedMultisig {
 export declare const ENCODED_MULTISIG_SCHEMA: NamedMapSchema;
 export declare function encodedMultiSigFromEncodingData(data: unknown): EncodedMultisig;
 export declare function encodedMultiSigToEncodingData(msig: EncodedMultisig): Map<string, unknown>;
+/**
+ * A structure for the encoded post-quantum signature transaction authorization
+ * proof. Mirrors the `PQSig` struct from go-algorand.
+ */
+export interface EncodedPQSig {
+    /**
+     * The 2-byte identifier of the post-quantum signature scheme (e.g. "f1"
+     * for Falcon-1024).
+     */
+    sch: Uint8Array;
+    /**
+     * The 1-byte salt used when deriving the post-quantum account address from the
+     * public key.
+     */
+    slt: number;
+    /**
+     * The post-quantum public key.
+     */
+    pk: Uint8Array;
+    /**
+     * The post-quantum signature over the transaction.
+     */
+    sig: Uint8Array;
+}
+export declare const ENCODED_PQSIG_SCHEMA: NamedMapSchema;
+export declare function encodedPQSigFromEncodingData(data: unknown): EncodedPQSig;
+export declare function encodedPQSigToEncodingData(pqsig: EncodedPQSig): Map<string, unknown>;

package/dist/types/utils/ed25519-check.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Report whether the given bytes decode to an Edwards25519 curve point.
+ *
+ * This over-approximates whatever the verifier's decoder accepts: small-order
+ * points and non-canonical encodings (such as y == p) count as curve points,
+ * matching decoders like filippo.io/edwards25519. Over-approximating is the
+ * safe direction here, because the only caller uses this to *reject* candidate
+ * post-quantum addresses that an Ed25519 key could also occupy.
+ */
+export declare function couldBeCurvePoint(keyBytes: Uint8Array): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "algosdk",
-  "version": "3.6.0",
+  "version": "3.7.0-beta.1",
   "description": "The official JavaScript SDK for Algorand",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -75,6 +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",
     "geckodriver": "^4.3.0",
     "husky": "^4.3.8",
     "lint-staged": "^10.5.4",

package/src/client/v2/algod/algod.ts

@@ -7,7 +7,6 @@ import AccountApplicationsInformation from './accountApplicationsInformation.js'
 import AccountApplicationInformation from './accountApplicationInformation.js';
 import Block from './block.js';
 import Compile from './compile.js';
-import Dryrun from './dryrun.js';
 import Genesis from './genesis.js';
 import GetAssetByID from './getAssetByID.js';
 import GetApplicationByID from './getApplicationByID.js';
@@ -460,24 +459,6 @@ export class AlgodClient extends ServiceClient {
     return new Disassemble(this.c, source);
   }
 
-  /**
-   * Provides debugging information for a transaction (or group).
-   *
-   * Executes TEAL program(s) in context and returns debugging information about the execution. This endpoint is only enabled when a node's configureation file sets `EnableDeveloperAPI` to true.
-   *
-   * #### Example
-   * ```typescript
-   * const dryRunResult = await algodClient.dryrun(dr).do();
-   * ```
-   *
-   * [Response data schema details](https://developer.algorand.org/docs/rest-apis/algod/#post-v2tealdryrun)
-   * @param dr
-   * @category POST
-   */
-  dryrun(dr: modelsv2.DryrunRequest) {
-    return new Dryrun(this.c, dr);
-  }
-
   /**
    * Given an asset ID, return asset information including creator, name, total supply and
    * special addresses.