algosdk 2.9.0 → 3.0.0-beta.1

package/dist/types/multisig.d.ts

@@ -1,125 +1,54 @@
-import * as txnBuilder from './transaction';
-import { EncodedTransaction } from './types/transactions';
-import { MultisigMetadata } from './types/multisig';
-import { EncodedMultisig } from './types/transactions/encoded';
+import { Address } from './encoding/address.js';
+import { EncodedMultisig } from './types/transactions/encoded.js';
 /**
  Utilities for manipulating multisig transaction blobs.
  */
-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";
-export declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
-export declare const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
-export declare const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
-export declare const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
-export declare const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
-interface MultisigMetadataWithPks extends Omit<MultisigMetadata, 'addrs'> {
-    pks: Uint8Array[];
-}
-/**
- * createMultisigTransaction creates a raw, unsigned multisig transaction blob.
- * @param txn - the actual transaction.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param pks - ordered list of public keys in this multisig
- * @returns encoded multisig blob
- */
-export declare function createMultisigTransaction(txn: txnBuilder.Transaction, { version, threshold, addrs }: MultisigMetadata): Uint8Array;
 /**
- * MultisigTransaction is a Transaction that also supports creating partially-signed multisig transactions.
+ * Required options for creating a multisignature
+ *
+ * Documentation available at: https://developer.algorand.org/docs/get-details/transactions/signatures/#multisignatures
  */
