@openzeppelin/miden-multisig-client 0.12.6 → 0.12.8

package/dist/multisig.js

@@ -1,50 +1,47 @@
-/**
- * Multisig class representing a created or loaded multisig account.
- *
- * This class wraps a Miden SDK Account and provides PSM integration
- * for proposal management.
- */
+import { AccountInspector } from './inspector.js';
 import { Account, AccountId, AdviceMap, FeltArray, Signature, TransactionSummary, Word, } from '@demox-labs/miden-sdk';
 import { executeForSummary, buildUpdateSignersTransactionRequest, buildUpdatePsmTransactionRequest, buildConsumeNotesTransactionRequest, buildP2idTransactionRequest, } from './transaction.js';
 import { base64ToUint8Array, uint8ArrayToBase64, normalizeHexWord, } from './utils/encoding.js';
-import { buildSignatureAdviceEntry, signatureHexToBytes } from './utils/signature.js';
+import { buildSignatureAdviceEntry, signatureHexToBytes, tryComputeEcdsaCommitmentHex } from './utils/signature.js';
 import { computeCommitmentFromTxSummary, accountIdToHex } from './multisig/helpers.js';
-/**
- * Represents a multisig account with PSM integration.
- */
 export class Multisig {
     account;
     threshold;
     signerCommitments;
     psmCommitment;
+    psmPublicKey;
     procedureThresholds;
+    signatureScheme;
     psm;
     signer;
     webClient;
     _accountId;
     proposals = new Map();
     constructor(account, config, psm, signer, webClient, accountId) {
+        if (config.signatureScheme && config.signatureScheme !== signer.scheme) {
+            throw new Error(`signature scheme mismatch: config=${config.signatureScheme} signer=${signer.scheme}`);
+        }
         this.account = account;
         this.threshold = config.threshold;
         this.signerCommitments = config.signerCommitments;
         this.psmCommitment = config.psmCommitment;
+        this.psmPublicKey = config.psmPublicKey;
+        this.signatureScheme = config.signatureScheme ?? signer.scheme;
         this.procedureThresholds = new Map((config.procedureThresholds ?? []).map((pt) => [pt.procedure, pt.threshold]));
         this.psm = psm;
         this.signer = signer;
         this.webClient = webClient;
         this._accountId = accountId ?? (account ? accountIdToHex(account) : '');
     }
-    /** The account ID as a string */
     get accountId() {
         return this._accountId;
     }
-    /** The signer's commitment */
     get signerCommitment() {
         return this.signer.commitment;
     }
-    /**
-     * Maps a proposal type to the procedure that determines its threshold.
-     */
+    setPsmPublicKey(pubkey) {
+        this.psmPublicKey = pubkey;
+    }
     getProposalProcedure(proposalType) {
         switch (proposalType) {
             case 'p2id':
@@ -61,13 +58,6 @@ export class Multisig {
                 return null;
         }
     }
-    /**
-     * Get the effective threshold for a given proposal type.
-     * Returns the procedure-specific threshold if configured, otherwise the default threshold.
-     *
-     * @param proposalType - The type of proposal
-     * @returns The threshold that applies to this proposal type
-     */
     getEffectiveThreshold(proposalType) {
         if (this.procedureThresholds.size === 0) {
             return this.threshold;
@@ -78,20 +68,10 @@ export class Multisig {
         }
         return this.procedureThresholds.get(procedure) ?? this.threshold;
     }
-    /**
-     * Update the PSM client used by this Multisig instance.
-     *
-     * @param psmClient - The new PSM HTTP client
-     */
     setPsmClient(psmClient) {
         this.psm = psmClient;
         this.psm.setSigner(this.signer);
     }
-    /**
-     * Fetch the current account state from PSM.
-     *
-     * @returns The account state including commitment and serialized data
-     */
     async fetchState() {
         const state = await this.psm.getState(this._accountId);
         return {
@@ -100,14 +80,9 @@ export class Multisig {
             stateDataBase64: state.stateJson.data,
             createdAt: state.createdAt,
             updatedAt: state.updatedAt,
+            authScheme: state.authScheme,
         };
     }
-    /**
-     * Sync account state from PSM into the local WebClient store.
-     *
-     * If the PSM commitment differs from the local commitment (or the account
-     * is missing locally), the local store is overwritten with the PSM state.
-     */
     async syncState() {
         const state = await this.fetchState();
         const accountId = AccountId.fromHex(this._accountId);
@@ -123,19 +98,10 @@ export class Multisig {
         }
         return state;
     }
-    /**
-     * Register this multisig account on the PSM server.
-     *
-     * The initial state must be the serialized Account bytes (base64-encoded).
-     * If not provided, the account's serialize() method is used.
-     *
-     * @param initialStateBase64 - Optional base64-encoded serialized Account.¡
-     */
     async registerOnPsm(initialStateBase64) {
         if (!this.account && !initialStateBase64) {
             throw new Error('Cannot register on PSM: no account available and no initial state provided');
         }
-        // Serialize the account to bytes and base64-encode
         let stateData;
         if (initialStateBase64) {
             stateData = initialStateBase64;
@@ -144,11 +110,9 @@ export class Multisig {
             const accountBytes = this.account.serialize();
             stateData = uint8ArrayToBase64(accountBytes);
         }
-        const auth = {
-            MidenFalconRpo: {
-                cosigner_commitments: this.signerCommitments,
-            },
-        };
+        const auth = this.signer.scheme === 'ecdsa'
+            ? { MidenEcdsa: { cosigner_commitments: this.signerCommitments } }
+            : { MidenFalconRpo: { cosigner_commitments: this.signerCommitments } };
         const response = await this.psm.configure({
             accountId: this._accountId,
             auth,
@@ -157,14 +121,37 @@ export class Multisig {
         if (!response.success) {
             throw new Error(`Failed to register on PSM: ${response.message}`);
         }
+        if (response.ackCommitment && this.psmCommitment) {
+            const onChain = normalizeHexWord(this.psmCommitment);
+            const server = normalizeHexWord(response.ackCommitment);
+            if (onChain !== server) {
+                throw new Error(`PSM commitment mismatch: on-chain=${onChain}, server=${server}. ` +
+                    `Re-create the account with getPubkey('${this.signatureScheme}') to get the correct PSM commitment.`);
+            }
+        }
+    }
+    async syncAll() {
+        const proposals = await this.syncTransactionProposals();
+        const state = await this.syncState();
+        const notes = await this.getConsumableNotes();
+        const config = AccountInspector.fromBase64(state.stateDataBase64, this.signatureScheme);
+        return { proposals, state, notes, config };
     }
-    /**
-     * Sync proposals from the PSM server.
-     */
-    async syncProposals() {
+    async getAccountConfig() {
+        const state = await this.syncState();
+        return AccountInspector.fromBase64(state.stateDataBase64, this.signatureScheme);
+    }
+    async switchPsm(psmClient) {
+        this.setPsmClient(psmClient);
+        const state = await this.fetchState();
+        await this.registerOnPsm(state.stateDataBase64);
+    }
+    async syncTransactionProposals() {
         const deltas = await this.psm.getDeltaProposals(this._accountId);
+        const serverProposalIds = new Set();
         for (const delta of deltas) {
             const proposalId = computeCommitmentFromTxSummary(delta.deltaPayload.txSummary.data);
+            serverProposalIds.add(proposalId);
             const existingProposal = this.proposals.get(proposalId);
             const resolvedMetadata = existingProposal?.metadata ??
                 (delta.deltaPayload.metadata
@@ -176,21 +163,19 @@ export class Multisig {
             const proposal = this.deltaToProposal(delta, proposalId, resolvedMetadata, existingProposal?.signatures);
             this.proposals.set(proposal.id, proposal);
         }
+        for (const [id, proposal] of this.proposals) {
+            if (serverProposalIds.has(id))
+                continue;
+            const isLocalOnly = proposal.metadata?.proposalType === 'switch_psm' && proposal.status.type !== 'finalized';
+            if (!isLocalOnly) {
+                this.proposals.delete(id);
+            }
+        }
         return Array.from(this.proposals.values());
     }
-    /**
-     * List all known proposals
-     */
-    listProposals() {
+    listTransactionProposals() {
         return Array.from(this.proposals.values());
     }
-    /**
-     * Create a new proposal.
-     *
-     * @param nonce - The nonce for this transaction
-     * @param txSummaryBase64 - Base64-encoded transaction summary
-     * @param metadata - Optional metadata for execution (target config, salt, etc.)
-     */
     async createProposal(nonce, txSummaryBase64, metadata) {
         const psmMetadata = this.buildPsmMetadata(metadata);
         const response = await this.psm.pushDeltaProposal({
@@ -206,20 +191,13 @@ export class Multisig {
         this.proposals.set(proposal.id, proposal);
         return proposal;
     }
-    /**
-     * Create an "add signer" proposal.
-     *
-     * @param newCommitment - Commitment of the new signer (hex)
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     * @param newThreshold - Optional new threshold (defaults to current threshold)
-     */
-    async createAddSignerProposal(newCommitment, nonce, newThreshold) {
-        const targetThreshold = newThreshold ?? this.threshold;
+    async createAddSignerProposal(newCommitment, options) {
+        const targetThreshold = options?.newThreshold ?? this.threshold;
         const targetSignerCommitments = [...this.signerCommitments, newCommitment];
-        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, targetThreshold, targetSignerCommitments);
+        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, targetThreshold, targetSignerCommitments, { signatureScheme: this.signatureScheme });
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'add_signer',
             targetThreshold,
@@ -227,16 +205,10 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Add signer ${newCommitment.slice(0, 10)}...`,
         };
-        return this.createProposal(proposalNonce, summaryBase64, metadata);
-    }
-    /**
-     * Create a "remove signer" proposal by executing the update_signers script to summary.
-     *
-     * @param signerToRemove - Commitment of the signer to remove (hex)
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     * @param newThreshold - Optional new threshold (defaults to min of current threshold and new signer count)
-     */
-    async createRemoveSignerProposal(signerToRemove, nonce, newThreshold) {
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return this.syncAfterCreate(proposal);
+    }
+    async createRemoveSignerProposal(signerToRemove, options) {
         const normalizedRemove = signerToRemove.toLowerCase();
         const signerExists = this.signerCommitments.some((c) => c.toLowerCase() === normalizedRemove);
         if (!signerExists) {
@@ -246,14 +218,14 @@ export class Multisig {
         if (targetSignerCommitments.length === 0) {
             throw new Error('Cannot remove the last signer');
         }
-        const targetThreshold = newThreshold ?? Math.min(this.threshold, targetSignerCommitments.length);
+        const targetThreshold = options?.newThreshold ?? Math.min(this.threshold, targetSignerCommitments.length);
         if (targetThreshold < 1 || targetThreshold > targetSignerCommitments.length) {
             throw new Error(`Invalid threshold ${targetThreshold}. Must be between 1 and ${targetSignerCommitments.length}`);
         }
-        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, targetThreshold, targetSignerCommitments);
+        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, targetThreshold, targetSignerCommitments, { signatureScheme: this.signatureScheme });
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'remove_signer',
             targetThreshold,
@@ -261,25 +233,20 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Remove signer ${signerToRemove.slice(0, 10)}...`,
         };
-        return this.createProposal(proposalNonce, summaryBase64, metadata);
-    }
-    /**
-     * Create a "change threshold" proposal.
-     *
-     * @param newThreshold - The new threshold value
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     */
-    async createChangeThresholdProposal(newThreshold, nonce) {
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return this.syncAfterCreate(proposal);
+    }
+    async createChangeThresholdProposal(newThreshold, options) {
         if (newThreshold < 1 || newThreshold > this.signerCommitments.length) {
             throw new Error(`Invalid threshold ${newThreshold}. Must be between 1 and ${this.signerCommitments.length}`);
         }
         if (newThreshold === this.threshold) {
             throw new Error('New threshold is the same as current threshold');
         }
-        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, newThreshold, this.signerCommitments);
+        const { request, salt } = await buildUpdateSignersTransactionRequest(this.webClient, newThreshold, this.signerCommitments, { signatureScheme: this.signatureScheme });
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'change_threshold',
             targetThreshold: newThreshold,
@@ -287,20 +254,14 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Change threshold from ${this.threshold} to ${newThreshold}`,
         };
-        return this.createProposal(proposalNonce, summaryBase64, metadata);
-    }
-    /**
-     * Create a "switch PSM" proposal to change the PSM provider.
-     *
-     * @param newPsmEndpoint - The new PSM server endpoint URL
-     * @param newPsmPubkey - The new PSM server's public key commitment (hex)
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     */
-    async createSwitchPsmProposal(newPsmEndpoint, newPsmPubkey, nonce) {
-        const { request, salt } = await buildUpdatePsmTransactionRequest(this.webClient, newPsmPubkey);
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return this.syncAfterCreate(proposal);
+    }
+    async createSwitchPsmProposal(newPsmEndpoint, newPsmPubkey, options) {
+        const { request, salt } = await buildUpdatePsmTransactionRequest(this.webClient, newPsmPubkey, { signatureScheme: this.signatureScheme });
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'switch_psm',
             saltHex: salt.toHex(),
@@ -311,6 +272,7 @@ export class Multisig {
         const proposalId = computeCommitmentFromTxSummary(summaryBase64);
         const proposal = {
             id: proposalId,
+            commitment: proposalId,
             accountId: this._accountId,
             nonce: proposalNonce,
             status: { type: 'pending', signaturesCollected: 0, signaturesRequired: this.threshold, signers: [] },
@@ -319,46 +281,34 @@ export class Multisig {
             metadata,
         };
         this.proposals.set(proposal.id, proposal);
-        return proposal;
+        const proposals = this.listTransactionProposals();
+        return { proposal, proposals };
     }
-    /**
-     * Create a "consume notes" proposal to consume notes sent to the multisig account.
-     *
-     * @param noteIds - IDs of the notes to consume (hex strings)
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     */
-    async createConsumeNotesProposal(noteIds, nonce) {
+    async createConsumeNotesProposal(noteIds, options) {
         if (noteIds.length === 0) {
             throw new Error('At least one note ID is required');
         }
         const { request, salt } = buildConsumeNotesTransactionRequest(noteIds);
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'consume_notes',
             noteIds,
             saltHex: salt.toHex(),
             description: `Consume ${noteIds.length} note(s)`,
         };
-        return this.createProposal(proposalNonce, summaryBase64, metadata);
-    }
-    /**
-     * Create a P2ID proposal to send funds to another account.
-     *
-     * @param recipientId - Account ID of the recipient (hex string)
-     * @param faucetId - Faucet/token account ID (hex string)
-     * @param amount - Amount to send
-     * @param nonce - Optional proposal nonce (defaults to Date.now())
-     */
-    async createP2idProposal(recipientId, faucetId, amount, nonce) {
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return this.syncAfterCreate(proposal);
+    }
+    async createSendProposal(recipientId, faucetId, amount, options) {
         if (amount <= 0n) {
             throw new Error('Amount must be greater than 0');
         }
         const { request, salt } = buildP2idTransactionRequest(this._accountId, recipientId, faucetId, amount);
         const summary = await executeForSummary(this.webClient, this._accountId, request);
         const summaryBase64 = uint8ArrayToBase64(summary.serialize());
-        const proposalNonce = nonce ?? Date.now();
+        const proposalNonce = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'p2id',
             saltHex: salt.toHex(),
@@ -367,31 +317,22 @@ export class Multisig {
             amount: amount.toString(),
             description: `Send ${amount} to ${recipientId.slice(0, 10)}...`,
         };
-        return this.createProposal(proposalNonce, summaryBase64, metadata);
-    }
-    /**
-     * Get notes that can be consumed by this multisig account.
-     *
-     * Returns a list of notes that are committed on-chain and can be consumed
-     * immediately by the multisig account.
-     */
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return this.syncAfterCreate(proposal);
+    }
     async getConsumableNotes() {
         const accountId = AccountId.fromHex(this._accountId);
-        // Get consumable notes for this account
         const consumableRecords = await this.webClient.getConsumableNotes(accountId);
-        // Convert to our simplified ConsumableNote type
         const notes = [];
         for (const record of consumableRecords) {
             const inputNote = record.inputNoteRecord();
             const consumability = record.noteConsumability();
-            // Only include notes that can be consumed now (consumableAfterBlock is undefined/null)
             const canConsumeNow = consumability.some((c) => c.accountId().toString().toLowerCase() === this._accountId.toLowerCase() &&
                 c.consumableAfterBlock() === undefined);
             if (canConsumeNow) {
                 const noteId = inputNote.id().toString();
                 const details = inputNote.details();
                 const fungibleAssets = details.assets().fungibleAssets();
-                // Extract assets
                 const assets = [];
                 for (const asset of fungibleAssets) {
                     assets.push({
@@ -404,42 +345,47 @@ export class Multisig {
         }
         return notes;
     }
-    /**
-     * Sign a proposal.
-     *
-     * The proposalId is the tx_summary commitment hex, which is what gets signed.
-     * This matches the Rust client behavior where proposal.id == tx_summary.to_commitment().
-     *
-     * @param proposalId - The proposal commitment/ID (this is also what gets signed)
-     */
-    async signProposal(proposalId) {
-        const existingProposal = this.proposals.get(proposalId);
-        const signatureHex = this.signer.signCommitment(proposalId);
-        const signature = {
-            scheme: 'falcon',
-            signature: signatureHex,
-        };
+    async signTransactionProposal(commitment) {
+        const existingProposal = this.proposals.get(commitment);
+        const signatureHex = this.signer.signCommitment(commitment);
+        const signature = this.signer.scheme === 'ecdsa'
+            ? { scheme: 'ecdsa', signature: signatureHex, publicKey: this.signer.publicKey }
+            : { scheme: 'falcon', signature: signatureHex };
         const delta = await this.psm.signDeltaProposal({
             accountId: this._accountId,
-            commitment: proposalId,
+            commitment,
             signature,
         });
-        const proposal = this.deltaToProposal(delta, proposalId, undefined, existingProposal?.signatures);
+        const proposal = this.deltaToProposal(delta, commitment, undefined, existingProposal?.signatures);
         if (existingProposal?.metadata) {
             proposal.metadata = existingProposal.metadata;
         }
         this.proposals.set(proposal.id, proposal);
-        return proposal;
+        return this.syncTransactionProposals();
     }
-    /**
-     * Execute a proposal that has enough signatures.
-     *
-     * @param proposalId - The proposal commitment/ID
-     */
-    async executeProposal(proposalId) {
-        const proposal = this.proposals.get(proposalId);
+    async signTransactionProposalExternal(params) {
+        const { commitment, signature: signatureHex, publicKey, scheme } = params;
+        const resolvedScheme = scheme ?? this.signatureScheme;
+        const existingProposal = this.proposals.get(commitment);
+        const signature = resolvedScheme === 'ecdsa'
+            ? { scheme: 'ecdsa', signature: signatureHex, publicKey: publicKey }
+            : { scheme: 'falcon', signature: signatureHex };
+        const delta = await this.psm.signDeltaProposal({
+            accountId: this._accountId,
+            commitment,
+            signature,
+        });
+        const proposal = this.deltaToProposal(delta, commitment, undefined, existingProposal?.signatures);
+        if (existingProposal?.metadata) {
+            proposal.metadata = existingProposal.metadata;
+        }
+        this.proposals.set(proposal.id, proposal);
+        return this.syncTransactionProposals();
+    }
+    async executeTransactionProposal(commitment) {
+        const proposal = this.proposals.get(commitment);
         if (!proposal) {
-            throw new Error(`Proposal not found: ${proposalId}`);
+            throw new Error(`Proposal not found: ${commitment}`);
         }
         const proposalType = proposal.metadata?.proposalType;
         const effectiveThreshold = proposalType
@@ -456,9 +402,9 @@ export class Multisig {
         }
         else {
             const deltas = await this.psm.getDeltaProposals(this._accountId);
-            delta = deltas.find((d) => computeCommitmentFromTxSummary(d.deltaPayload.txSummary.data) === proposalId);
+            delta = deltas.find((d) => computeCommitmentFromTxSummary(d.deltaPayload.txSummary.data) === commitment);
             if (!delta) {
-                throw new Error(`Proposal not found on server: ${proposalId}`);
+                throw new Error(`Proposal not found on server: ${commitment}`);
             }
             txSummaryBase64 = delta.deltaPayload.txSummary.data;
         }
@@ -467,12 +413,24 @@ export class Multisig {
         const saltHex = txSummary.salt().toHex();
         const txCommitmentHex = txSummary.toCommitment().toHex();
         const adviceMap = new AdviceMap();
+        const normalizedSignerCommitments = new Set(this.signerCommitments.map((c) => normalizeHexWord(c)));
         for (const cosignerSig of proposal.signatures) {
-            const signerCommitment = Word.fromHex(normalizeHexWord(cosignerSig.signerId));
-            const sigBytes = signatureHexToBytes(cosignerSig.signature.signature);
+            let signerCommitmentHex = normalizeHexWord(cosignerSig.signerId);
+            if (cosignerSig.signature.scheme === 'ecdsa' && cosignerSig.signature.publicKey) {
+                const derived = tryComputeEcdsaCommitmentHex(cosignerSig.signature.publicKey);
+                if (derived && derived !== signerCommitmentHex) {
+                    if (!normalizedSignerCommitments.has(derived)) {
+                        throw new Error(`ECDSA public key commitment mismatch: derived commitment ${derived} is not in signerCommitments.`);
+                    }
+                    signerCommitmentHex = derived;
+                }
+            }
+            const signerCommitment = Word.fromHex(signerCommitmentHex);
+            const sigBytes = signatureHexToBytes(cosignerSig.signature.signature, cosignerSig.signature.scheme);
             const signature = Signature.deserialize(sigBytes);
             const txCommitment = Word.fromHex(normalizeHexWord(txCommitmentHex));
-            const { key, values } = buildSignatureAdviceEntry(signerCommitment, txCommitment, signature);
+            const isEcdsa = cosignerSig.signature.scheme === 'ecdsa' && cosignerSig.signature.publicKey;
+            const { key, values } = buildSignatureAdviceEntry(signerCommitment, txCommitment, signature, isEcdsa ? cosignerSig.signature.publicKey : undefined, isEcdsa ? cosignerSig.signature.signature : undefined);
             adviceMap.insert(key, new FeltArray(values));
         }
         if (!isSwitchPsm && delta) {
@@ -485,11 +443,21 @@ export class Multisig {
             if (!ackSigHex) {
                 throw new Error('PSM did not return acknowledgment signature');
             }
-            const psmCommitment = Word.fromHex(normalizeHexWord(this.psmCommitment));
-            const ackSigBytes = signatureHexToBytes(ackSigHex);
+            const psmAckScheme = pushResult.ackScheme || this.signatureScheme;
+            const psmAckPubkey = pushResult.ackPubkey || this.psmPublicKey;
+            const psmCommitmentHex = normalizeHexWord(this.psmCommitment);
+            if (psmAckScheme === 'ecdsa' && psmAckPubkey) {
+                const derived = tryComputeEcdsaCommitmentHex(psmAckPubkey);
+                if (derived && derived !== psmCommitmentHex) {
+                    throw new Error(`PSM public key commitment mismatch`);
+                }
+            }
+            const psmCommitment = Word.fromHex(psmCommitmentHex);
+            const ackSigBytes = signatureHexToBytes(ackSigHex, psmAckScheme);
             const ackSignature = Signature.deserialize(ackSigBytes);
             const txCommitmentForAck = Word.fromHex(normalizeHexWord(txCommitmentHex));
-            const { key: ackKey, values: ackValues } = buildSignatureAdviceEntry(psmCommitment, txCommitmentForAck, ackSignature);
+            const isAckEcdsa = psmAckScheme === 'ecdsa' && psmAckPubkey;
+            const { key: ackKey, values: ackValues } = buildSignatureAdviceEntry(psmCommitment, txCommitmentForAck, ackSignature, isAckEcdsa ? psmAckPubkey : undefined, isAckEcdsa ? ackSigHex : undefined);
             adviceMap.insert(ackKey, new FeltArray(ackValues));
         }
         const metadata = proposal.metadata;
@@ -510,7 +478,11 @@ export class Multisig {
                 if (!metadata.newPsmPubkey) {
                     throw new Error('Proposal missing newPsmPubkey. Was it created with createSwitchPsmProposal?');
                 }
-                const { request } = await buildUpdatePsmTransactionRequest(this.webClient, metadata.newPsmPubkey, { salt: Word.fromHex(normalizeHexWord(saltHex)), signatureAdviceMap: adviceMap });
+                const { request } = await buildUpdatePsmTransactionRequest(this.webClient, metadata.newPsmPubkey, {
+                    salt: Word.fromHex(normalizeHexWord(saltHex)),
+                    signatureAdviceMap: adviceMap,
+                    signatureScheme: this.signatureScheme,
+                });
                 finalRequest = request;
                 break;
             }
@@ -526,7 +498,11 @@ export class Multisig {
                 throw new Error('Cannot execute proposal with unknown type. The proposal must have been imported without proper metadata.');
             }
             default: {
-                const { request } = await buildUpdateSignersTransactionRequest(this.webClient, metadata.targetThreshold, metadata.targetSignerCommitments, { salt: Word.fromHex(normalizeHexWord(saltHex)), signatureAdviceMap: adviceMap });
+                const { request } = await buildUpdateSignersTransactionRequest(this.webClient, metadata.targetThreshold, metadata.targetSignerCommitments, {
+                    salt: Word.fromHex(normalizeHexWord(saltHex)),
+                    signatureAdviceMap: adviceMap,
+                    signatureScheme: this.signatureScheme,
+                });
                 finalRequest = request;
                 break;
             }
@@ -538,39 +514,10 @@ export class Multisig {
         await this.webClient.applyTransaction(result, submissionHeight);
         proposal.status = { type: 'finalized' };
     }
-    /**
-     * Export a proposal for offline signing
-     */
-    async exportProposal(proposalId) {
-        const deltas = await this.psm.getDeltaProposals(this._accountId);
-        const delta = deltas.find((d) => computeCommitmentFromTxSummary(d.deltaPayload.txSummary.data) === proposalId);
-        if (!delta) {
-            throw new Error(`Proposal not found: ${proposalId}`);
-        }
-        const signatures = delta.status.status === 'pending'
-            ? delta.status.cosignerSigs.map((s) => ({
-                commitment: s.signerId,
-                signatureHex: s.signature.signature,
-            }))
-            : [];
-        return {
-            accountId: delta.accountId,
-            nonce: delta.nonce,
-            commitment: proposalId,
-            txSummaryBase64: delta.deltaPayload.txSummary.data,
-            signatures,
-        };
-    }
-    /**
-     * Export a proposal to JSON for side-channel sharing.
-     *
-     * @param proposalId - The proposal commitment/ID
-     * @returns JSON string that can be shared and imported by other signers
-     */
-    exportProposalToJson(proposalId) {
-        const proposal = this.proposals.get(proposalId);
+    exportTransactionProposalToJson(commitment) {
+        const proposal = this.proposals.get(commitment);
         if (!proposal) {
-            throw new Error(`Proposal not found in local cache: ${proposalId}`);
+            throw new Error(`Proposal not found in local cache: ${commitment}`);
         }
         const exported = {
             accountId: proposal.accountId,
@@ -586,13 +533,7 @@ export class Multisig {
         };
         return JSON.stringify(exported, null, 2);
     }
-    /**
-     * Import a proposal from JSON (exported via exportProposalToJson).
-     *
-     * @param json - JSON string from exportProposalToJson
-     * @returns The imported proposal
-     */
-    importProposal(json) {
+    importTransactionProposal(json) {
         const exported = JSON.parse(json);
         if (!exported.accountId || !exported.txSummaryBase64 || !exported.commitment) {
             throw new Error('Invalid proposal JSON: missing required fields');
@@ -620,45 +561,40 @@ export class Multisig {
             };
         const proposal = {
             id: exported.commitment,
+            commitment: exported.commitment,
             accountId: exported.accountId,
             nonce: exported.nonce,
             status,
             txSummary: exported.txSummaryBase64,
             signatures: exported.signatures.map((s) => ({
                 signerId: s.commitment,
-                signature: { scheme: 'falcon', signature: s.signatureHex },
+                signature: { scheme: this.signer.scheme, signature: s.signatureHex },
                 timestamp: s.timestamp || new Date().toISOString(),
             })),
             metadata,
         };
         this.proposals.set(proposal.id, proposal);
-        return proposal;
+        const proposals = this.listTransactionProposals();
+        return { proposal, proposals };
     }
-    /**
-     * Sign an imported proposal and return updated JSON for sharing..
-     *
-     * @param proposalId - The proposal commitment/ID
-     * @returns Updated JSON string with the new signature included
-     */
-    signProposalOffline(proposalId) {
-        const proposal = this.proposals.get(proposalId);
+    signTransactionProposalOffline(commitment) {
+        const proposal = this.proposals.get(commitment);
         if (!proposal) {
-            throw new Error(`Proposal not found: ${proposalId}`);
+            throw new Error(`Proposal not found: ${commitment}`);
         }
-        // Check if already signed
         const alreadySigned = proposal.signatures.some((s) => s.signerId.toLowerCase() === this.signer.commitment.toLowerCase());
         if (alreadySigned) {
             throw new Error('You have already signed this proposal');
         }
-        // Sign the commitment
-        const signatureHex = this.signer.signCommitment(proposalId);
-        // Add signature to local proposal
+        const signatureHex = this.signer.signCommitment(commitment);
+        const sigEntry = this.signer.scheme === 'ecdsa'
+            ? { scheme: 'ecdsa', signature: signatureHex, publicKey: this.signer.publicKey }
+            : { scheme: 'falcon', signature: signatureHex };
         proposal.signatures.push({
             signerId: this.signer.commitment,
-            signature: { scheme: 'falcon', signature: signatureHex },
+            signature: sigEntry,
             timestamp: new Date().toISOString(),
         });
-        // Update status
         const signaturesCollected = proposal.signatures.length;
         const proposalType = proposal.metadata?.proposalType;
         const effectiveThreshold = proposalType
@@ -675,8 +611,20 @@ export class Multisig {
                 signers: proposal.signatures.map((s) => s.signerId),
             };
         }
-        // Return updated JSON
-        return this.exportProposalToJson(proposalId);
+        return this.exportTransactionProposalToJson(commitment);
+    }
+    async syncAfterCreate(proposal) {
+        let proposals;
+        try {
+            proposals = await this.syncTransactionProposals();
+            if (!proposals.find((p) => p.id === proposal.id)) {
+                proposals = [...proposals, proposal];
+            }
+        }
+        catch {
+            proposals = this.listTransactionProposals();
+        }
+        return { proposal, proposals };
     }
     deltaToProposal(delta, proposalId, metadata, existingSignatures) {
         const resolvedMetadata = metadata ??
@@ -702,6 +650,7 @@ export class Multisig {
         const signatures = Array.from(signaturesMap.values());
         return {
             id: proposalId,
+            commitment: proposalId,
             accountId: delta.accountId,
             nonce: delta.nonce,
             status,