@openzeppelin/miden-multisig-client 0.12.7 → 0.13.0

package/dist/multisig.js

@@ -1,9 +1,11 @@
 import { AccountInspector } from './inspector.js';
-import { Account, AccountId, AdviceMap, FeltArray, Signature, TransactionSummary, Word, } from '@demox-labs/miden-sdk';
+import { Account, AccountId, } from '@miden-sdk/miden-sdk';
 import { executeForSummary, buildUpdateSignersTransactionRequest, buildUpdatePsmTransactionRequest, buildConsumeNotesTransactionRequest, buildP2idTransactionRequest, } from './transaction.js';
 import { base64ToUint8Array, uint8ArrayToBase64, normalizeHexWord, } from './utils/encoding.js';
-import { buildSignatureAdviceEntry, signatureHexToBytes, tryComputeEcdsaCommitmentHex } from './utils/signature.js';
 import { computeCommitmentFromTxSummary, accountIdToHex } from './multisig/helpers.js';
+import { buildPsmMetadata, deltaToProposal, resolveMetadata, signatureRequirementForProposal, } from './multisig/proposal/parser.js';
+import { toPsmSignature, buildPsmSignatureFromSigner, } from './multisig/signing.js';
+import { executeProposalWorkflow } from './multisig/proposal/execution.js';
 export class Multisig {
     account;
     threshold;
@@ -125,8 +127,7 @@ export class Multisig {
             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.`);
+                throw new Error(`PSM commitment mismatch: on-chain=${onChain}, server=${server}`);
             }
         }
     }
@@ -135,6 +136,12 @@ export class Multisig {
         const state = await this.syncState();
         const notes = await this.getConsumableNotes();
         const config = AccountInspector.fromBase64(state.stateDataBase64, this.signatureScheme);
+        this.threshold = config.threshold;
+        this.signerCommitments = config.signerCommitments;
+        if (config.psmCommitment) {
+            this.psmCommitment = config.psmCommitment;
+        }
+        this.procedureThresholds = config.procedureThresholds;
         return { proposals, state, notes, config };
     }
     async getAccountConfig() {
@@ -142,9 +149,38 @@ export class Multisig {
         return AccountInspector.fromBase64(state.stateDataBase64, this.signatureScheme);
     }
     async switchPsm(psmClient) {
+        const accountId = AccountId.fromHex(this._accountId);
+        const localAccount = await this.webClient.getAccount(accountId);
+        if (localAccount) {
+            this.account = localAccount;
+            const config = AccountInspector.fromAccount(localAccount, this.signatureScheme);
+            if (config.psmCommitment) {
+                this.psmCommitment = config.psmCommitment;
+            }
+            this.threshold = config.threshold;
+            this.signerCommitments = config.signerCommitments;
+            this.procedureThresholds = config.procedureThresholds;
+        }
         this.setPsmClient(psmClient);
-        const state = await this.fetchState();
-        await this.registerOnPsm(state.stateDataBase64);
+        const accountBytes = this.account.serialize();
+        const stateData = uint8ArrayToBase64(accountBytes);
+        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,
+            initialState: { data: stateData, accountId: this._accountId },
+        });
+        if (!response.success) {
+            throw new Error(`Failed to register on PSM: ${response.message}`);
+        }
+        if (response.ackCommitment) {
+            this.psmCommitment = normalizeHexWord(response.ackCommitment);
+        }
+        if (response.ackPubkey) {
+            this.psmPublicKey = response.ackPubkey;
+        }
     }
     async syncTransactionProposals() {
         const deltas = await this.psm.getDeltaProposals(this._accountId);
@@ -153,14 +189,17 @@ export class Multisig {
             const proposalId = computeCommitmentFromTxSummary(delta.deltaPayload.txSummary.data);
             serverProposalIds.add(proposalId);
             const existingProposal = this.proposals.get(proposalId);
-            const resolvedMetadata = existingProposal?.metadata ??
-                (delta.deltaPayload.metadata
-                    ? this.fromPsmMetadata(delta.deltaPayload.metadata)
-                    : undefined);
+            const resolvedMetadata = resolveMetadata(delta, existingProposal?.metadata);
             if (!resolvedMetadata) {
                 throw new Error('Missing proposal metadata from PSM');
             }
-            const proposal = this.deltaToProposal(delta, proposalId, resolvedMetadata, existingProposal?.signatures);
+            const proposal = deltaToProposal({
+                delta,
+                proposalId,
+                metadata: resolvedMetadata,
+                signaturesRequired: signatureRequirementForProposal(resolvedMetadata, this.threshold, (proposalType) => this.getEffectiveThreshold(proposalType)),
+                existingSignatures: existingProposal?.signatures,
+            });
             this.proposals.set(proposal.id, proposal);
         }
         for (const [id, proposal] of this.proposals) {
@@ -177,7 +216,7 @@ export class Multisig {
         return Array.from(this.proposals.values());
     }
     async createProposal(nonce, txSummaryBase64, metadata) {
-        const psmMetadata = this.buildPsmMetadata(metadata);
+        const psmMetadata = buildPsmMetadata(metadata);
         const response = await this.psm.pushDeltaProposal({
             accountId: this._accountId,
             nonce,
@@ -187,7 +226,12 @@ export class Multisig {
                 metadata: psmMetadata,
             },
         });
-        const proposal = this.deltaToProposal(response.delta, response.commitment, metadata);
+        const proposal = deltaToProposal({
+            delta: response.delta,
+            proposalId: response.commitment,
+            metadata,
+            signaturesRequired: signatureRequirementForProposal(metadata, this.threshold, (proposalType) => this.getEffectiveThreshold(proposalType)),
+        });
         this.proposals.set(proposal.id, proposal);
         return proposal;
     }
@@ -195,9 +239,6 @@ export class Multisig {
         const targetThreshold = options?.newThreshold ?? this.threshold;
         const targetSignerCommitments = [...this.signerCommitments, newCommitment];
         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 = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'add_signer',
             targetThreshold,
@@ -205,8 +246,7 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Add signer ${newCommitment.slice(0, 10)}...`,
         };
-        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
-        return this.syncAfterCreate(proposal);
+        return this.createAndSyncFromRequest(request, metadata, options?.nonce);
     }
     async createRemoveSignerProposal(signerToRemove, options) {
         const normalizedRemove = signerToRemove.toLowerCase();
@@ -223,9 +263,6 @@ export class Multisig {
             throw new Error(`Invalid threshold ${targetThreshold}. Must be between 1 and ${targetSignerCommitments.length}`);
         }
         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 = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'remove_signer',
             targetThreshold,
@@ -233,8 +270,7 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Remove signer ${signerToRemove.slice(0, 10)}...`,
         };
-        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
-        return this.syncAfterCreate(proposal);
+        return this.createAndSyncFromRequest(request, metadata, options?.nonce);
     }
     async createChangeThresholdProposal(newThreshold, options) {
         if (newThreshold < 1 || newThreshold > this.signerCommitments.length) {
@@ -244,9 +280,6 @@ export class Multisig {
             throw new Error('New threshold is the same as current threshold');
         }
         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 = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'change_threshold',
             targetThreshold: newThreshold,
@@ -254,8 +287,7 @@ export class Multisig {
             saltHex: salt.toHex(),
             description: `Change threshold from ${this.threshold} to ${newThreshold}`,
         };
-        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
-        return this.syncAfterCreate(proposal);
+        return this.createAndSyncFromRequest(request, metadata, options?.nonce);
     }
     async createSwitchPsmProposal(newPsmEndpoint, newPsmPubkey, options) {
         const { request, salt } = await buildUpdatePsmTransactionRequest(this.webClient, newPsmPubkey, { signatureScheme: this.signatureScheme });
@@ -288,27 +320,20 @@ export class Multisig {
         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 = options?.nonce ?? Date.now();
+        const { request, salt } = await buildConsumeNotesTransactionRequest(this.webClient, noteIds);
         const metadata = {
             proposalType: 'consume_notes',
             noteIds,
             saltHex: salt.toHex(),
             description: `Consume ${noteIds.length} note(s)`,
         };
-        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
-        return this.syncAfterCreate(proposal);
+        return this.createAndSyncFromRequest(request, metadata, options?.nonce);
     }
     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 = options?.nonce ?? Date.now();
         const metadata = {
             proposalType: 'p2id',
             saltHex: salt.toHex(),
@@ -317,8 +342,7 @@ export class Multisig {
             amount: amount.toString(),
             description: `Send ${amount} to ${recipientId.slice(0, 10)}...`,
         };
-        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
-        return this.syncAfterCreate(proposal);
+        return this.createAndSyncFromRequest(request, metadata, options?.nonce);
     }
     async getConsumableNotes() {
         const accountId = AccountId.fromHex(this._accountId);
@@ -328,7 +352,7 @@ export class Multisig {
             const inputNote = record.inputNoteRecord();
             const consumability = record.noteConsumability();
             const canConsumeNow = consumability.some((c) => c.accountId().toString().toLowerCase() === this._accountId.toLowerCase() &&
-                c.consumableAfterBlock() === undefined);
+                c.consumptionStatus().consumableAfterBlock() === undefined);
             if (canConsumeNow) {
                 const noteId = inputNote.id().toString();
                 const details = inputNote.details();
@@ -347,171 +371,67 @@ export class Multisig {
     }
     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 signature = await buildPsmSignatureFromSigner(this.signer, commitment);
         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;
+        const resolvedMetadata = resolveMetadata(delta, existingProposal?.metadata);
+        if (!resolvedMetadata) {
+            throw new Error('Missing proposal metadata');
         }
+        const proposal = deltaToProposal({
+            delta,
+            proposalId: commitment,
+            metadata: resolvedMetadata,
+            signaturesRequired: signatureRequirementForProposal(resolvedMetadata, this.threshold, (proposalType) => this.getEffectiveThreshold(proposalType)),
+            existingSignatures: existingProposal?.signatures,
+        });
         this.proposals.set(proposal.id, proposal);
-        return this.syncTransactionProposals();
+        return this.listTransactionProposals();
     }
     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 signature = toPsmSignature(resolvedScheme, signatureHex, publicKey);
         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;
+        const resolvedMetadata = resolveMetadata(delta, existingProposal?.metadata);
+        if (!resolvedMetadata) {
+            throw new Error('Missing proposal metadata');
         }
+        const proposal = deltaToProposal({
+            delta,
+            proposalId: commitment,
+            metadata: resolvedMetadata,
+            signaturesRequired: signatureRequirementForProposal(resolvedMetadata, this.threshold, (proposalType) => this.getEffectiveThreshold(proposalType)),
+            existingSignatures: existingProposal?.signatures,
+        });
         this.proposals.set(proposal.id, proposal);
-        return this.syncTransactionProposals();
+        return this.listTransactionProposals();
     }
     async executeTransactionProposal(commitment) {
         const proposal = this.proposals.get(commitment);
         if (!proposal) {
             throw new Error(`Proposal not found: ${commitment}`);
         }
-        const proposalType = proposal.metadata?.proposalType;
-        const effectiveThreshold = proposalType
-            ? this.getEffectiveThreshold(proposalType)
-            : this.threshold;
-        if (proposal.signatures.length < effectiveThreshold) {
-            throw new Error('Proposal is not ready for execution. Still pending signatures.');
-        }
-        const isSwitchPsm = proposalType === 'switch_psm';
-        let txSummaryBase64;
-        let delta;
-        if (isSwitchPsm) {
-            txSummaryBase64 = proposal.txSummary;
-        }
-        else {
-            const deltas = await this.psm.getDeltaProposals(this._accountId);
-            delta = deltas.find((d) => computeCommitmentFromTxSummary(d.deltaPayload.txSummary.data) === commitment);
-            if (!delta) {
-                throw new Error(`Proposal not found on server: ${commitment}`);
-            }
-            txSummaryBase64 = delta.deltaPayload.txSummary.data;
-        }
-        const txSummaryBytes = base64ToUint8Array(txSummaryBase64);
-        const txSummary = TransactionSummary.deserialize(txSummaryBytes);
-        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) {
-            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 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) {
-            const executionDelta = {
-                ...delta,
-                deltaPayload: delta.deltaPayload.txSummary,
-            };
-            const pushResult = await this.psm.pushDelta(executionDelta);
-            const ackSigHex = pushResult.ackSig;
-            if (!ackSigHex) {
-                throw new Error('PSM did not return acknowledgment signature');
-            }
-            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 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;
-        if (!metadata) {
-            throw new Error('Proposal missing metadata');
-        }
-        let finalRequest;
-        switch (metadata.proposalType) {
-            case 'consume_notes': {
-                if (!metadata.noteIds || metadata.noteIds.length === 0) {
-                    throw new Error('Proposal missing noteIds. Was it created with createConsumeNotesProposal?');
-                }
-                const { request } = buildConsumeNotesTransactionRequest(metadata.noteIds, { salt: Word.fromHex(normalizeHexWord(saltHex)), signatureAdviceMap: adviceMap });
-                finalRequest = request;
-                break;
-            }
-            case 'switch_psm': {
-                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,
-                    signatureScheme: this.signatureScheme,
-                });
-                finalRequest = request;
-                break;
-            }
-            case 'p2id': {
-                if (!metadata.recipientId || !metadata.faucetId || !metadata.amount) {
-                    throw new Error('Proposal missing P2ID metadata (recipientId, faucetId, amount). Was it created with createP2idProposal?');
-                }
-                const { request } = buildP2idTransactionRequest(this._accountId, metadata.recipientId, metadata.faucetId, BigInt(metadata.amount), { salt: Word.fromHex(normalizeHexWord(saltHex)), signatureAdviceMap: adviceMap });
-                finalRequest = request;
-                break;
-            }
-            case 'unknown': {
-                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,
-                    signatureScheme: this.signatureScheme,
-                });
-                finalRequest = request;
-                break;
-            }
-        }
-        const accountId = AccountId.fromHex(this._accountId);
-        const result = await this.webClient.executeTransaction(accountId, finalRequest);
-        const proven = await this.webClient.proveTransaction(result, null);
-        const submissionHeight = await this.webClient.submitProvenTransaction(proven, result);
-        await this.webClient.applyTransaction(result, submissionHeight);
+        await executeProposalWorkflow({
+            proposal,
+            accountId: this._accountId,
+            threshold: this.threshold,
+            signerCommitments: this.signerCommitments,
+            psmCommitment: this.psmCommitment,
+            psmPublicKey: this.psmPublicKey,
+            signatureScheme: this.signatureScheme,
+            getEffectiveThreshold: (proposalType) => this.getEffectiveThreshold(proposalType),
+            psm: this.psm,
+            webClient: this.webClient,
+        });
         proposal.status = { type: 'finalized' };
     }
     exportTransactionProposalToJson(commitment) {
@@ -577,7 +497,7 @@ export class Multisig {
         const proposals = this.listTransactionProposals();
         return { proposal, proposals };
     }
-    signTransactionProposalOffline(commitment) {
+    async signTransactionProposalOffline(commitment) {
         const proposal = this.proposals.get(commitment);
         if (!proposal) {
             throw new Error(`Proposal not found: ${commitment}`);
@@ -586,10 +506,8 @@ export class Multisig {
         if (alreadySigned) {
             throw new Error('You have already signed this 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 };
+        const signatureHex = await this.signer.signCommitment(commitment);
+        const sigEntry = toPsmSignature(this.signer.scheme, signatureHex, this.signer.publicKey);
         proposal.signatures.push({
             signerId: this.signer.commitment,
             signature: sigEntry,
@@ -613,158 +531,12 @@ export class Multisig {
         }
         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 ??
-            (delta.deltaPayload.metadata ? this.fromPsmMetadata(delta.deltaPayload.metadata) : undefined);
-        if (!resolvedMetadata) {
-            throw new Error('Missing proposal metadata');
-        }
-        const status = this.deltaStatusToProposalStatus(delta.status, resolvedMetadata.proposalType);
-        const signaturesFromStatus = delta.status.status === 'pending'
-            ? delta.status.cosignerSigs.map((s) => ({
-                signerId: s.signerId,
-                signature: s.signature,
-                timestamp: s.timestamp,
-            }))
-            : [];
-        const signaturesMap = new Map();
-        for (const sig of existingSignatures ?? []) {
-            signaturesMap.set(sig.signerId, sig);
-        }
-        for (const sig of signaturesFromStatus) {
-            signaturesMap.set(sig.signerId, sig);
-        }
-        const signatures = Array.from(signaturesMap.values());
-        return {
-            id: proposalId,
-            commitment: proposalId,
-            accountId: delta.accountId,
-            nonce: delta.nonce,
-            status,
-            txSummary: delta.deltaPayload.txSummary.data,
-            signatures,
-            metadata: resolvedMetadata,
-        };
-    }
-    buildPsmMetadata(metadata) {
-        const base = {
-            proposalType: metadata.proposalType,
-            description: metadata.description,
-            salt: metadata.saltHex,
-        };
-        switch (metadata.proposalType) {
-            case 'consume_notes':
-                return {
-                    ...base,
-                    noteIds: metadata.noteIds,
-                };
-            case 'p2id':
-                return {
-                    ...base,
-                    recipientId: metadata.recipientId,
-                    faucetId: metadata.faucetId,
-                    amount: metadata.amount,
-                };
-            case 'switch_psm':
-                return {
-                    ...base,
-                    targetThreshold: metadata.targetThreshold,
-                    signerCommitments: metadata.targetSignerCommitments,
-                    newPsmPubkey: metadata.newPsmPubkey,
-                    newPsmEndpoint: metadata.newPsmEndpoint,
-                };
-            case 'add_signer':
-            case 'remove_signer':
-            case 'change_threshold':
-                return {
-                    ...base,
-                    targetThreshold: metadata.targetThreshold,
-                    signerCommitments: metadata.targetSignerCommitments,
-                };
-            case 'unknown':
-                return base;
-        }
-    }
-    fromPsmMetadata(psm) {
-        if (!psm.proposalType)
-            return undefined;
-        const base = {
-            description: psm.description ?? '',
-            saltHex: psm.salt,
-        };
-        switch (psm.proposalType) {
-            case 'p2id':
-                return {
-                    ...base,
-                    proposalType: 'p2id',
-                    recipientId: psm.recipientId ?? '',
-                    faucetId: psm.faucetId ?? '',
-                    amount: psm.amount ?? '0',
-                };
-            case 'consume_notes':
-                return {
-                    ...base,
-                    proposalType: 'consume_notes',
-                    noteIds: psm.noteIds ?? [],
-                };
-            case 'switch_psm':
-                return {
-                    ...base,
-                    proposalType: 'switch_psm',
-                    newPsmPubkey: psm.newPsmPubkey ?? '',
-                    newPsmEndpoint: psm.newPsmEndpoint,
-                    targetThreshold: psm.targetThreshold,
-                    targetSignerCommitments: psm.signerCommitments,
-                };
-            case 'add_signer':
-            case 'remove_signer':
-            case 'change_threshold':
-                return {
-                    ...base,
-                    proposalType: psm.proposalType,
-                    targetThreshold: psm.targetThreshold ?? 0,
-                    targetSignerCommitments: psm.signerCommitments ?? [],
-                };
-            default:
-                return undefined;
-        }
-    }
-    deltaStatusToProposalStatus(status, proposalType) {
-        switch (status.status) {
-            case 'pending': {
-                const signaturesCollected = status.cosignerSigs.length;
-                const signaturesRequired = proposalType
-                    ? this.getEffectiveThreshold(proposalType)
-                    : this.threshold;
-                if (signaturesCollected >= signaturesRequired) {
-                    return { type: 'ready' };
-                }
-                return {
-                    type: 'pending',
-                    signaturesCollected,
-                    signaturesRequired,
-                    signers: status.cosignerSigs.map((s) => s.signerId),
-                };
-            }
-            case 'candidate':
-                return { type: 'ready' };
-            case 'canonical':
-            case 'discarded':
-                return { type: 'finalized' };
-        }
+    async createAndSyncFromRequest(request, metadata, nonce) {
+        const summary = await executeForSummary(this.webClient, this._accountId, request);
+        const summaryBase64 = uint8ArrayToBase64(summary.serialize());
+        const proposalNonce = nonce ?? Date.now();
+        const proposal = await this.createProposal(proposalNonce, summaryBase64, metadata);
+        return { proposal, proposals: this.listTransactionProposals() };
     }
 }
 //# sourceMappingURL=multisig.js.map