@sovereign-sdk/multisig 0.3.2 → 0.4.0

package/README.md

@@ -3,7 +3,9 @@
 [![npm version](https://img.shields.io/npm/v/@sovereign-sdk/multisig.svg)](https://www.npmjs.com/package/@sovereign-sdk/multisig)
 [![CI](https://github.com/Sovereign-Labs/sovereign-sdk/actions/workflows/typescript.ci.yml/badge.svg)](https://github.com/Sovereign-Labs/sovereign-sdk/actions/workflows/typescript.ci.yml)
 
-A TypeScript library for creating and managing multisig transactions on Sovereign SDK rollups.
+Payload-agnostic multisig signer state for Sovereign SDK applications.
+
+Use `@sovereign-sdk/multisig` when you want to collect signatures outside the rollup client and finalize them into a standard `TransactionV1` once the threshold is met.
 
 ## Installation
 
@@ -11,119 +13,46 @@ A TypeScript library for creating and managing multisig transactions on Sovereig
 npm install @sovereign-sdk/multisig
 ```
 
-## Features
-
-- **Multisig Transaction Management**: Create and manage transactions requiring multiple signatures
-- **Threshold Signatures**: Configurable minimum signature requirements (M-of-N)
-- **Signature Collection**: Collect signatures from multiple parties before submission
-- **Transaction Conversion**: Convert between V0 (single-sig) and V1 (multisig) transaction formats
-- **Safety Checks**: Validates transaction consistency and prevents replay attacks
-
 ## Usage
 
-### Basic Multisig Workflow
-
 ```typescript
-import { StandardRollup, createStandardRollup } from "@sovereign-sdk/web3";
-import { MultisigTransaction } from "@sovereign-sdk/multisig";
+import { Multisig } from "@sovereign-sdk/multisig";
+import { createStandardRollup } from "@sovereign-sdk/web3";
 import type { UnsignedTransaction } from "@sovereign-sdk/types";
+import { bytesToHex } from "@sovereign-sdk/utils";
+
+const rollup = await createStandardRollup<YourRuntimeCall>();
 
-// 1. Create an unsigned transaction
 const unsignedTx: UnsignedTransaction<YourRuntimeCall> = {
   runtime_call: {
     // Your rollup-specific call data
-    value_setter: { set_value: { value: 100, gas: null } },
   },
-  uniqueness: { nonce: 1 }, // Must be nonce-based for multisig
+  uniqueness: { nonce: 1 },
   details: {
-    max_priority_fee_bips: 100,
+    max_priority_fee_bips: 0,
     max_fee: "1000000",
     gas_limit: null,
-    chain_id: 4321,
+    chain_hash_fragment: "6654161651848106779",
   },
 };
 
-// 2. Initialize multisig with all participant public keys
-const allPubKeys = ["0xpubkey1", "0xpubkey2", "0xpubkey3"];
-const minSigners = 2; // 2-of-3 multisig
+const multisig = Multisig.fromPubKeys(
+  ["pubkey1hex", "pubkey2hex", "pubkey3hex"],
+  2,
+);
 
-const multisig = MultisigTransaction.empty(unsignedTx, minSigners, allPubKeys);
+const signingBytes = await rollup.multisigSigningBytes(unsignedTx, multisig);
+multisig.addSignature(
+  bytesToHex(await signer1.sign(signingBytes)),
+  bytesToHex(await signer1.publicKey()),
+);
 
-// 3. Add signatures as they're collected
-multisig.addSignature("0xsignature1", "0xpubkey1");
-multisig.addSignature("0xsignature2", "0xpubkey2");
+multisig.addSignature(
+  bytesToHex(await signer2.sign(signingBytes)),
+  bytesToHex(await signer2.publicKey()),
+);
 
-// 4. Check if ready for submission
 if (multisig.isComplete) {
-  // Convert to rollup transaction for submission
-  const finalTx = multisig.asTransaction();
-  const rollup = await createStandardRollup();
-  // Submit the transaction to the rollup
-  const result = await rollup.submitTransaction(finalTx);
-  console.log("Multisig transaction submitted", result);
+  await rollup.submitTransaction(multisig.toTransaction(unsignedTx));
 }
 ```
-
-### Creating from Existing Signed Transactions
-
-```typescript
-import { MultisigTransaction } from '@sovereign-sdk/multisig';
-import type { Transaction } from '@sovereign-sdk/types';
-
-// If you have individual V0 transactions from different signers
-const signedTxns: Transaction<YourRuntimeCall>[] = [
-  {
-    V0: {
-      pub_key: "0xpubkey1",
-      signature: "0xsignature1",
-      runtime_call: /* same call data */,
-      uniqueness: { nonce: 1 },
-      details: /* same details */,
-    }
-  },
-  {
-    V0: {
-      pub_key: "0xpubkey2",
-      signature: "0xsignature2",
-      runtime_call: /* same call data */,
-      uniqueness: { nonce: 1 },
-      details: /* same details */,
-    }
-  }
-];
-
-// Create multisig from existing transactions
-const multisig = MultisigTransaction.fromTransactions({
-  txns: signedTxns,
-  minSigners: 2,
-  allPubKeys: ["0xpubkey1", "0xpubkey2", "0xpubkey3"]
-});
-```
-
-### Adding Individual Signed Transactions
-
-```typescript
-// Add a complete signed transaction to the multisig
-const signedTx: Transaction<YourRuntimeCall> = {
-  V0: {
-    pub_key: "0xpubkey3",
-    signature: "0xsignature3",
-    // ... same transaction data
-  },
-};
-
-multisig.addSignedTransaction(signedTx);
-
-// Now check if complete and submit
-if (multisig.isComplete) {
-  const finalTx = multisig.asTransaction();
-  // Submit to rollup...
-}
-```
-
-## Important Notes
-
-- **Nonce-based transactions only**: Multisig currently only supports transactions with `{ nonce: number }` uniqueness
-- **Transaction consistency**: All signatures must be for the exact same unsigned transaction
-- **Public key validation**: Public keys must be known members of the multisig and can only sign once
-

package/dist/index.d.mts

@@ -1,22 +1,12 @@
-import { UnsignedTransaction, SignatureAndPubKey, Transaction } from '@sovereign-sdk/types';
+import { SignatureAndPubKey, UnsignedTransaction, TransactionV1 } from '@sovereign-sdk/types';
 import { HexString } from '@sovereign-sdk/utils';
 
+declare const MAX_SIGNERS = 21;
 /**
  * Base error class for multisig-related errors.
  */
 declare class MultisigError extends Error {
 }
-/**
- * Error thrown when a transaction has an unsupported version for multisig operations.
- */
-declare class InvalidTransactionVersionError extends MultisigError {
-}
-/**
- * Error thrown when a provided transaction doesn't match the expected unsigned transaction.
- */
-declare class TransactionMismatchError extends Error {
-    constructor();
-}
 /**
  * Error thrown when multisig is constructed or used with invalid parameters.
  */
@@ -24,113 +14,33 @@ declare class InvalidMultisigParameterError extends MultisigError {
     constructor(desc: string);
 }
 /**
- * Parameters for constructing a MultisigTransaction.
+ * Parameters for constructing a Multisig.
  */
 type MultisigParams = {
-    /** The unsigned transaction to be signed by multiple parties */
-    unsignedTx: UnsignedTransaction<unknown>;
     /** Array of signatures with pubkeys already collected */
-    signatures: SignatureAndPubKey[];
+    signatures?: SignatureAndPubKey[];
     /** Array of public keys that haven't signed yet */
     unusedPubKeys: HexString[];
     /** Minimum number of signatures required */
     minSigners: number;
 };
 /**
- * Parameters for creating a MultisigTransaction from existing signed transactions.
+ * Represents multisig signer membership and collected signatures.
  */
-type FromTransactionsParams = {
-    /** Array of signed transactions to extract signatures from */
-    txns: Transaction<unknown>[];
-    /** Minimum number of signatures required */
-    minSigners: number;
-    /** All public keys that are members of the multisig */
-    allPubKeys: HexString[];
-};
-/**
- * Represents a multisig transaction that collects signatures from multiple parties.
- * Only supports nonce-based transactions and V0 transaction variants for signature collection.
- */
-declare class MultisigTransaction {
-    private unsignedTx;
+declare class Multisig {
     private signatures;
     private minSigners;
     private unusedPubKeys;
-    /**
-     * Creates a new MultisigTransaction instance.
-     * @param params - The multisig parameters including unsigned transaction, signatures, and public keys
-     */
-    constructor({ unsignedTx, signatures, unusedPubKeys, minSigners, }: MultisigParams);
-    /**
-     * Creates an empty MultisigTransaction with no signatures collected yet.
-     * @param unsignedTx - The unsigned transaction to be signed by multiple parties
-     * @param minSigners - Minimum number of signatures required for completion
-     * @param allPubKeys - All public keys that are members of the multisig
-     * @returns A new empty MultisigTransaction instance
-     */
-    static empty(unsignedTx: UnsignedTransaction<unknown>, minSigners: number, allPubKeys: HexString[]): MultisigTransaction;
-    /**
-     * Creates a MultisigTransaction from an array of already-signed transactions.
-     * Extracts signatures and validates that all transactions are identical except for signatures.
-     * @param params - Parameters including the signed transactions, minimum signers, and all public keys
-     * @returns A new MultisigTransaction instance
-     * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant
-     * @throws {TransactionMismatchError} If transactions don't match each other
-     * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based
-     */
-    static fromTransactions({ txns, minSigners, allPubKeys, }: FromTransactionsParams): MultisigTransaction;
-    /**
-     * Adds a signature & public key from a signed transaction to the multisig transaction.
-     * @param tx - The signed transaction to extract signature from
-     * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant
-     * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction
-     * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-     */
-    addSignedTransaction(tx: Transaction<unknown>): void;
-    /**
-     * Adds a signature to the multisig transaction.
-     * @param signature - The signature to add
-     * @param pubKey - The public key corresponding to the signature
-     * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-     */
+    constructor({ signatures, unusedPubKeys, minSigners }: MultisigParams);
+    static fromPubKeys(allPubKeys: HexString[], minSigners: number): Multisig;
     addSignature(signature: HexString, pubKey: HexString): void;
-    /**
-     * Checks if the multisig has collected enough signatures to be complete.
-     * @returns True if the number of signatures meets or exceeds the minimum required
-     */
     get isComplete(): boolean;
-    /**
-     * Gets the unsigned transaction.
-     * @returns A readonly view of the unsigned transaction
-     */
-    get unsignedTransaction(): Readonly<UnsignedTransaction<unknown>>;
-    /**
-     * Gets the signatures and public keys collected so far.
-     * @returns A readonly view of the signatures and public keys
-     */
+    get threshold(): number;
     get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]>;
-    /**
-     * Gets the remaining public keys that haven't signed yet.
-     * @returns A readonly view of the remaining public keys
-     */
     get remainingPubKeys(): Readonly<Set<HexString>>;
-    /**
-     * Gets the threshold number of signatures required for the multisig to be complete.
-     * @returns The threshold number of signatures
-     */
-    get threshold(): number;
-    /**
-     * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.
-     * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))
-     * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)
-     * @returns The 32-byte multisig address as a Uint8Array
-     */
+    get allPubKeys(): Readonly<HexString[]>;
+    toTransaction<RuntimeCall>(unsignedTx: UnsignedTransaction<RuntimeCall>): TransactionV1<RuntimeCall>;
     getMultisigAddress(hasher?: "sha256"): Uint8Array;
-    /**
-     * Converts the multisig to a V1 transaction that can be submitted to the network.
-     * @returns A V1 transaction containing all collected signatures and unused public keys
-     */
-    asTransaction(): Transaction<unknown>;
 }
 
-export { type FromTransactionsParams, InvalidMultisigParameterError, InvalidTransactionVersionError, MultisigError, type MultisigParams, MultisigTransaction, TransactionMismatchError };
+export { InvalidMultisigParameterError, MAX_SIGNERS, Multisig, MultisigError, type MultisigParams };

package/dist/index.d.ts

@@ -1,22 +1,12 @@
-import { UnsignedTransaction, SignatureAndPubKey, Transaction } from '@sovereign-sdk/types';
+import { SignatureAndPubKey, UnsignedTransaction, TransactionV1 } from '@sovereign-sdk/types';
 import { HexString } from '@sovereign-sdk/utils';
 
+declare const MAX_SIGNERS = 21;
 /**
  * Base error class for multisig-related errors.
  */
 declare class MultisigError extends Error {
 }
-/**
- * Error thrown when a transaction has an unsupported version for multisig operations.
- */
-declare class InvalidTransactionVersionError extends MultisigError {
-}
-/**
- * Error thrown when a provided transaction doesn't match the expected unsigned transaction.
- */
-declare class TransactionMismatchError extends Error {
-    constructor();
-}
 /**
  * Error thrown when multisig is constructed or used with invalid parameters.
  */
@@ -24,113 +14,33 @@ declare class InvalidMultisigParameterError extends MultisigError {
     constructor(desc: string);
 }
 /**
- * Parameters for constructing a MultisigTransaction.
+ * Parameters for constructing a Multisig.
  */
 type MultisigParams = {
-    /** The unsigned transaction to be signed by multiple parties */
-    unsignedTx: UnsignedTransaction<unknown>;
     /** Array of signatures with pubkeys already collected */
-    signatures: SignatureAndPubKey[];
+    signatures?: SignatureAndPubKey[];
     /** Array of public keys that haven't signed yet */
     unusedPubKeys: HexString[];
     /** Minimum number of signatures required */
     minSigners: number;
 };
 /**
- * Parameters for creating a MultisigTransaction from existing signed transactions.
+ * Represents multisig signer membership and collected signatures.
  */
-type FromTransactionsParams = {
-    /** Array of signed transactions to extract signatures from */
-    txns: Transaction<unknown>[];
-    /** Minimum number of signatures required */
-    minSigners: number;
-    /** All public keys that are members of the multisig */
-    allPubKeys: HexString[];
-};
-/**
- * Represents a multisig transaction that collects signatures from multiple parties.
- * Only supports nonce-based transactions and V0 transaction variants for signature collection.
- */
-declare class MultisigTransaction {
-    private unsignedTx;
+declare class Multisig {
     private signatures;
     private minSigners;
     private unusedPubKeys;
-    /**
-     * Creates a new MultisigTransaction instance.
-     * @param params - The multisig parameters including unsigned transaction, signatures, and public keys
-     */
-    constructor({ unsignedTx, signatures, unusedPubKeys, minSigners, }: MultisigParams);
-    /**
-     * Creates an empty MultisigTransaction with no signatures collected yet.
-     * @param unsignedTx - The unsigned transaction to be signed by multiple parties
-     * @param minSigners - Minimum number of signatures required for completion
-     * @param allPubKeys - All public keys that are members of the multisig
-     * @returns A new empty MultisigTransaction instance
-     */
-    static empty(unsignedTx: UnsignedTransaction<unknown>, minSigners: number, allPubKeys: HexString[]): MultisigTransaction;
-    /**
-     * Creates a MultisigTransaction from an array of already-signed transactions.
-     * Extracts signatures and validates that all transactions are identical except for signatures.
-     * @param params - Parameters including the signed transactions, minimum signers, and all public keys
-     * @returns A new MultisigTransaction instance
-     * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant
-     * @throws {TransactionMismatchError} If transactions don't match each other
-     * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based
-     */
-    static fromTransactions({ txns, minSigners, allPubKeys, }: FromTransactionsParams): MultisigTransaction;
-    /**
-     * Adds a signature & public key from a signed transaction to the multisig transaction.
-     * @param tx - The signed transaction to extract signature from
-     * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant
-     * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction
-     * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-     */
-    addSignedTransaction(tx: Transaction<unknown>): void;
-    /**
-     * Adds a signature to the multisig transaction.
-     * @param signature - The signature to add
-     * @param pubKey - The public key corresponding to the signature
-     * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-     */
+    constructor({ signatures, unusedPubKeys, minSigners }: MultisigParams);
+    static fromPubKeys(allPubKeys: HexString[], minSigners: number): Multisig;
     addSignature(signature: HexString, pubKey: HexString): void;
-    /**
-     * Checks if the multisig has collected enough signatures to be complete.
-     * @returns True if the number of signatures meets or exceeds the minimum required
-     */
     get isComplete(): boolean;
-    /**
-     * Gets the unsigned transaction.
-     * @returns A readonly view of the unsigned transaction
-     */
-    get unsignedTransaction(): Readonly<UnsignedTransaction<unknown>>;
-    /**
-     * Gets the signatures and public keys collected so far.
-     * @returns A readonly view of the signatures and public keys
-     */
+    get threshold(): number;
     get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]>;
-    /**
-     * Gets the remaining public keys that haven't signed yet.
-     * @returns A readonly view of the remaining public keys
-     */
     get remainingPubKeys(): Readonly<Set<HexString>>;
-    /**
-     * Gets the threshold number of signatures required for the multisig to be complete.
-     * @returns The threshold number of signatures
-     */
-    get threshold(): number;
-    /**
-     * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.
-     * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))
-     * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)
-     * @returns The 32-byte multisig address as a Uint8Array
-     */
+    get allPubKeys(): Readonly<HexString[]>;
+    toTransaction<RuntimeCall>(unsignedTx: UnsignedTransaction<RuntimeCall>): TransactionV1<RuntimeCall>;
     getMultisigAddress(hasher?: "sha256"): Uint8Array;
-    /**
-     * Converts the multisig to a V1 transaction that can be submitted to the network.
-     * @returns A V1 transaction containing all collected signatures and unused public keys
-     */
-    asTransaction(): Transaction<unknown>;
 }
 
-export { type FromTransactionsParams, InvalidMultisigParameterError, InvalidTransactionVersionError, MultisigError, type MultisigParams, MultisigTransaction, TransactionMismatchError };
+export { InvalidMultisigParameterError, MAX_SIGNERS, Multisig, MultisigError, type MultisigParams };

package/dist/index.js

@@ -31,178 +31,92 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   InvalidMultisigParameterError: () => InvalidMultisigParameterError,
-  InvalidTransactionVersionError: () => InvalidTransactionVersionError,
-  MultisigError: () => MultisigError,
-  MultisigTransaction: () => MultisigTransaction,
-  TransactionMismatchError: () => TransactionMismatchError
+  MAX_SIGNERS: () => MAX_SIGNERS,
+  Multisig: () => Multisig,
+  MultisigError: () => MultisigError
 });
 module.exports = __toCommonJS(src_exports);
 var import_sha2 = require("@noble/hashes/sha2");
 var import_utils = require("@sovereign-sdk/utils");
 var borsh = __toESM(require("borsh"));
+var MAX_SIGNERS = 21;
 var MultisigError = class extends Error {
 };
-var InvalidTransactionVersionError = class extends MultisigError {
-};
-var TransactionMismatchError = class extends Error {
-  constructor() {
-    super(
-      "Provided transaction does not match the expected unsigned transaction"
-    );
-  }
-};
 var InvalidMultisigParameterError = class extends MultisigError {
   constructor(desc) {
     super(`Multisig was constructed with invalid parameter: ${desc}`);
   }
 };
-var MultisigTransaction = class _MultisigTransaction {
-  /**
-   * Creates a new MultisigTransaction instance.
-   * @param params - The multisig parameters including unsigned transaction, signatures, and public keys
-   */
-  constructor({
-    unsignedTx,
-    signatures,
-    unusedPubKeys,
-    minSigners
-  }) {
-    this.signatures = [];
-    this.unusedPubKeys = /* @__PURE__ */ new Set();
-    this.unsignedTx = unsignedTx;
-    this.signatures = signatures;
-    this.unusedPubKeys = new Set(unusedPubKeys);
+var Multisig = class _Multisig {
+  constructor({ signatures = [], unusedPubKeys, minSigners }) {
+    const normalizedSignatures = signatures.map(normalizeSignatureAndPubKey);
+    const normalizedUnusedPubKeys = unusedPubKeys.map(
+      (pubKey) => normalizeMultisigHex("public key", pubKey)
+    );
+    assertValidSignerSet(
+      normalizedSignatures,
+      normalizedUnusedPubKeys,
+      minSigners
+    );
+    this.signatures = normalizedSignatures;
+    this.unusedPubKeys = new Set(normalizedUnusedPubKeys);
     this.minSigners = minSigners;
   }
-  /**
-   * Creates an empty MultisigTransaction with no signatures collected yet.
-   * @param unsignedTx - The unsigned transaction to be signed by multiple parties
-   * @param minSigners - Minimum number of signatures required for completion
-   * @param allPubKeys - All public keys that are members of the multisig
-   * @returns A new empty MultisigTransaction instance
-   */
-  static empty(unsignedTx, minSigners, allPubKeys) {
-    return new _MultisigTransaction({
-      unsignedTx,
+  static fromPubKeys(allPubKeys, minSigners) {
+    return new _Multisig({
       signatures: [],
       unusedPubKeys: allPubKeys,
       minSigners
     });
   }
-  /**
-   * Creates a MultisigTransaction from an array of already-signed transactions.
-   * Extracts signatures and validates that all transactions are identical except for signatures.
-   * @param params - Parameters including the signed transactions, minimum signers, and all public keys
-   * @returns A new MultisigTransaction instance
-   * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant
-   * @throws {TransactionMismatchError} If transactions don't match each other
-   * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based
-   */
-  static fromTransactions({
-    txns,
-    minSigners,
-    allPubKeys
-  }) {
-    const signatures = [];
-    const unsignedTx = asUnsignedTransaction(txns[0]);
-    const unusedPubKeys = new Set(allPubKeys);
-    assertIsNonceBasedTx(unsignedTx);
-    for (const tx of txns) {
-      assertTxVariant(tx);
-      assertTxMatchesUnsignedTx(tx, unsignedTx);
-      const { pub_key, signature } = tx.V0;
-      if (!unusedPubKeys.delete(pub_key)) {
-        throw new InvalidMultisigParameterError(
-          `Public key is not a member of the multisig or has already signed: ${pub_key}`
-        );
-      }
-      signatures.push({ pub_key, signature });
-    }
-    return new _MultisigTransaction({
-      unsignedTx,
-      signatures,
-      unusedPubKeys: Array.from(unusedPubKeys),
-      minSigners
-    });
-  }
-  /**
-   * Adds a signature & public key from a signed transaction to the multisig transaction.
-   * @param tx - The signed transaction to extract signature from
-   * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant
-   * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction
-   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-   */
-  addSignedTransaction(tx) {
-    assertTxVariant(tx);
-    assertTxMatchesUnsignedTx(tx, this.unsignedTx);
-    const { pub_key, signature } = tx.V0;
-    this.addSignature(signature, pub_key);
-  }
-  /**
-   * Adds a signature to the multisig transaction.
-   * @param signature - The signature to add
-   * @param pubKey - The public key corresponding to the signature
-   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-   */
   addSignature(signature, pubKey) {
-    if (!this.unusedPubKeys.delete(pubKey)) {
+    const pair = normalizeSignatureAndPubKey({ signature, pub_key: pubKey });
+    if (!this.unusedPubKeys.delete(pair.pub_key)) {
       throw new InvalidMultisigParameterError(
-        `Public key is not a member of the multisig or has already signed: ${pubKey}`
+        `Public key is not a member of the multisig or has already signed: ${pair.pub_key}`
       );
     }
-    this.signatures.push({ pub_key: pubKey, signature });
+    this.signatures.push(pair);
   }
-  /**
-   * Checks if the multisig has collected enough signatures to be complete.
-   * @returns True if the number of signatures meets or exceeds the minimum required
-   */
   get isComplete() {
     return this.signatures.length >= this.minSigners;
   }
-  /**
-   * Gets the unsigned transaction.
-   * @returns A readonly view of the unsigned transaction
-   */
-  get unsignedTransaction() {
-    return this.unsignedTx;
+  get threshold() {
+    return this.minSigners;
   }
-  /**
-   * Gets the signatures and public keys collected so far.
-   * @returns A readonly view of the signatures and public keys
-   */
   get signaturesAndPubKeys() {
-    return this.signatures;
+    return this.signatures.map((pair) => ({ ...pair }));
   }
-  /**
-   * Gets the remaining public keys that haven't signed yet.
-   * @returns A readonly view of the remaining public keys
-   */
   get remainingPubKeys() {
-    return this.unusedPubKeys;
+    return new Set(this.unusedPubKeys);
   }
-  /**
-   * Gets the threshold number of signatures required for the multisig to be complete.
-   * @returns The threshold number of signatures
-   */
-  get threshold() {
-    return this.minSigners;
+  get allPubKeys() {
+    return [
+      ...this.signatures.map((signature) => signature.pub_key),
+      ...this.unusedPubKeys
+    ];
+  }
+  toTransaction(unsignedTx) {
+    if (!this.isComplete) {
+      throw new MultisigError("Multisig transaction is incomplete");
+    }
+    return {
+      V1: {
+        ...unsignedTx,
+        signatures: [...this.signaturesAndPubKeys],
+        unused_pub_keys: [...this.remainingPubKeys],
+        min_signers: this.threshold
+      }
+    };
   }
-  /**
-   * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.
-   * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))
-   * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)
-   * @returns The 32-byte multisig address as a Uint8Array
-   */
   getMultisigAddress(hasher = "sha256") {
     if (hasher !== "sha256") {
       throw new Error(`Unsupported hasher: ${hasher}`);
     }
-    const allPubKeys = [
-      ...this.signatures.map((s) => s.pub_key),
-      ...Array.from(this.unusedPubKeys)
-    ];
-    const sortedPubKeys = allPubKeys.sort();
-    const pubKeyBytes = sortedPubKeys.map((pk) => Array.from((0, import_utils.hexToBytes)(pk)));
+    const sortedPubKeys = [...this.allPubKeys].sort();
+    const pubKeyBytes = sortedPubKeys.map(
+      (pubKey) => Array.from((0, import_utils.hexToBytes)(pubKey))
+    );
     const buffer = new borsh.BinaryWriter();
     buffer.writeU8(this.minSigners);
     buffer.writeArray(pubKeyBytes, (pkBytes) => {
@@ -210,68 +124,58 @@ var MultisigTransaction = class _MultisigTransaction {
     });
     return (0, import_sha2.sha256)(buffer.toArray());
   }
-  /**
-   * Converts the multisig to a V1 transaction that can be submitted to the network.
-   * @returns A V1 transaction containing all collected signatures and unused public keys
-   */
-  asTransaction() {
-    return {
-      V1: {
-        runtime_call: this.unsignedTx.runtime_call,
-        uniqueness: this.unsignedTx.uniqueness,
-        details: this.unsignedTx.details,
-        unused_pub_keys: Array.from(this.unusedPubKeys),
-        signatures: this.signatures,
-        min_signers: this.minSigners
-      }
-    };
-  }
 };
-function assertTxVariant(tx) {
-  if ("V1" in tx) {
-    throw new InvalidTransactionVersionError(
-      "Input transaction was an unsupported variant (V1)"
+function assertValidSignerSet(signatures, unusedPubKeys, minSigners) {
+  const seenPubKeys = /* @__PURE__ */ new Set();
+  const allPubKeys = [
+    ...signatures.map((signature) => signature.pub_key),
+    ...unusedPubKeys
+  ];
+  if (!Number.isInteger(minSigners) || minSigners < 1) {
+    throw new InvalidMultisigParameterError(
+      `minSigners must be a positive integer, got ${minSigners}`
     );
   }
-}
-function asUnsignedTransaction(tx) {
-  if ("V0" in tx) {
-    return {
-      runtime_call: tx.V0.runtime_call,
-      uniqueness: tx.V0.uniqueness,
-      details: tx.V0.details
-    };
+  if (allPubKeys.length < 2 || allPubKeys.length > MAX_SIGNERS) {
+    throw new InvalidMultisigParameterError(
+      `expected 2-${MAX_SIGNERS} total signers, got ${allPubKeys.length}`
+    );
   }
-  if ("V1" in tx) {
-    return {
-      runtime_call: tx.V1.runtime_call,
-      uniqueness: tx.V1.uniqueness,
-      details: tx.V1.details
-    };
+  if (minSigners > allPubKeys.length) {
+    throw new InvalidMultisigParameterError(
+      `minSigners cannot exceed total signer count: ${minSigners} > ${allPubKeys.length}`
+    );
   }
-  throw new InvalidTransactionVersionError(
-    "Transaction variant is neither V0 nor V1"
-  );
-}
-function assertTxMatchesUnsignedTx(tx, unsignedTx) {
-  const txAsUnsigned = asUnsignedTransaction(tx);
-  if (JSON.stringify(txAsUnsigned) !== JSON.stringify(unsignedTx)) {
-    throw new TransactionMismatchError();
+  for (const pubKey of allPubKeys) {
+    if (seenPubKeys.has(pubKey)) {
+      throw new InvalidMultisigParameterError(
+        `Duplicate multisig public key: ${pubKey}`
+      );
+    }
+    seenPubKeys.add(pubKey);
   }
 }
-function assertIsNonceBasedTx(unsignedTx) {
-  if (!("nonce" in unsignedTx.uniqueness)) {
+function normalizeSignatureAndPubKey(pair) {
+  return {
+    signature: normalizeMultisigHex("signature", pair.signature),
+    pub_key: normalizeMultisigHex("public key", pair.pub_key)
+  };
+}
+function normalizeMultisigHex(kind, value) {
+  try {
+    return (0, import_utils.normalizeHexString)(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     throw new InvalidMultisigParameterError(
-      "Only nonce-based transactions are supported for multisig"
+      `Invalid multisig ${kind} ${value}: ${message}`
     );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InvalidMultisigParameterError,
-  InvalidTransactionVersionError,
-  MultisigError,
-  MultisigTransaction,
-  TransactionMismatchError
+  MAX_SIGNERS,
+  Multisig,
+  MultisigError
 });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { sha256 } from \"@noble/hashes/sha2\";\nimport type {\n  SignatureAndPubKey,\n  Transaction,\n  TransactionV0,\n  UnsignedTransaction,\n} from \"@sovereign-sdk/types\";\nimport type { HexString } from \"@sovereign-sdk/utils\";\nimport { bytesToHex, hexToBytes } from \"@sovereign-sdk/utils\";\nimport * as borsh from \"borsh\";\n\n/**\n * Base error class for multisig-related errors.\n */\nexport class MultisigError extends Error {}\n\n/**\n * Error thrown when a transaction has an unsupported version for multisig operations.\n */\nexport class InvalidTransactionVersionError extends MultisigError {}\n\n/**\n * Error thrown when a provided transaction doesn't match the expected unsigned transaction.\n */\nexport class TransactionMismatchError extends Error {\n  constructor() {\n    super(\n      \"Provided transaction does not match the expected unsigned transaction\",\n    );\n  }\n}\n\n/**\n * Error thrown when multisig is constructed or used with invalid parameters.\n */\nexport class InvalidMultisigParameterError extends MultisigError {\n  constructor(desc: string) {\n    super(`Multisig was constructed with invalid parameter: ${desc}`);\n  }\n}\n\n/**\n * Parameters for constructing a MultisigTransaction.\n */\nexport type MultisigParams = {\n  /** The unsigned transaction to be signed by multiple parties */\n  unsignedTx: UnsignedTransaction<unknown>;\n  /** Array of signatures with pubkeys already collected */\n  signatures: SignatureAndPubKey[];\n  /** Array of public keys that haven't signed yet */\n  unusedPubKeys: HexString[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n};\n\n/**\n * Parameters for creating a MultisigTransaction from existing signed transactions.\n */\nexport type FromTransactionsParams = {\n  /** Array of signed transactions to extract signatures from */\n  txns: Transaction<unknown>[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n  /** All public keys that are members of the multisig */\n  allPubKeys: HexString[];\n};\n\n/**\n * Represents a multisig transaction that collects signatures from multiple parties.\n * Only supports nonce-based transactions and V0 transaction variants for signature collection.\n */\nexport class MultisigTransaction {\n  private unsignedTx: UnsignedTransaction<unknown>;\n  private signatures: SignatureAndPubKey[] = [];\n  private minSigners: number;\n  private unusedPubKeys = new Set<HexString>();\n\n  /**\n   * Creates a new MultisigTransaction instance.\n   * @param params - The multisig parameters including unsigned transaction, signatures, and public keys\n   */\n  constructor({\n    unsignedTx,\n    signatures,\n    unusedPubKeys,\n    minSigners,\n  }: MultisigParams) {\n    this.unsignedTx = unsignedTx;\n    this.signatures = signatures;\n    this.unusedPubKeys = new Set(unusedPubKeys);\n    this.minSigners = minSigners;\n  }\n\n  /**\n   * Creates an empty MultisigTransaction with no signatures collected yet.\n   * @param unsignedTx - The unsigned transaction to be signed by multiple parties\n   * @param minSigners - Minimum number of signatures required for completion\n   * @param allPubKeys - All public keys that are members of the multisig\n   * @returns A new empty MultisigTransaction instance\n   */\n  static empty(\n    unsignedTx: UnsignedTransaction<unknown>,\n    minSigners: number,\n    allPubKeys: HexString[],\n  ): MultisigTransaction {\n    return new MultisigTransaction({\n      unsignedTx,\n      signatures: [],\n      unusedPubKeys: allPubKeys,\n      minSigners,\n    });\n  }\n\n  /**\n   * Creates a MultisigTransaction from an array of already-signed transactions.\n   * Extracts signatures and validates that all transactions are identical except for signatures.\n   * @param params - Parameters including the signed transactions, minimum signers, and all public keys\n   * @returns A new MultisigTransaction instance\n   * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant\n   * @throws {TransactionMismatchError} If transactions don't match each other\n   * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based\n   */\n  static fromTransactions({\n    txns,\n    minSigners,\n    allPubKeys,\n  }: FromTransactionsParams): MultisigTransaction {\n    const signatures: SignatureAndPubKey[] = [];\n    const unsignedTx = asUnsignedTransaction(txns[0]);\n    const unusedPubKeys = new Set<HexString>(allPubKeys);\n\n    assertIsNonceBasedTx(unsignedTx);\n\n    for (const tx of txns) {\n      assertTxVariant(tx);\n      assertTxMatchesUnsignedTx(tx, unsignedTx);\n\n      const { pub_key, signature } = tx.V0;\n\n      if (!unusedPubKeys.delete(pub_key)) {\n        throw new InvalidMultisigParameterError(\n          `Public key is not a member of the multisig or has already signed: ${pub_key}`,\n        );\n      }\n\n      signatures.push({ pub_key, signature });\n    }\n\n    return new MultisigTransaction({\n      unsignedTx,\n      signatures,\n      unusedPubKeys: Array.from(unusedPubKeys),\n      minSigners,\n    });\n  }\n\n  /**\n   * Adds a signature & public key from a signed transaction to the multisig transaction.\n   * @param tx - The signed transaction to extract signature from\n   * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant\n   * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction\n   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed\n   */\n  addSignedTransaction(tx: Transaction<unknown>): void {\n    assertTxVariant(tx);\n    assertTxMatchesUnsignedTx(tx, this.unsignedTx);\n\n    const { pub_key, signature } = tx.V0;\n\n    this.addSignature(signature, pub_key);\n  }\n\n  /**\n   * Adds a signature to the multisig transaction.\n   * @param signature - The signature to add\n   * @param pubKey - The public key corresponding to the signature\n   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed\n   */\n  addSignature(signature: HexString, pubKey: HexString): void {\n    if (!this.unusedPubKeys.delete(pubKey)) {\n      throw new InvalidMultisigParameterError(\n        `Public key is not a member of the multisig or has already signed: ${pubKey}`,\n      );\n    }\n\n    this.signatures.push({ pub_key: pubKey, signature });\n  }\n\n  /**\n   * Checks if the multisig has collected enough signatures to be complete.\n   * @returns True if the number of signatures meets or exceeds the minimum required\n   */\n  get isComplete(): boolean {\n    return this.signatures.length >= this.minSigners;\n  }\n\n  /**\n   * Gets the unsigned transaction.\n   * @returns A readonly view of the unsigned transaction\n   */\n  get unsignedTransaction(): Readonly<UnsignedTransaction<unknown>> {\n    return this.unsignedTx;\n  }\n\n  /**\n   * Gets the signatures and public keys collected so far.\n   * @returns A readonly view of the signatures and public keys\n   */\n  get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]> {\n    return this.signatures;\n  }\n\n  /**\n   * Gets the remaining public keys that haven't signed yet.\n   * @returns A readonly view of the remaining public keys\n   */\n  get remainingPubKeys(): Readonly<Set<HexString>> {\n    return this.unusedPubKeys;\n  }\n\n  /**\n   * Gets the threshold number of signatures required for the multisig to be complete.\n   * @returns The threshold number of signatures\n   */\n  get threshold(): number {\n    return this.minSigners;\n  }\n\n  /**\n   * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.\n   * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))\n   * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)\n   * @returns The 32-byte multisig address as a Uint8Array\n   */\n  getMultisigAddress(hasher: \"sha256\" = \"sha256\"): Uint8Array {\n    if (hasher !== \"sha256\") {\n      throw new Error(`Unsupported hasher: ${hasher}`);\n    }\n\n    // Collect all public keys (signatures + unused)\n    const allPubKeys = [\n      ...this.signatures.map((s) => s.pub_key),\n      ...Array.from(this.unusedPubKeys),\n    ];\n    const sortedPubKeys = allPubKeys.sort();\n    const pubKeyBytes = sortedPubKeys.map((pk) => Array.from(hexToBytes(pk)));\n    const buffer = new borsh.BinaryWriter();\n\n    buffer.writeU8(this.minSigners);\n    buffer.writeArray(pubKeyBytes, (pkBytes: number[]) => {\n      buffer.writeFixedArray(new Uint8Array(pkBytes));\n    });\n\n    return sha256(buffer.toArray());\n  }\n\n  /**\n   * Converts the multisig to a V1 transaction that can be submitted to the network.\n   * @returns A V1 transaction containing all collected signatures and unused public keys\n   */\n  asTransaction(): Transaction<unknown> {\n    return {\n      V1: {\n        runtime_call: this.unsignedTx.runtime_call,\n        uniqueness: this.unsignedTx.uniqueness,\n        details: this.unsignedTx.details,\n        unused_pub_keys: Array.from(this.unusedPubKeys),\n        signatures: this.signatures,\n        min_signers: this.minSigners,\n      },\n    };\n  }\n}\n\nfunction assertTxVariant(\n  tx: Transaction<unknown>,\n): asserts tx is TransactionV0<unknown> {\n  if (\"V1\" in tx) {\n    throw new InvalidTransactionVersionError(\n      \"Input transaction was an unsupported variant (V1)\",\n    );\n  }\n}\n\nfunction asUnsignedTransaction(\n  tx: Transaction<unknown>,\n): UnsignedTransaction<unknown> {\n  if (\"V0\" in tx) {\n    return {\n      runtime_call: tx.V0.runtime_call,\n      uniqueness: tx.V0.uniqueness,\n      details: tx.V0.details,\n    };\n  }\n\n  if (\"V1\" in tx) {\n    return {\n      runtime_call: tx.V1.runtime_call,\n      uniqueness: tx.V1.uniqueness,\n      details: tx.V1.details,\n    };\n  }\n\n  throw new InvalidTransactionVersionError(\n    \"Transaction variant is neither V0 nor V1\",\n  );\n}\n\nfunction assertTxMatchesUnsignedTx(\n  tx: Transaction<unknown>,\n  unsignedTx: UnsignedTransaction<unknown>,\n): void {\n  const txAsUnsigned = asUnsignedTransaction(tx);\n\n  if (JSON.stringify(txAsUnsigned) !== JSON.stringify(unsignedTx)) {\n    throw new TransactionMismatchError();\n  }\n}\n\nfunction assertIsNonceBasedTx(unsignedTx: UnsignedTransaction<unknown>): void {\n  if (!(\"nonce\" in unsignedTx.uniqueness)) {\n    throw new InvalidMultisigParameterError(\n      \"Only nonce-based transactions are supported for multisig\",\n    );\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { sha256 } from \"@noble/hashes/sha2\";\nimport type {\n  SignatureAndPubKey,\n  TransactionV1,\n  UnsignedTransaction,\n} from \"@sovereign-sdk/types\";\nimport type { HexString } from \"@sovereign-sdk/utils\";\nimport { hexToBytes, normalizeHexString } from \"@sovereign-sdk/utils\";\nimport * as borsh from \"borsh\";\n\nexport const MAX_SIGNERS = 21;\n\n/**\n * Base error class for multisig-related errors.\n */\nexport class MultisigError extends Error {}\n\n/**\n * Error thrown when multisig is constructed or used with invalid parameters.\n */\nexport class InvalidMultisigParameterError extends MultisigError {\n  constructor(desc: string) {\n    super(`Multisig was constructed with invalid parameter: ${desc}`);\n  }\n}\n\n/**\n * Parameters for constructing a Multisig.\n */\nexport type MultisigParams = {\n  /** Array of signatures with pubkeys already collected */\n  signatures?: SignatureAndPubKey[];\n  /** Array of public keys that haven't signed yet */\n  unusedPubKeys: HexString[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n};\n\n/**\n * Represents multisig signer membership and collected signatures.\n */\nexport class Multisig {\n  private signatures: SignatureAndPubKey[];\n  private minSigners: number;\n  private unusedPubKeys: Set<HexString>;\n\n  constructor({ signatures = [], unusedPubKeys, minSigners }: MultisigParams) {\n    const normalizedSignatures = signatures.map(normalizeSignatureAndPubKey);\n    const normalizedUnusedPubKeys = unusedPubKeys.map((pubKey) =>\n      normalizeMultisigHex(\"public key\", pubKey),\n    );\n\n    assertValidSignerSet(\n      normalizedSignatures,\n      normalizedUnusedPubKeys,\n      minSigners,\n    );\n\n    this.signatures = normalizedSignatures;\n    this.unusedPubKeys = new Set(normalizedUnusedPubKeys);\n    this.minSigners = minSigners;\n  }\n\n  static fromPubKeys(allPubKeys: HexString[], minSigners: number): Multisig {\n    return new Multisig({\n      signatures: [],\n      unusedPubKeys: allPubKeys,\n      minSigners,\n    });\n  }\n\n  addSignature(signature: HexString, pubKey: HexString): void {\n    const pair = normalizeSignatureAndPubKey({ signature, pub_key: pubKey });\n\n    if (!this.unusedPubKeys.delete(pair.pub_key)) {\n      throw new InvalidMultisigParameterError(\n        `Public key is not a member of the multisig or has already signed: ${pair.pub_key}`,\n      );\n    }\n\n    this.signatures.push(pair);\n  }\n\n  get isComplete(): boolean {\n    return this.signatures.length >= this.minSigners;\n  }\n\n  get threshold(): number {\n    return this.minSigners;\n  }\n\n  get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]> {\n    return this.signatures.map((pair) => ({ ...pair }));\n  }\n\n  get remainingPubKeys(): Readonly<Set<HexString>> {\n    return new Set(this.unusedPubKeys);\n  }\n\n  get allPubKeys(): Readonly<HexString[]> {\n    return [\n      ...this.signatures.map((signature) => signature.pub_key),\n      ...this.unusedPubKeys,\n    ];\n  }\n\n  toTransaction<RuntimeCall>(\n    unsignedTx: UnsignedTransaction<RuntimeCall>,\n  ): TransactionV1<RuntimeCall> {\n    if (!this.isComplete) {\n      throw new MultisigError(\"Multisig transaction is incomplete\");\n    }\n\n    return {\n      V1: {\n        ...unsignedTx,\n        signatures: [...this.signaturesAndPubKeys],\n        unused_pub_keys: [...this.remainingPubKeys],\n        min_signers: this.threshold,\n      },\n    };\n  }\n\n  getMultisigAddress(hasher: \"sha256\" = \"sha256\"): Uint8Array {\n    if (hasher !== \"sha256\") {\n      throw new Error(`Unsupported hasher: ${hasher}`);\n    }\n\n    const sortedPubKeys = [...this.allPubKeys].sort();\n    const pubKeyBytes = sortedPubKeys.map((pubKey) =>\n      Array.from(hexToBytes(pubKey)),\n    );\n    const buffer = new borsh.BinaryWriter();\n\n    buffer.writeU8(this.minSigners);\n    buffer.writeArray(pubKeyBytes, (pkBytes: number[]) => {\n      buffer.writeFixedArray(new Uint8Array(pkBytes));\n    });\n\n    return sha256(buffer.toArray());\n  }\n}\n\nfunction assertValidSignerSet(\n  signatures: SignatureAndPubKey[],\n  unusedPubKeys: HexString[],\n  minSigners: number,\n): void {\n  // `signatures` and `unusedPubKeys` are expected to already be normalized and\n  // validated hex strings by the time this runs.\n  const seenPubKeys = new Set<HexString>();\n  const allPubKeys = [\n    ...signatures.map((signature) => signature.pub_key),\n    ...unusedPubKeys,\n  ];\n\n  if (!Number.isInteger(minSigners) || minSigners < 1) {\n    throw new InvalidMultisigParameterError(\n      `minSigners must be a positive integer, got ${minSigners}`,\n    );\n  }\n\n  if (allPubKeys.length < 2 || allPubKeys.length > MAX_SIGNERS) {\n    throw new InvalidMultisigParameterError(\n      `expected 2-${MAX_SIGNERS} total signers, got ${allPubKeys.length}`,\n    );\n  }\n\n  if (minSigners > allPubKeys.length) {\n    throw new InvalidMultisigParameterError(\n      `minSigners cannot exceed total signer count: ${minSigners} > ${allPubKeys.length}`,\n    );\n  }\n\n  for (const pubKey of allPubKeys) {\n    if (seenPubKeys.has(pubKey)) {\n      throw new InvalidMultisigParameterError(\n        `Duplicate multisig public key: ${pubKey}`,\n      );\n    }\n\n    seenPubKeys.add(pubKey);\n  }\n}\n\nfunction normalizeSignatureAndPubKey(\n  pair: SignatureAndPubKey,\n): SignatureAndPubKey {\n  return {\n    signature: normalizeMultisigHex(\"signature\", pair.signature),\n    pub_key: normalizeMultisigHex(\"public key\", pair.pub_key),\n  };\n}\n\nfunction normalizeMultisigHex(kind: string, value: HexString): HexString {\n  try {\n    return normalizeHexString(value);\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    throw new InvalidMultisigParameterError(\n      `Invalid multisig ${kind} ${value}: ${message}`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AAOvB,mBAA+C;AAC/C,YAAuB;AAEhB,IAAM,cAAc;AAKpB,IAAM,gBAAN,cAA4B,MAAM;AAAC;AAKnC,IAAM,gCAAN,cAA4C,cAAc;AAAA,EAC/D,YAAY,MAAc;AACxB,UAAM,oDAAoD,IAAI,EAAE;AAAA,EAClE;AACF;AAiBO,IAAM,WAAN,MAAM,UAAS;AAAA,EAKpB,YAAY,EAAE,aAAa,CAAC,GAAG,eAAe,WAAW,GAAmB;AAC1E,UAAM,uBAAuB,WAAW,IAAI,2BAA2B;AACvE,UAAM,0BAA0B,cAAc;AAAA,MAAI,CAAC,WACjD,qBAAqB,cAAc,MAAM;AAAA,IAC3C;AAEA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,SAAK,aAAa;AAClB,SAAK,gBAAgB,IAAI,IAAI,uBAAuB;AACpD,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,OAAO,YAAY,YAAyB,YAA8B;AACxE,WAAO,IAAI,UAAS;AAAA,MAClB,YAAY,CAAC;AAAA,MACb,eAAe;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,aAAa,WAAsB,QAAyB;AAC1D,UAAM,OAAO,4BAA4B,EAAE,WAAW,SAAS,OAAO,CAAC;AAEvE,QAAI,CAAC,KAAK,cAAc,OAAO,KAAK,OAAO,GAAG;AAC5C,YAAM,IAAI;AAAA,QACR,qEAAqE,KAAK,OAAO;AAAA,MACnF;AAAA,IACF;AAEA,SAAK,WAAW,KAAK,IAAI;AAAA,EAC3B;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK,WAAW,UAAU,KAAK;AAAA,EACxC;AAAA,EAEA,IAAI,YAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,uBAAuD;AACzD,WAAO,KAAK,WAAW,IAAI,CAAC,UAAU,EAAE,GAAG,KAAK,EAAE;AAAA,EACpD;AAAA,EAEA,IAAI,mBAA6C;AAC/C,WAAO,IAAI,IAAI,KAAK,aAAa;AAAA,EACnC;AAAA,EAEA,IAAI,aAAoC;AACtC,WAAO;AAAA,MACL,GAAG,KAAK,WAAW,IAAI,CAAC,cAAc,UAAU,OAAO;AAAA,MACvD,GAAG,KAAK;AAAA,IACV;AAAA,EACF;AAAA,EAEA,cACE,YAC4B;AAC5B,QAAI,CAAC,KAAK,YAAY;AACpB,YAAM,IAAI,cAAc,oCAAoC;AAAA,IAC9D;AAEA,WAAO;AAAA,MACL,IAAI;AAAA,QACF,GAAG;AAAA,QACH,YAAY,CAAC,GAAG,KAAK,oBAAoB;AAAA,QACzC,iBAAiB,CAAC,GAAG,KAAK,gBAAgB;AAAA,QAC1C,aAAa,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,mBAAmB,SAAmB,UAAsB;AAC1D,QAAI,WAAW,UAAU;AACvB,YAAM,IAAI,MAAM,uBAAuB,MAAM,EAAE;AAAA,IACjD;AAEA,UAAM,gBAAgB,CAAC,GAAG,KAAK,UAAU,EAAE,KAAK;AAChD,UAAM,cAAc,cAAc;AAAA,MAAI,CAAC,WACrC,MAAM,SAAK,yBAAW,MAAM,CAAC;AAAA,IAC/B;AACA,UAAM,SAAS,IAAU,mBAAa;AAEtC,WAAO,QAAQ,KAAK,UAAU;AAC9B,WAAO,WAAW,aAAa,CAAC,YAAsB;AACpD,aAAO,gBAAgB,IAAI,WAAW,OAAO,CAAC;AAAA,IAChD,CAAC;AAED,eAAO,oBAAO,OAAO,QAAQ,CAAC;AAAA,EAChC;AACF;AAEA,SAAS,qBACP,YACA,eACA,YACM;AAGN,QAAM,cAAc,oBAAI,IAAe;AACvC,QAAM,aAAa;AAAA,IACjB,GAAG,WAAW,IAAI,CAAC,cAAc,UAAU,OAAO;AAAA,IAClD,GAAG;AAAA,EACL;AAEA,MAAI,CAAC,OAAO,UAAU,UAAU,KAAK,aAAa,GAAG;AACnD,UAAM,IAAI;AAAA,MACR,8CAA8C,UAAU;AAAA,IAC1D;AAAA,EACF;AAEA,MAAI,WAAW,SAAS,KAAK,WAAW,SAAS,aAAa;AAC5D,UAAM,IAAI;AAAA,MACR,cAAc,WAAW,uBAAuB,WAAW,MAAM;AAAA,IACnE;AAAA,EACF;AAEA,MAAI,aAAa,WAAW,QAAQ;AAClC,UAAM,IAAI;AAAA,MACR,gDAAgD,UAAU,MAAM,WAAW,MAAM;AAAA,IACnF;AAAA,EACF;AAEA,aAAW,UAAU,YAAY;AAC/B,QAAI,YAAY,IAAI,MAAM,GAAG;AAC3B,YAAM,IAAI;AAAA,QACR,kCAAkC,MAAM;AAAA,MAC1C;AAAA,IACF;AAEA,gBAAY,IAAI,MAAM;AAAA,EACxB;AACF;AAEA,SAAS,4BACP,MACoB;AACpB,SAAO;AAAA,IACL,WAAW,qBAAqB,aAAa,KAAK,SAAS;AAAA,IAC3D,SAAS,qBAAqB,cAAc,KAAK,OAAO;AAAA,EAC1D;AACF;AAEA,SAAS,qBAAqB,MAAc,OAA6B;AACvE,MAAI;AACF,eAAO,iCAAmB,KAAK;AAAA,EACjC,SAAS,OAAO;AACd,UAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,UAAM,IAAI;AAAA,MACR,oBAAoB,IAAI,IAAI,KAAK,KAAK,OAAO;AAAA,IAC/C;AAAA,EACF;AACF;","names":[]}

package/dist/index.mjs

@@ -1,170 +1,85 @@
 // src/index.ts
 import { sha256 } from "@noble/hashes/sha2";
-import { hexToBytes } from "@sovereign-sdk/utils";
+import { hexToBytes, normalizeHexString } from "@sovereign-sdk/utils";
 import * as borsh from "borsh";
+var MAX_SIGNERS = 21;
 var MultisigError = class extends Error {
 };
-var InvalidTransactionVersionError = class extends MultisigError {
-};
-var TransactionMismatchError = class extends Error {
-  constructor() {
-    super(
-      "Provided transaction does not match the expected unsigned transaction"
-    );
-  }
-};
 var InvalidMultisigParameterError = class extends MultisigError {
   constructor(desc) {
     super(`Multisig was constructed with invalid parameter: ${desc}`);
   }
 };
-var MultisigTransaction = class _MultisigTransaction {
-  /**
-   * Creates a new MultisigTransaction instance.
-   * @param params - The multisig parameters including unsigned transaction, signatures, and public keys
-   */
-  constructor({
-    unsignedTx,
-    signatures,
-    unusedPubKeys,
-    minSigners
-  }) {
-    this.signatures = [];
-    this.unusedPubKeys = /* @__PURE__ */ new Set();
-    this.unsignedTx = unsignedTx;
-    this.signatures = signatures;
-    this.unusedPubKeys = new Set(unusedPubKeys);
+var Multisig = class _Multisig {
+  constructor({ signatures = [], unusedPubKeys, minSigners }) {
+    const normalizedSignatures = signatures.map(normalizeSignatureAndPubKey);
+    const normalizedUnusedPubKeys = unusedPubKeys.map(
+      (pubKey) => normalizeMultisigHex("public key", pubKey)
+    );
+    assertValidSignerSet(
+      normalizedSignatures,
+      normalizedUnusedPubKeys,
+      minSigners
+    );
+    this.signatures = normalizedSignatures;
+    this.unusedPubKeys = new Set(normalizedUnusedPubKeys);
     this.minSigners = minSigners;
   }
-  /**
-   * Creates an empty MultisigTransaction with no signatures collected yet.
-   * @param unsignedTx - The unsigned transaction to be signed by multiple parties
-   * @param minSigners - Minimum number of signatures required for completion
-   * @param allPubKeys - All public keys that are members of the multisig
-   * @returns A new empty MultisigTransaction instance
-   */
-  static empty(unsignedTx, minSigners, allPubKeys) {
-    return new _MultisigTransaction({
-      unsignedTx,
+  static fromPubKeys(allPubKeys, minSigners) {
+    return new _Multisig({
       signatures: [],
       unusedPubKeys: allPubKeys,
       minSigners
     });
   }
-  /**
-   * Creates a MultisigTransaction from an array of already-signed transactions.
-   * Extracts signatures and validates that all transactions are identical except for signatures.
-   * @param params - Parameters including the signed transactions, minimum signers, and all public keys
-   * @returns A new MultisigTransaction instance
-   * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant
-   * @throws {TransactionMismatchError} If transactions don't match each other
-   * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based
-   */
-  static fromTransactions({
-    txns,
-    minSigners,
-    allPubKeys
-  }) {
-    const signatures = [];
-    const unsignedTx = asUnsignedTransaction(txns[0]);
-    const unusedPubKeys = new Set(allPubKeys);
-    assertIsNonceBasedTx(unsignedTx);
-    for (const tx of txns) {
-      assertTxVariant(tx);
-      assertTxMatchesUnsignedTx(tx, unsignedTx);
-      const { pub_key, signature } = tx.V0;
-      if (!unusedPubKeys.delete(pub_key)) {
-        throw new InvalidMultisigParameterError(
-          `Public key is not a member of the multisig or has already signed: ${pub_key}`
-        );
-      }
-      signatures.push({ pub_key, signature });
-    }
-    return new _MultisigTransaction({
-      unsignedTx,
-      signatures,
-      unusedPubKeys: Array.from(unusedPubKeys),
-      minSigners
-    });
-  }
-  /**
-   * Adds a signature & public key from a signed transaction to the multisig transaction.
-   * @param tx - The signed transaction to extract signature from
-   * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant
-   * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction
-   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-   */
-  addSignedTransaction(tx) {
-    assertTxVariant(tx);
-    assertTxMatchesUnsignedTx(tx, this.unsignedTx);
-    const { pub_key, signature } = tx.V0;
-    this.addSignature(signature, pub_key);
-  }
-  /**
-   * Adds a signature to the multisig transaction.
-   * @param signature - The signature to add
-   * @param pubKey - The public key corresponding to the signature
-   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed
-   */
   addSignature(signature, pubKey) {
-    if (!this.unusedPubKeys.delete(pubKey)) {
+    const pair = normalizeSignatureAndPubKey({ signature, pub_key: pubKey });
+    if (!this.unusedPubKeys.delete(pair.pub_key)) {
       throw new InvalidMultisigParameterError(
-        `Public key is not a member of the multisig or has already signed: ${pubKey}`
+        `Public key is not a member of the multisig or has already signed: ${pair.pub_key}`
       );
     }
-    this.signatures.push({ pub_key: pubKey, signature });
+    this.signatures.push(pair);
   }
-  /**
-   * Checks if the multisig has collected enough signatures to be complete.
-   * @returns True if the number of signatures meets or exceeds the minimum required
-   */
   get isComplete() {
     return this.signatures.length >= this.minSigners;
   }
-  /**
-   * Gets the unsigned transaction.
-   * @returns A readonly view of the unsigned transaction
-   */
-  get unsignedTransaction() {
-    return this.unsignedTx;
-  }
-  /**
-   * Gets the signatures and public keys collected so far.
-   * @returns A readonly view of the signatures and public keys
-   */
+  get threshold() {
+    return this.minSigners;
+  }
   get signaturesAndPubKeys() {
-    return this.signatures;
+    return this.signatures.map((pair) => ({ ...pair }));
   }
-  /**
-   * Gets the remaining public keys that haven't signed yet.
-   * @returns A readonly view of the remaining public keys
-   */
   get remainingPubKeys() {
-    return this.unusedPubKeys;
+    return new Set(this.unusedPubKeys);
   }
-  /**
-   * Gets the threshold number of signatures required for the multisig to be complete.
-   * @returns The threshold number of signatures
-   */
-  get threshold() {
-    return this.minSigners;
+  get allPubKeys() {
+    return [
+      ...this.signatures.map((signature) => signature.pub_key),
+      ...this.unusedPubKeys
+    ];
+  }
+  toTransaction(unsignedTx) {
+    if (!this.isComplete) {
+      throw new MultisigError("Multisig transaction is incomplete");
+    }
+    return {
+      V1: {
+        ...unsignedTx,
+        signatures: [...this.signaturesAndPubKeys],
+        unused_pub_keys: [...this.remainingPubKeys],
+        min_signers: this.threshold
+      }
+    };
   }
-  /**
-   * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.
-   * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))
-   * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)
-   * @returns The 32-byte multisig address as a Uint8Array
-   */
   getMultisigAddress(hasher = "sha256") {
     if (hasher !== "sha256") {
       throw new Error(`Unsupported hasher: ${hasher}`);
     }
-    const allPubKeys = [
-      ...this.signatures.map((s) => s.pub_key),
-      ...Array.from(this.unusedPubKeys)
-    ];
-    const sortedPubKeys = allPubKeys.sort();
-    const pubKeyBytes = sortedPubKeys.map((pk) => Array.from(hexToBytes(pk)));
+    const sortedPubKeys = [...this.allPubKeys].sort();
+    const pubKeyBytes = sortedPubKeys.map(
+      (pubKey) => Array.from(hexToBytes(pubKey))
+    );
     const buffer = new borsh.BinaryWriter();
     buffer.writeU8(this.minSigners);
     buffer.writeArray(pubKeyBytes, (pkBytes) => {
@@ -172,67 +87,57 @@ var MultisigTransaction = class _MultisigTransaction {
     });
     return sha256(buffer.toArray());
   }
-  /**
-   * Converts the multisig to a V1 transaction that can be submitted to the network.
-   * @returns A V1 transaction containing all collected signatures and unused public keys
-   */
-  asTransaction() {
-    return {
-      V1: {
-        runtime_call: this.unsignedTx.runtime_call,
-        uniqueness: this.unsignedTx.uniqueness,
-        details: this.unsignedTx.details,
-        unused_pub_keys: Array.from(this.unusedPubKeys),
-        signatures: this.signatures,
-        min_signers: this.minSigners
-      }
-    };
-  }
 };
-function assertTxVariant(tx) {
-  if ("V1" in tx) {
-    throw new InvalidTransactionVersionError(
-      "Input transaction was an unsupported variant (V1)"
+function assertValidSignerSet(signatures, unusedPubKeys, minSigners) {
+  const seenPubKeys = /* @__PURE__ */ new Set();
+  const allPubKeys = [
+    ...signatures.map((signature) => signature.pub_key),
+    ...unusedPubKeys
+  ];
+  if (!Number.isInteger(minSigners) || minSigners < 1) {
+    throw new InvalidMultisigParameterError(
+      `minSigners must be a positive integer, got ${minSigners}`
     );
   }
-}
-function asUnsignedTransaction(tx) {
-  if ("V0" in tx) {
-    return {
-      runtime_call: tx.V0.runtime_call,
-      uniqueness: tx.V0.uniqueness,
-      details: tx.V0.details
-    };
+  if (allPubKeys.length < 2 || allPubKeys.length > MAX_SIGNERS) {
+    throw new InvalidMultisigParameterError(
+      `expected 2-${MAX_SIGNERS} total signers, got ${allPubKeys.length}`
+    );
   }
-  if ("V1" in tx) {
-    return {
-      runtime_call: tx.V1.runtime_call,
-      uniqueness: tx.V1.uniqueness,
-      details: tx.V1.details
-    };
+  if (minSigners > allPubKeys.length) {
+    throw new InvalidMultisigParameterError(
+      `minSigners cannot exceed total signer count: ${minSigners} > ${allPubKeys.length}`
+    );
   }
-  throw new InvalidTransactionVersionError(
-    "Transaction variant is neither V0 nor V1"
-  );
-}
-function assertTxMatchesUnsignedTx(tx, unsignedTx) {
-  const txAsUnsigned = asUnsignedTransaction(tx);
-  if (JSON.stringify(txAsUnsigned) !== JSON.stringify(unsignedTx)) {
-    throw new TransactionMismatchError();
+  for (const pubKey of allPubKeys) {
+    if (seenPubKeys.has(pubKey)) {
+      throw new InvalidMultisigParameterError(
+        `Duplicate multisig public key: ${pubKey}`
+      );
+    }
+    seenPubKeys.add(pubKey);
   }
 }
-function assertIsNonceBasedTx(unsignedTx) {
-  if (!("nonce" in unsignedTx.uniqueness)) {
+function normalizeSignatureAndPubKey(pair) {
+  return {
+    signature: normalizeMultisigHex("signature", pair.signature),
+    pub_key: normalizeMultisigHex("public key", pair.pub_key)
+  };
+}
+function normalizeMultisigHex(kind, value) {
+  try {
+    return normalizeHexString(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     throw new InvalidMultisigParameterError(
-      "Only nonce-based transactions are supported for multisig"
+      `Invalid multisig ${kind} ${value}: ${message}`
     );
   }
 }
 export {
   InvalidMultisigParameterError,
-  InvalidTransactionVersionError,
-  MultisigError,
-  MultisigTransaction,
-  TransactionMismatchError
+  MAX_SIGNERS,
+  Multisig,
+  MultisigError
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { sha256 } from \"@noble/hashes/sha2\";\nimport type {\n  SignatureAndPubKey,\n  Transaction,\n  TransactionV0,\n  UnsignedTransaction,\n} from \"@sovereign-sdk/types\";\nimport type { HexString } from \"@sovereign-sdk/utils\";\nimport { bytesToHex, hexToBytes } from \"@sovereign-sdk/utils\";\nimport * as borsh from \"borsh\";\n\n/**\n * Base error class for multisig-related errors.\n */\nexport class MultisigError extends Error {}\n\n/**\n * Error thrown when a transaction has an unsupported version for multisig operations.\n */\nexport class InvalidTransactionVersionError extends MultisigError {}\n\n/**\n * Error thrown when a provided transaction doesn't match the expected unsigned transaction.\n */\nexport class TransactionMismatchError extends Error {\n  constructor() {\n    super(\n      \"Provided transaction does not match the expected unsigned transaction\",\n    );\n  }\n}\n\n/**\n * Error thrown when multisig is constructed or used with invalid parameters.\n */\nexport class InvalidMultisigParameterError extends MultisigError {\n  constructor(desc: string) {\n    super(`Multisig was constructed with invalid parameter: ${desc}`);\n  }\n}\n\n/**\n * Parameters for constructing a MultisigTransaction.\n */\nexport type MultisigParams = {\n  /** The unsigned transaction to be signed by multiple parties */\n  unsignedTx: UnsignedTransaction<unknown>;\n  /** Array of signatures with pubkeys already collected */\n  signatures: SignatureAndPubKey[];\n  /** Array of public keys that haven't signed yet */\n  unusedPubKeys: HexString[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n};\n\n/**\n * Parameters for creating a MultisigTransaction from existing signed transactions.\n */\nexport type FromTransactionsParams = {\n  /** Array of signed transactions to extract signatures from */\n  txns: Transaction<unknown>[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n  /** All public keys that are members of the multisig */\n  allPubKeys: HexString[];\n};\n\n/**\n * Represents a multisig transaction that collects signatures from multiple parties.\n * Only supports nonce-based transactions and V0 transaction variants for signature collection.\n */\nexport class MultisigTransaction {\n  private unsignedTx: UnsignedTransaction<unknown>;\n  private signatures: SignatureAndPubKey[] = [];\n  private minSigners: number;\n  private unusedPubKeys = new Set<HexString>();\n\n  /**\n   * Creates a new MultisigTransaction instance.\n   * @param params - The multisig parameters including unsigned transaction, signatures, and public keys\n   */\n  constructor({\n    unsignedTx,\n    signatures,\n    unusedPubKeys,\n    minSigners,\n  }: MultisigParams) {\n    this.unsignedTx = unsignedTx;\n    this.signatures = signatures;\n    this.unusedPubKeys = new Set(unusedPubKeys);\n    this.minSigners = minSigners;\n  }\n\n  /**\n   * Creates an empty MultisigTransaction with no signatures collected yet.\n   * @param unsignedTx - The unsigned transaction to be signed by multiple parties\n   * @param minSigners - Minimum number of signatures required for completion\n   * @param allPubKeys - All public keys that are members of the multisig\n   * @returns A new empty MultisigTransaction instance\n   */\n  static empty(\n    unsignedTx: UnsignedTransaction<unknown>,\n    minSigners: number,\n    allPubKeys: HexString[],\n  ): MultisigTransaction {\n    return new MultisigTransaction({\n      unsignedTx,\n      signatures: [],\n      unusedPubKeys: allPubKeys,\n      minSigners,\n    });\n  }\n\n  /**\n   * Creates a MultisigTransaction from an array of already-signed transactions.\n   * Extracts signatures and validates that all transactions are identical except for signatures.\n   * @param params - Parameters including the signed transactions, minimum signers, and all public keys\n   * @returns A new MultisigTransaction instance\n   * @throws {InvalidTransactionVersionError} If any transaction is not V0 variant\n   * @throws {TransactionMismatchError} If transactions don't match each other\n   * @throws {InvalidMultisigParameterError} If public keys are invalid or transaction is not nonce-based\n   */\n  static fromTransactions({\n    txns,\n    minSigners,\n    allPubKeys,\n  }: FromTransactionsParams): MultisigTransaction {\n    const signatures: SignatureAndPubKey[] = [];\n    const unsignedTx = asUnsignedTransaction(txns[0]);\n    const unusedPubKeys = new Set<HexString>(allPubKeys);\n\n    assertIsNonceBasedTx(unsignedTx);\n\n    for (const tx of txns) {\n      assertTxVariant(tx);\n      assertTxMatchesUnsignedTx(tx, unsignedTx);\n\n      const { pub_key, signature } = tx.V0;\n\n      if (!unusedPubKeys.delete(pub_key)) {\n        throw new InvalidMultisigParameterError(\n          `Public key is not a member of the multisig or has already signed: ${pub_key}`,\n        );\n      }\n\n      signatures.push({ pub_key, signature });\n    }\n\n    return new MultisigTransaction({\n      unsignedTx,\n      signatures,\n      unusedPubKeys: Array.from(unusedPubKeys),\n      minSigners,\n    });\n  }\n\n  /**\n   * Adds a signature & public key from a signed transaction to the multisig transaction.\n   * @param tx - The signed transaction to extract signature from\n   * @throws {InvalidTransactionVersionError} If the transaction is not V0 variant\n   * @throws {TransactionMismatchError} If the transaction doesn't match the unsigned transaction\n   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed\n   */\n  addSignedTransaction(tx: Transaction<unknown>): void {\n    assertTxVariant(tx);\n    assertTxMatchesUnsignedTx(tx, this.unsignedTx);\n\n    const { pub_key, signature } = tx.V0;\n\n    this.addSignature(signature, pub_key);\n  }\n\n  /**\n   * Adds a signature to the multisig transaction.\n   * @param signature - The signature to add\n   * @param pubKey - The public key corresponding to the signature\n   * @throws {InvalidMultisigParameterError} If the public key is not a member or has already signed\n   */\n  addSignature(signature: HexString, pubKey: HexString): void {\n    if (!this.unusedPubKeys.delete(pubKey)) {\n      throw new InvalidMultisigParameterError(\n        `Public key is not a member of the multisig or has already signed: ${pubKey}`,\n      );\n    }\n\n    this.signatures.push({ pub_key: pubKey, signature });\n  }\n\n  /**\n   * Checks if the multisig has collected enough signatures to be complete.\n   * @returns True if the number of signatures meets or exceeds the minimum required\n   */\n  get isComplete(): boolean {\n    return this.signatures.length >= this.minSigners;\n  }\n\n  /**\n   * Gets the unsigned transaction.\n   * @returns A readonly view of the unsigned transaction\n   */\n  get unsignedTransaction(): Readonly<UnsignedTransaction<unknown>> {\n    return this.unsignedTx;\n  }\n\n  /**\n   * Gets the signatures and public keys collected so far.\n   * @returns A readonly view of the signatures and public keys\n   */\n  get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]> {\n    return this.signatures;\n  }\n\n  /**\n   * Gets the remaining public keys that haven't signed yet.\n   * @returns A readonly view of the remaining public keys\n   */\n  get remainingPubKeys(): Readonly<Set<HexString>> {\n    return this.unusedPubKeys;\n  }\n\n  /**\n   * Gets the threshold number of signatures required for the multisig to be complete.\n   * @returns The threshold number of signatures\n   */\n  get threshold(): number {\n    return this.minSigners;\n  }\n\n  /**\n   * Calculates the multisig address (credential ID) by hashing the threshold and sorted public keys.\n   * This matches the Rust implementation: hash(threshold || borsh(sorted_pubkeys))\n   * @param hasher - The hash algorithm to use (currently only 'sha256' is supported)\n   * @returns The 32-byte multisig address as a Uint8Array\n   */\n  getMultisigAddress(hasher: \"sha256\" = \"sha256\"): Uint8Array {\n    if (hasher !== \"sha256\") {\n      throw new Error(`Unsupported hasher: ${hasher}`);\n    }\n\n    // Collect all public keys (signatures + unused)\n    const allPubKeys = [\n      ...this.signatures.map((s) => s.pub_key),\n      ...Array.from(this.unusedPubKeys),\n    ];\n    const sortedPubKeys = allPubKeys.sort();\n    const pubKeyBytes = sortedPubKeys.map((pk) => Array.from(hexToBytes(pk)));\n    const buffer = new borsh.BinaryWriter();\n\n    buffer.writeU8(this.minSigners);\n    buffer.writeArray(pubKeyBytes, (pkBytes: number[]) => {\n      buffer.writeFixedArray(new Uint8Array(pkBytes));\n    });\n\n    return sha256(buffer.toArray());\n  }\n\n  /**\n   * Converts the multisig to a V1 transaction that can be submitted to the network.\n   * @returns A V1 transaction containing all collected signatures and unused public keys\n   */\n  asTransaction(): Transaction<unknown> {\n    return {\n      V1: {\n        runtime_call: this.unsignedTx.runtime_call,\n        uniqueness: this.unsignedTx.uniqueness,\n        details: this.unsignedTx.details,\n        unused_pub_keys: Array.from(this.unusedPubKeys),\n        signatures: this.signatures,\n        min_signers: this.minSigners,\n      },\n    };\n  }\n}\n\nfunction assertTxVariant(\n  tx: Transaction<unknown>,\n): asserts tx is TransactionV0<unknown> {\n  if (\"V1\" in tx) {\n    throw new InvalidTransactionVersionError(\n      \"Input transaction was an unsupported variant (V1)\",\n    );\n  }\n}\n\nfunction asUnsignedTransaction(\n  tx: Transaction<unknown>,\n): UnsignedTransaction<unknown> {\n  if (\"V0\" in tx) {\n    return {\n      runtime_call: tx.V0.runtime_call,\n      uniqueness: tx.V0.uniqueness,\n      details: tx.V0.details,\n    };\n  }\n\n  if (\"V1\" in tx) {\n    return {\n      runtime_call: tx.V1.runtime_call,\n      uniqueness: tx.V1.uniqueness,\n      details: tx.V1.details,\n    };\n  }\n\n  throw new InvalidTransactionVersionError(\n    \"Transaction variant is neither V0 nor V1\",\n  );\n}\n\nfunction assertTxMatchesUnsignedTx(\n  tx: Transaction<unknown>,\n  unsignedTx: UnsignedTransaction<unknown>,\n): void {\n  const txAsUnsigned = asUnsignedTransaction(tx);\n\n  if (JSON.stringify(txAsUnsigned) !== JSON.stringify(unsignedTx)) {\n    throw new TransactionMismatchError();\n  }\n}\n\nfunction assertIsNonceBasedTx(unsignedTx: UnsignedTransaction<unknown>): void {\n  if (!(\"nonce\" in unsignedTx.uniqueness)) {\n    throw new InvalidMultisigParameterError(\n      \"Only nonce-based transactions are supported for multisig\",\n    );\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { sha256 } from \"@noble/hashes/sha2\";\nimport type {\n  SignatureAndPubKey,\n  TransactionV1,\n  UnsignedTransaction,\n} from \"@sovereign-sdk/types\";\nimport type { HexString } from \"@sovereign-sdk/utils\";\nimport { hexToBytes, normalizeHexString } from \"@sovereign-sdk/utils\";\nimport * as borsh from \"borsh\";\n\nexport const MAX_SIGNERS = 21;\n\n/**\n * Base error class for multisig-related errors.\n */\nexport class MultisigError extends Error {}\n\n/**\n * Error thrown when multisig is constructed or used with invalid parameters.\n */\nexport class InvalidMultisigParameterError extends MultisigError {\n  constructor(desc: string) {\n    super(`Multisig was constructed with invalid parameter: ${desc}`);\n  }\n}\n\n/**\n * Parameters for constructing a Multisig.\n */\nexport type MultisigParams = {\n  /** Array of signatures with pubkeys already collected */\n  signatures?: SignatureAndPubKey[];\n  /** Array of public keys that haven't signed yet */\n  unusedPubKeys: HexString[];\n  /** Minimum number of signatures required */\n  minSigners: number;\n};\n\n/**\n * Represents multisig signer membership and collected signatures.\n */\nexport class Multisig {\n  private signatures: SignatureAndPubKey[];\n  private minSigners: number;\n  private unusedPubKeys: Set<HexString>;\n\n  constructor({ signatures = [], unusedPubKeys, minSigners }: MultisigParams) {\n    const normalizedSignatures = signatures.map(normalizeSignatureAndPubKey);\n    const normalizedUnusedPubKeys = unusedPubKeys.map((pubKey) =>\n      normalizeMultisigHex(\"public key\", pubKey),\n    );\n\n    assertValidSignerSet(\n      normalizedSignatures,\n      normalizedUnusedPubKeys,\n      minSigners,\n    );\n\n    this.signatures = normalizedSignatures;\n    this.unusedPubKeys = new Set(normalizedUnusedPubKeys);\n    this.minSigners = minSigners;\n  }\n\n  static fromPubKeys(allPubKeys: HexString[], minSigners: number): Multisig {\n    return new Multisig({\n      signatures: [],\n      unusedPubKeys: allPubKeys,\n      minSigners,\n    });\n  }\n\n  addSignature(signature: HexString, pubKey: HexString): void {\n    const pair = normalizeSignatureAndPubKey({ signature, pub_key: pubKey });\n\n    if (!this.unusedPubKeys.delete(pair.pub_key)) {\n      throw new InvalidMultisigParameterError(\n        `Public key is not a member of the multisig or has already signed: ${pair.pub_key}`,\n      );\n    }\n\n    this.signatures.push(pair);\n  }\n\n  get isComplete(): boolean {\n    return this.signatures.length >= this.minSigners;\n  }\n\n  get threshold(): number {\n    return this.minSigners;\n  }\n\n  get signaturesAndPubKeys(): Readonly<SignatureAndPubKey[]> {\n    return this.signatures.map((pair) => ({ ...pair }));\n  }\n\n  get remainingPubKeys(): Readonly<Set<HexString>> {\n    return new Set(this.unusedPubKeys);\n  }\n\n  get allPubKeys(): Readonly<HexString[]> {\n    return [\n      ...this.signatures.map((signature) => signature.pub_key),\n      ...this.unusedPubKeys,\n    ];\n  }\n\n  toTransaction<RuntimeCall>(\n    unsignedTx: UnsignedTransaction<RuntimeCall>,\n  ): TransactionV1<RuntimeCall> {\n    if (!this.isComplete) {\n      throw new MultisigError(\"Multisig transaction is incomplete\");\n    }\n\n    return {\n      V1: {\n        ...unsignedTx,\n        signatures: [...this.signaturesAndPubKeys],\n        unused_pub_keys: [...this.remainingPubKeys],\n        min_signers: this.threshold,\n      },\n    };\n  }\n\n  getMultisigAddress(hasher: \"sha256\" = \"sha256\"): Uint8Array {\n    if (hasher !== \"sha256\") {\n      throw new Error(`Unsupported hasher: ${hasher}`);\n    }\n\n    const sortedPubKeys = [...this.allPubKeys].sort();\n    const pubKeyBytes = sortedPubKeys.map((pubKey) =>\n      Array.from(hexToBytes(pubKey)),\n    );\n    const buffer = new borsh.BinaryWriter();\n\n    buffer.writeU8(this.minSigners);\n    buffer.writeArray(pubKeyBytes, (pkBytes: number[]) => {\n      buffer.writeFixedArray(new Uint8Array(pkBytes));\n    });\n\n    return sha256(buffer.toArray());\n  }\n}\n\nfunction assertValidSignerSet(\n  signatures: SignatureAndPubKey[],\n  unusedPubKeys: HexString[],\n  minSigners: number,\n): void {\n  // `signatures` and `unusedPubKeys` are expected to already be normalized and\n  // validated hex strings by the time this runs.\n  const seenPubKeys = new Set<HexString>();\n  const allPubKeys = [\n    ...signatures.map((signature) => signature.pub_key),\n    ...unusedPubKeys,\n  ];\n\n  if (!Number.isInteger(minSigners) || minSigners < 1) {\n    throw new InvalidMultisigParameterError(\n      `minSigners must be a positive integer, got ${minSigners}`,\n    );\n  }\n\n  if (allPubKeys.length < 2 || allPubKeys.length > MAX_SIGNERS) {\n    throw new InvalidMultisigParameterError(\n      `expected 2-${MAX_SIGNERS} total signers, got ${allPubKeys.length}`,\n    );\n  }\n\n  if (minSigners > allPubKeys.length) {\n    throw new InvalidMultisigParameterError(\n      `minSigners cannot exceed total signer count: ${minSigners} > ${allPubKeys.length}`,\n    );\n  }\n\n  for (const pubKey of allPubKeys) {\n    if (seenPubKeys.has(pubKey)) {\n      throw new InvalidMultisigParameterError(\n        `Duplicate multisig public key: ${pubKey}`,\n      );\n    }\n\n    seenPubKeys.add(pubKey);\n  }\n}\n\nfunction normalizeSignatureAndPubKey(\n  pair: SignatureAndPubKey,\n): SignatureAndPubKey {\n  return {\n    signature: normalizeMultisigHex(\"signature\", pair.signature),\n    pub_key: normalizeMultisigHex(\"public key\", pair.pub_key),\n  };\n}\n\nfunction normalizeMultisigHex(kind: string, value: HexString): HexString {\n  try {\n    return normalizeHexString(value);\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    throw new InvalidMultisigParameterError(\n      `Invalid multisig ${kind} ${value}: ${message}`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovereign-sdk/multisig",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Multisig functionality for Sovereign SDK applications",
   "repository": {
     "type": "git",
@@ -25,8 +25,7 @@
     "tsup": "^8.3.0",
     "typescript": "^5.6.3",
     "vitest": "4.0.7",
-    "@sovereign-sdk/types": "^0.1.2",
-    "@sovereign-sdk/web3": "^0.14.1"
+    "@sovereign-sdk/types": "^0.2.0"
   },
   "peerDependencies": {
     "tsup": "^8.3.0",
@@ -38,8 +37,7 @@
   "dependencies": {
     "@noble/hashes": "^1.5.0",
     "borsh": "0.7.0",
-    "@sovereign-sdk/signers": "^0.5.3",
-    "@sovereign-sdk/utils": "^0.0.4"
+    "@sovereign-sdk/utils": "^0.1.0"
   },
   "scripts": {
     "build": "tsup",
@@ -47,7 +45,6 @@
     "fix": "biome check --write",
     "lint": "biome lint",
     "test": "vitest run **/*.test.ts",
-    "test:integration": "vitest run **/*.integration-test.ts",
     "typecheck": "tsc --noEmit"
   }
 }