-export declare class MultisigTransaction extends txnBuilder.Transaction {
-    /**
-     * Override inherited method to throw an error, as mutating transactions are prohibited in this context
-     */
-    addLease(): void;
-    /**
-     * Override inherited method to throw an error, as mutating transactions are prohibited in this context
-     */
-    addRekey(): void;
+export interface MultisigMetadata {
     /**
-     * Override inherited method to throw an error, as traditional signing is not allowed
+     * Multisig version
      */
-    signTxn(sk: Uint8Array): Uint8Array;
+    version: number;
     /**
-     * partialSignTxn partially signs this transaction and returns a partially-signed multisig transaction,
-     * encoded with msgpack as a typed array.
-     * @param version - multisig version
-     * @param threshold - multisig threshold
-     * @param pks - multisig public key list, order is important.
-     * @param sk - an Algorand secret key to sign with.
-     * @returns an encoded, partially signed multisig transaction.
+     * Multisig threshold value. Authorization requires a subset of signatures,
+     * equal to or greater than the threshold value.
      */
-    partialSignTxn({ version, threshold, pks }: MultisigMetadataWithPks, sk: Uint8Array): Uint8Array;
+    threshold: number;
     /**
-     * partialSignWithMultisigSignature partially signs this transaction with an external raw multisig signature and returns
-     * a partially-signed multisig transaction, encoded with msgpack as a typed array.
-     * @param metadata - multisig metadata
-     * @param signerAddr - address of the signer
-     * @param signature - raw multisig signature
-     * @returns an encoded, partially signed multisig transaction.
+     * A list of Algorand addresses representing possible signers for this multisig. Order is important.
      */
-    partialSignWithMultisigSignature(metadata: MultisigMetadataWithPks, signerAddr: string, signature: Uint8Array): Uint8Array;
-    static from_obj_for_encoding(txnForEnc: EncodedTransaction): MultisigTransaction;
+    addrs: Array<string | Address>;
 }
+export declare function pksFromAddresses(addrs: Array<string | Address>): Uint8Array[];
 /**
- * mergeMultisigTransactions takes a list of multisig transaction blobs, and merges them.
- * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
- * @returns typed array msg-pack encoded multisig txn
- */
-export declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
-export declare function verifyMultisig(toBeVerified: Uint8Array, msig: EncodedMultisig, publicKey: Uint8Array): boolean;
-/**
- * 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.
- * @param txn - object with either payment or key registration fields
+ * fromMultisigPreImg takes multisig parameters and returns a 32 byte typed array public key,
+ * representing an address that identifies the "exact group, version, and public keys" that are required for signing.
+ * Hash("MultisigAddr" || version uint8 || threshold uint8 || PK1 || PK2 || ...)
+ * Encoding this output yields a human readable address.
  * @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 sk - Algorand secret key. The corresponding pk should be in the pre image.
- * @returns object containing txID, and blob of partially signed multisig transaction (with multisig preimage information)
- * If the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
+ * @param pks - array of typed array public keys
  */
-export declare function signMultisigTransaction(txn: txnBuilder.TransactionLike, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
-/**
- * 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.
- * @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 sk - Algorand secret key
- * @returns object containing txID, and blob representing encoded multisig txn
- */
-export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
+export declare function addressFromMultisigPreImg({ version, threshold, pks, }: Omit<MultisigMetadata, 'addrs'> & {
+    pks: Uint8Array[];
+}): Address;
 /**
- * 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.
- * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
+ * fromMultisigPreImgAddrs takes multisig parameters and returns a human readable Algorand address.
+ * This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.
  * @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 signerAddr - address of the signer
- * @param signature - raw multisig signature
- * @returns object containing txID, and blob representing encoded multisig txn
+ * @param addrs - array of encoded addresses
  */
-export declare function appendSignRawMultisigSignature(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, signerAddr: string, signature: Uint8Array): {
-    txID: string;
-    blob: Uint8Array;
-};
+export declare function addressFromMultisigPreImgAddrs({ version, threshold, addrs, }: MultisigMetadata): Address;
+export declare function verifyMultisig(toBeVerified: Uint8Array, msig: EncodedMultisig, publicKey: Uint8Array): boolean;
 /**
  * multisigAddress takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
  * @param version - multisig version
  * @param threshold - multisig threshold
  * @param addrs - list of Algorand addresses
  */
-export declare function multisigAddress({ version, threshold, addrs, }: MultisigMetadata): string;
-export {};
+export declare function multisigAddress({ version, threshold, addrs, }: MultisigMetadata): Address;

package/dist/types/multisigSigning.d.ts

@@ -0,0 +1,72 @@
+import { Address } from './encoding/address.js';
+import { Transaction } from './transaction.js';
+import { MultisigMetadata } from './multisig.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";
+export declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
+export declare const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
+export declare const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
+export declare const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
+export declare const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
+/**
+ * createMultisigTransaction creates a raw, unsigned multisig transaction blob.
+ * @param txn - the actual transaction.
+ * @param version - multisig version
+ * @param threshold - multisig threshold
+ * @param pks - ordered list of public keys in this multisig
+ * @returns encoded multisig blob
+ */
+export declare function createMultisigTransaction(txn: Transaction, { version, threshold, addrs }: MultisigMetadata): Uint8Array;
+/**
+ * mergeMultisigTransactions takes a list of multisig transaction blobs, and merges them.
+ * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
+ * @returns typed array msg-pack encoded multisig txn
+ */
+export declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
+/**
+ * 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.
+ * @param txn - object with either payment or key registration fields
+ * @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 sk - Algorand secret key. The corresponding pk should be in the pre image.
+ * @returns object containing txID, and blob of partially signed multisig transaction (with multisig preimage information)
+ * If the final calculated fee is lower than the protocol minimum fee, the fee will be increased to match the minimum.
+ */
+export declare function signMultisigTransaction(txn: Transaction, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};
+/**
+ * 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.
+ * @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 sk - Algorand secret key
+ * @returns object containing txID, and blob representing encoded multisig txn
+ */
+export declare function appendSignMultisigTransaction(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, sk: Uint8Array): {
+    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.
+ * @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 signerAddr - address of the signer
+ * @param signature - raw multisig signature
+ * @returns object containing txID, and blob representing encoded multisig txn
+ */
+export declare function appendSignRawMultisigSignature(multisigTxnBlob: Uint8Array, { version, threshold, addrs }: MultisigMetadata, signerAddr: string | Address, signature: Uint8Array): {
+    txID: string;
+    blob: Uint8Array;
+};

package/dist/types/signedTransaction.d.ts

@@ -0,0 +1,55 @@
+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 { NamedMapSchema } from './encoding/schema/index.js';
+export declare class SignedTransaction implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    /**
+     * The transaction that was signed
+     */
+    readonly txn: Transaction;
+    /**
+     * Transaction signature
+     */
+    readonly sig?: Uint8Array;
+    /**
+     * Multisig structure
+     */
+    readonly msig?: EncodedMultisig;
+    /**
+     * Logic signature
+     */
+    readonly lsig?: LogicSig;
+    /**
+     * The signer, if signing with a different key than the Transaction type `sender` property indicates
+     */
+    readonly sgnr?: Address;
+    constructor({ txn, sig, msig, lsig, sgnr, }: {
+        txn: Transaction;
+        sig?: Uint8Array;
+        msig?: EncodedMultisig;
+        lsig?: LogicSig;
+        sgnr?: Address;
+    });
+    getEncodingSchema(): NamedMapSchema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SignedTransaction;
+}
+/**
+ * decodeSignedTransaction takes a Uint8Array (from transaction.signTxn) and converts it to an object
+ * containing the Transaction (txn), the signature (sig), and the auth-addr field if applicable (sgnr)
+ * @param transactionBuffer - the Uint8Array containing a transaction
+ * @returns containing a Transaction, the signature, and possibly an auth-addr field
+ */
+export declare function decodeSignedTransaction(transactionBuffer: Uint8Array): SignedTransaction;
+/**
+ * encodeUnsignedSimulateTransaction takes a txnBuilder.Transaction object,
+ * converts it into a SignedTransaction-like object, and converts it to a Buffer.
+ *
+ * Note: this function should only be used to simulate unsigned transactions.
+ *
+ * @param txn - Transaction object to simulate.
+ */
+export declare function encodeUnsignedSimulateTransaction(txn: Transaction): Uint8Array;

package/dist/types/signer.d.ts

@@ -1,7 +1,7 @@
-import { Transaction } from './transaction';
-import Account from './types/account';
-import { LogicSigAccount } from './logicsig';
-import { MultisigMetadata } from './types/multisig';
+import Account from './types/account.js';
+import { Transaction } from './transaction.js';
+import { LogicSigAccount } from './logicsig.js';
+import { MultisigMetadata } from './multisig.js';
 /**
  * This type represents a function which can sign transactions from an atomic transaction group.
  * @param txnGroup - The atomic group containing transactions to be signed
@@ -10,7 +10,7 @@ import { MultisigMetadata } from './types/multisig';
  *   array will be the same as the length of indexesToSign, and each index i in the array
  *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
  */
-export declare type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+export type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 /**
  * Create a TransactionSigner that can sign transactions for the provided basic Account.
  */

package/dist/types/signing.d.ts

@@ -0,0 +1,29 @@
+import { Transaction } from './transaction.js';
+import { LogicSig, LogicSigAccount } from './logicsig.js';
+/**
+ * signLogicSigTransactionObject takes a transaction and a LogicSig object and
+ * returns a signed transaction.
+ *
+ * @param txn - The transaction to sign.
+ * @param lsigObject - The LogicSig object that will sign the transaction.
+ *
+ * @returns Object containing txID and blob representing signed transaction.
+ */
+export declare function signLogicSigTransactionObject(txn: Transaction, lsigObject: LogicSig | LogicSigAccount): {
+    txID: string;
+    blob: Uint8Array;
+};
+/**
+ * signLogicSigTransaction takes a transaction and a LogicSig object and returns
+ * a signed transaction.
+ *
+ * @param txn - The transaction to sign.
+ * @param lsigObject - The LogicSig object that will sign the transaction.
+ *
+ * @returns Object containing txID and blob representing signed transaction.
+ * @throws error on failure
+ */
+export declare function signLogicSigTransaction(txn: Transaction, lsigObject: LogicSig | LogicSigAccount): {
+    txID: string;
+    blob: Uint8Array;
+};

package/dist/types/stateproof.d.ts

@@ -0,0 +1,194 @@
+import { Encodable, Schema } from './encoding/encoding.js';
+import { NamedMapSchema } from './encoding/schema/index.js';
+export declare class HashFactory implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    hashType: number;
+    constructor(params: {
+        hashType: number;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): HashFactory;
+}
+export declare class MerkleArrayProof implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    /**
+     * Path is bounded by MaxNumLeavesOnEncodedTree since there could be multiple reveals, and
+     * given the distribution of the elt positions and the depth of the tree, the path length can
+     * increase up to 2^MaxEncodedTreeDepth / 2
+     */
+    path: Uint8Array[];
+    hashFactory: HashFactory;
+    /**
+     * TreeDepth represents the depth of the tree that is being proven. It is the number of edges
+     * from the root to a leaf.
+     */
+    treeDepth: number;
+    constructor(params: {
+        path: Uint8Array[];
+        hashFactory: HashFactory;
+        treeDepth: number;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): MerkleArrayProof;
+}
+/**
+ * MerkleSignatureVerifier is used to verify a merkle signature.
+ */
+export declare class MerkleSignatureVerifier implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    commitment: Uint8Array;
+    keyLifetime: bigint;
+    constructor(params: {
+        commitment: Uint8Array;
+        keyLifetime: bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): MerkleSignatureVerifier;
+}
+/**
+ * A Participant corresponds to an account whose AccountData.Status is Online, and for which the
+ * expected sigRound satisfies AccountData.VoteFirstValid <= sigRound <= AccountData.VoteLastValid.
+ *
+ * In the Algorand ledger, it is possible for multiple accounts to have the same PK. Thus, the PK is
+ * not necessarily unique among Participants. However, each account will produce a unique Participant
+ * struct, to avoid potential DoS attacks where one account claims to have the same VoteID PK as
+ * another account.
+ */
+export declare class Participant implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    /**
+     * pk is the identifier used to verify the signature for a specific participant
+     */
+    pk: MerkleSignatureVerifier;
+    /**
+     * weight is AccountData.MicroAlgos.
+     */
+    weight: bigint;
+    constructor(params: {
+        pk: MerkleSignatureVerifier;
+        weight: bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): Participant;
+}
+export declare class FalconVerifier implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    publicKey: Uint8Array;
+    constructor(params: {
+        publicKey: Uint8Array;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): FalconVerifier;
+}
+/**
+ * FalconSignatureStruct represents a signature in the merkle signature scheme using falcon signatures
+ * as an underlying crypto scheme. It consists of an ephemeral public key, a signature, a merkle
+ * verification path and an index. The merkle signature considered valid only if the Signature is
+ * verified under the ephemeral public key and the Merkle verification path verifies that the
+ * ephemeral public key is located at the given index of the tree (for the root given in the
+ * long-term public key). More details can be found on Algorand's spec
+ */
+export declare class FalconSignatureStruct implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    signature: Uint8Array;
+    vectorCommitmentIndex: bigint;
+    proof: MerkleArrayProof;
+    verifyingKey: FalconVerifier;
+    constructor(params: {
+        signature: Uint8Array;
+        index: bigint;
+        proof: MerkleArrayProof;
+        verifyingKey: FalconVerifier;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): FalconSignatureStruct;
+}
+/**
+ * A SigslotCommit is a single slot in the sigs array that forms the state proof.
+ */
+export declare class SigslotCommit implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    /**
+     * Sig is a signature by the participant on the expected message.
+     */
+    sig: FalconSignatureStruct;
+    /**
+     * L is the total weight of signatures in lower-numbered slots. This is initialized once the builder
+     * has collected a sufficient number of signatures.
+     */
+    l: bigint;
+    constructor(params: {
+        sig: FalconSignatureStruct;
+        l: bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): SigslotCommit;
+}
+/**
+ * Reveal is a single array position revealed as part of a state proof. It reveals an element of the
+ * signature array and the corresponding element of the participants array.
+ */
+export declare class Reveal implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    sigslot: SigslotCommit;
+    participant: Participant;
+    constructor(params: {
+        sigslot: SigslotCommit;
+        participant: Participant;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): Reveal;
+}
+export declare class StateProof implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    sigCommit: Uint8Array;
+    signedWeight: bigint;
+    sigProofs: MerkleArrayProof;
+    partProofs: MerkleArrayProof;
+    merkleSignatureSaltVersion: number;
+    /**
+     * Reveals is a sparse map from the position being revealed to the corresponding elements from the
+     * sigs and participants arrays.
+     */
+    reveals: Map<bigint, Reveal>;
+    positionsToReveal: bigint[];
+    constructor(params: {
+        sigCommit: Uint8Array;
+        signedWeight: bigint;
+        sigProofs: MerkleArrayProof;
+        partProofs: MerkleArrayProof;
+        merkleSignatureSaltVersion: number;
+        reveals: Map<bigint, Reveal>;
+        positionsToReveal: bigint[];
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): StateProof;
+}
+export declare class StateProofMessage implements Encodable {
+    static readonly encodingSchema: NamedMapSchema;
+    blockHeadersCommitment: Uint8Array;
+    votersCommitment: Uint8Array;
+    lnProvenWeight: bigint;
+    firstAttestedRound: bigint;
+    lastAttestedRound: bigint;
+    constructor(params: {
+        blockHeadersCommitment: Uint8Array;
+        votersCommitment: Uint8Array;
+        lnProvenWeight: bigint;
+        firstAttestedRound: bigint;
+        lastAttestedRound: bigint;
+    });
+    getEncodingSchema(): Schema;
+    toEncodingData(): Map<string, unknown>;
+    static fromEncodingData(data: unknown): StateProofMessage;
+    static fromMap(data: Map<string, unknown>): StateProofMessage;
+}