@openzeppelin/miden-multisig-client 0.13.3 → 0.14.3

package/dist/multisig.test.js

@@ -41,7 +41,7 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
         insert: vi.fn(),
     })),
     FeltArray: vi.fn().mockImplementation((arr) => arr),
-    Rpo256: {
+    Poseidon2: {
         hashElements: vi.fn().mockReturnValue({
             toHex: () => '0x' + 'e'.repeat(64),
         }),
@@ -108,6 +108,9 @@ function mockedAccount(commitmentHex, nonce = 0) {
         commitment: () => ({
             toHex: () => commitmentHex,
         }),
+        to_commitment: () => ({
+            toHex: () => commitmentHex,
+        }),
         nonce: () => ({
             asInt: () => BigInt(nonce),
         }),
@@ -167,6 +170,11 @@ describe('Multisig', () => {
             proveTransaction: vi.fn(),
             submitProvenTransaction: vi.fn(),
             applyTransaction: vi.fn(),
+            submitNewTransaction: vi.fn(),
+            submitNewTransactionWithProver: vi.fn(),
+            transactions: {
+                submit: vi.fn(),
+            },
             getConsumableNotes: vi.fn().mockResolvedValue([]),
             syncState: vi.fn(),
             getAccount: vi.fn().mockResolvedValue(null),
@@ -310,11 +318,7 @@ describe('Multisig', () => {
                 guardianCommitment: '0x' + 'c'.repeat(64),
             };
             const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
-            mockWebClient.getAccount.mockResolvedValueOnce({
-                commitment: () => ({
-                    toHex: () => '0x' + 'b'.repeat(64),
-                }),
-            });
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'b'.repeat(64), 0));
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
@@ -444,11 +448,7 @@ describe('Multisig', () => {
                 signerCommitments: ['0x' + 'a'.repeat(64)],
                 guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            mockWebClient.getAccount.mockResolvedValueOnce({
-                commitment: () => ({
-                    toHex: () => '0x' + 'b'.repeat(64),
-                }),
-            });
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'b'.repeat(64), 0));
             const multisigWithRpc = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
             await expect(multisigWithRpc.verifyStateCommitment()).resolves.toMatchObject({
                 accountId: multisigWithRpc.accountId,
@@ -470,11 +470,7 @@ describe('Multisig', () => {
                 signerCommitments: ['0x' + 'a'.repeat(64)],
                 guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            mockWebClient.getAccount.mockResolvedValueOnce({
-                commitment: () => ({
-                    toHex: () => '0x' + 'f'.repeat(64),
-                }),
-            });
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'f'.repeat(64), 0));
             mockRpcGetAccountDetails.mockResolvedValueOnce({
                 commitment: () => ({
                     toHex: () => '0x' + 'b'.repeat(64),
@@ -1638,6 +1634,470 @@ describe('Multisig', () => {
             expect(mockSigner.signCommitment).not.toHaveBeenCalled();
         });
     });
+    describe('createTransactionProposalRequest', () => {
+        it('should return a ready non-switch_guardian request without executing it', async () => {
+            const { buildSignatureAdviceEntry, signatureHexToBytes } = await import('./utils/signature.js');
+            vi.mocked(signatureHexToBytes).mockClear();
+            vi.mocked(buildSignatureAdviceEntry).mockClear();
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+                guardianPublicKey: '0x' + '1'.repeat(66),
+            };
+            const ecdsaSigner = {
+                ...mockSigner,
+                scheme: 'ecdsa',
+                publicKey: '0x' + '2'.repeat(66),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, ecdsaSigner, mockWebClient);
+            const cachedProposalId = '0x' + 'c'.repeat(64);
+            const requestedProposalId = '0x' + 'C'.repeat(64);
+            const cosignerPubkey = '0x' + '3'.repeat(66);
+            const ackPubkey = '0x' + '4'.repeat(66);
+            const cosignerSignature = '0x' + '5'.repeat(130);
+            const ackSignature = '0x' + '6'.repeat(130);
+            const finalRequest = { kind: 'final-change-threshold-request' };
+            vi.mocked(buildUpdateSignersTransactionRequest)
+                .mockResolvedValueOnce({
+                request: { kind: 'verify-change-threshold-request' },
+                salt: { toHex: () => '0x' + 'd'.repeat(64) },
+                configHash: { toHex: () => '0x' + 'e'.repeat(64) },
+            })
+                .mockResolvedValueOnce({
+                request: finalRequest,
+                salt: { toHex: () => '0x' + 'd'.repeat(64) },
+                configHash: { toHex: () => '0x' + 'e'.repeat(64) },
+            });
+            multisig.proposals.set(cachedProposalId, {
+                id: cachedProposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: {
+                            scheme: 'ecdsa',
+                            signature: cosignerSignature,
+                            publicKey: cosignerPubkey,
+                        },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'change_threshold',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    nonce: 1,
+                    prev_commitment: '0x' + 'b'.repeat(64),
+                    delta_payload: {
+                        tx_summary: { data: 'AQID' },
+                        signatures: [],
+                        metadata: {
+                            proposal_type: 'change_threshold',
+                            target_threshold: 1,
+                            signer_commitments: ['0x' + 'a'.repeat(64)],
+                        },
+                    },
+                    status: {
+                        status: 'pending',
+                        timestamp: '2024-01-01T00:00:00Z',
+                        proposer_id: '0x' + 'a'.repeat(64),
+                        cosigner_sigs: [],
+                    },
+                }),
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    nonce: 1,
+                    ack_sig: ackSignature,
+                    ack_pubkey: ackPubkey,
+                    ack_scheme: 'ecdsa',
+                }),
+            });
+            await expect(multisig.createTransactionProposalRequest(requestedProposalId)).resolves.toBe(finalRequest);
+            expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(1, cosignerSignature, 'ecdsa');
+            expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(2, ackSignature, 'ecdsa');
+            expect(vi.mocked(buildSignatureAdviceEntry)).toHaveBeenNthCalledWith(1, expect.anything(), expect.anything(), expect.anything(), cosignerPubkey, cosignerSignature);
+            expect(vi.mocked(buildSignatureAdviceEntry)).toHaveBeenNthCalledWith(2, expect.anything(), expect.anything(), expect.anything(), ackPubkey, ackSignature);
+            expect(mockWebClient.executeTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.proveTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.submitProvenTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.applyTransaction).not.toHaveBeenCalled();
+        });
+        it('should return a ready switch_guardian request without executing it', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'c'.repeat(64);
+            const newGuardianPubkey = '0x' + '1'.repeat(64);
+            const finalRequest = { kind: 'final-switch-guardian-request' };
+            vi.mocked(buildUpdateGuardianTransactionRequest)
+                .mockResolvedValueOnce({
+                request: { kind: 'verify-switch-guardian-request' },
+                salt: { toHex: () => '0x' + 'd'.repeat(64) },
+            })
+                .mockResolvedValueOnce({
+                request: finalRequest,
+                salt: { toHex: () => '0x' + 'd'.repeat(64) },
+            });
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'switch_guardian',
+                    newGuardianPubkey,
+                    newGuardianEndpoint: 'http://new-guardian.com',
+                    description: '',
+                },
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ commitment: newGuardianPubkey }),
+            });
+            await expect(multisig.createTransactionProposalRequest(proposalId)).resolves.toBe(finalRequest);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            expect(mockWebClient.executeTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.proveTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.submitProvenTransaction).not.toHaveBeenCalled();
+            expect(mockWebClient.applyTransaction).not.toHaveBeenCalled();
+        });
+        it('should throw if proposal not found locally', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            await expect(multisig.createTransactionProposalRequest('0x' + 'nonexistent'.repeat(5))).rejects.toThrow('Proposal not found');
+        });
+        it('should throw if proposal is still pending', async () => {
+            const config = {
+                threshold: 2,
+                signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const mockProposals = [
+                {
+                    account_id: '0x' + 'a'.repeat(30),
+                    nonce: 1,
+                    prev_commitment: '0x' + 'b'.repeat(64),
+                    delta_payload: {
+                        tx_summary: { data: 'AQID' },
+                        signatures: [],
+                        metadata: {
+                            proposal_type: 'add_signer',
+                            description: '',
+                            target_threshold: 2,
+                            signer_commitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                        },
+                    },
+                    status: {
+                        status: 'pending',
+                        timestamp: '2024-01-01T00:00:00Z',
+                        proposer_id: '0x' + 'c'.repeat(64),
+                        cosigner_sigs: [
+                            {
+                                signer_id: '0x' + 'a'.repeat(64),
+                                signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
+                                timestamp: '2024-01-01T00:00:00Z',
+                            },
+                        ],
+                    },
+                },
+            ];
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ proposals: mockProposals }),
+            });
+            await multisig.syncProposals();
+            await expect(multisig.createTransactionProposalRequest('0x' + 'c'.repeat(64))).rejects.toThrow('not ready for execution');
+        });
+        it('should throw when proposal metadata does not match tx_summary', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'c'.repeat(64);
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'd'.repeat(64),
+                }),
+            });
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'change_threshold',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            });
+            await expect(multisig.createTransactionProposalRequest(proposalId)).rejects.toThrow(`Invalid proposal: metadata does not match tx_summary for ${proposalId}`);
+            expect(mockWebClient.executeTransaction).not.toHaveBeenCalled();
+        });
+        it('should reject switch_guardian requests when endpoint commitment mismatches', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'c'.repeat(64);
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'switch_guardian',
+                    newGuardianPubkey: '0x' + '1'.repeat(64),
+                    newGuardianEndpoint: 'http://new-guardian.com',
+                    description: '',
+                },
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ commitment: '0x' + '2'.repeat(64) }),
+            });
+            await expect(multisig.createTransactionProposalRequest(proposalId)).rejects.toThrow('Refusing to use GUARDIAN endpoint');
+            expect(mockWebClient.executeTransaction).not.toHaveBeenCalled();
+        });
+        it('should reject duplicate normalized signer IDs during request creation', async () => {
+            const config = {
+                threshold: 2,
+                signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'c'.repeat(64);
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                    {
+                        signerId: '0x' + 'A'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'c'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:01Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'switch_guardian',
+                    newGuardianPubkey: '0x' + '1'.repeat(64),
+                    newGuardianEndpoint: 'http://new-guardian.com',
+                    description: '',
+                },
+            });
+            await expect(multisig.createTransactionProposalRequest(proposalId)).rejects.toThrow('duplicate signatures for signer');
+        });
+        it('should build a fresh tx commitment word for each advice entry during request creation', async () => {
+            const { buildSignatureAdviceEntry } = await import('./utils/signature.js');
+            const { Word } = await import('@miden-sdk/miden-sdk');
+            const originalAdviceImpl = vi.mocked(buildSignatureAdviceEntry).getMockImplementation();
+            const originalWordFromHexImpl = vi.mocked(Word.fromHex).getMockImplementation();
+            try {
+                vi.mocked(Word.fromHex).mockImplementation((hex) => {
+                    let consumed = false;
+                    return {
+                        toHex: () => hex,
+                        toFelts: () => {
+                            if (consumed) {
+                                throw new Error('Word already consumed');
+                            }
+                            consumed = true;
+                            return [1, 2, 3, 4];
+                        },
+                    };
+                });
+                vi.mocked(buildSignatureAdviceEntry).mockImplementation((signerCommitment, message) => {
+                    message.toFelts();
+                    return {
+                        key: { toHex: () => signerCommitment.toHex() },
+                        values: [1, 2, 3],
+                    };
+                });
+                const config = {
+                    threshold: 1,
+                    signerCommitments: ['0x' + 'a'.repeat(64)],
+                    guardianCommitment: '0x' + 'c'.repeat(64),
+                };
+                const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+                const proposalId = '0x' + 'c'.repeat(64);
+                const finalRequest = { kind: 'fresh-message-word-request' };
+                vi.mocked(buildUpdateSignersTransactionRequest)
+                    .mockResolvedValueOnce({
+                    request: { kind: 'verify-change-threshold-request' },
+                    salt: { toHex: () => '0x' + 'd'.repeat(64) },
+                    configHash: { toHex: () => '0x' + 'e'.repeat(64) },
+                })
+                    .mockResolvedValueOnce({
+                    request: finalRequest,
+                    salt: { toHex: () => '0x' + 'd'.repeat(64) },
+                    configHash: { toHex: () => '0x' + 'e'.repeat(64) },
+                });
+                multisig.proposals.set(proposalId, {
+                    id: proposalId,
+                    accountId: multisig.accountId,
+                    nonce: 1,
+                    status: 'ready',
+                    txSummary: 'AQID',
+                    signatures: [
+                        {
+                            signerId: '0x' + 'a'.repeat(64),
+                            signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                            timestamp: '2024-01-01T00:00:00Z',
+                        },
+                    ],
+                    metadata: {
+                        proposalType: 'change_threshold',
+                        targetThreshold: 1,
+                        targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                        description: '',
+                    },
+                });
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => ({
+                        account_id: multisig.accountId,
+                        nonce: 1,
+                        prev_commitment: '0x' + 'b'.repeat(64),
+                        delta_payload: {
+                            tx_summary: { data: 'AQID' },
+                            signatures: [],
+                            metadata: {
+                                proposal_type: 'change_threshold',
+                                target_threshold: 1,
+                                signer_commitments: ['0x' + 'a'.repeat(64)],
+                            },
+                        },
+                        status: {
+                            status: 'pending',
+                            timestamp: '2024-01-01T00:00:00Z',
+                            proposer_id: '0x' + 'a'.repeat(64),
+                            cosigner_sigs: [],
+                        },
+                    }),
+                });
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => ({
+                        account_id: multisig.accountId,
+                        nonce: 1,
+                        ack_sig: '0x' + 'f'.repeat(128),
+                        ack_scheme: 'falcon',
+                    }),
+                });
+                await expect(multisig.createTransactionProposalRequest(proposalId)).resolves.toBe(finalRequest);
+            }
+            finally {
+                if (originalAdviceImpl) {
+                    vi.mocked(buildSignatureAdviceEntry).mockImplementation(originalAdviceImpl);
+                }
+                if (originalWordFromHexImpl) {
+                    vi.mocked(Word.fromHex).mockImplementation(originalWordFromHexImpl);
+                }
+            }
+        });
+        it('should reject advice-map key collisions during request creation', async () => {
+            const { buildSignatureAdviceEntry } = await import('./utils/signature.js');
+            vi.mocked(buildSignatureAdviceEntry)
+                .mockImplementationOnce(() => ({
+                key: { toHex: () => '0x' + 'f'.repeat(64) },
+                values: [1, 2, 3],
+            }))
+                .mockImplementationOnce(() => ({
+                key: { toHex: () => '0x' + 'f'.repeat(64) },
+                values: [1, 2, 3],
+            }));
+            const config = {
+                threshold: 2,
+                signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'c'.repeat(64);
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                accountId: multisig.accountId,
+                nonce: 1,
+                status: 'ready',
+                txSummary: 'AQID',
+                signatures: [
+                    {
+                        signerId: '0x' + 'a'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'b'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                    {
+                        signerId: '0x' + 'b'.repeat(64),
+                        signature: { scheme: 'falcon', signature: '0x' + 'c'.repeat(128) },
+                        timestamp: '2024-01-01T00:00:01Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'switch_guardian',
+                    newGuardianPubkey: '0x' + '1'.repeat(64),
+                    newGuardianEndpoint: 'http://new-guardian.com',
+                    description: '',
+                },
+            });
+            await expect(multisig.createTransactionProposalRequest(proposalId)).rejects.toThrow('Duplicate advice-map key detected');
+        });
+    });
     describe('executeProposal', () => {
         it('should throw if proposal not found locally', async () => {
             const config = {
@@ -1824,11 +2284,9 @@ describe('Multisig', () => {
                     ack_scheme: 'ecdsa',
                 }),
             });
-            mockWebClient.executeTransaction.mockResolvedValueOnce({});
-            mockWebClient.proveTransaction.mockResolvedValueOnce({});
-            mockWebClient.submitProvenTransaction.mockResolvedValueOnce(1n);
-            mockWebClient.applyTransaction.mockResolvedValueOnce(undefined);
+            mockWebClient.transactions.submit.mockResolvedValueOnce({});
             await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
+            expect(mockWebClient.transactions.submit).toHaveBeenCalledTimes(1);
             expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(1, cosignerSignature, 'ecdsa');
             expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(2, ackSignature, 'ecdsa');
             expect(vi.mocked(buildSignatureAdviceEntry)).toHaveBeenNthCalledWith(1, expect.anything(), expect.anything(), expect.anything(), cosignerPubkey, cosignerSignature);
@@ -1909,10 +2367,7 @@ describe('Multisig', () => {
                     ack_scheme: 'ecdsa',
                 }),
             });
-            mockWebClient.executeTransaction.mockResolvedValueOnce({});
-            mockWebClient.proveTransaction.mockResolvedValueOnce({});
-            mockWebClient.submitProvenTransaction.mockResolvedValueOnce(1n);
-            mockWebClient.applyTransaction.mockResolvedValueOnce(undefined);
+            mockWebClient.transactions.submit.mockResolvedValueOnce({});
             await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
             expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(1, cosignerSignature, 'ecdsa');
             expect(vi.mocked(signatureHexToBytes)).toHaveBeenNthCalledWith(2, ackSignature, 'ecdsa');
@@ -1959,12 +2414,9 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ success: true, message: 'ok', ack_pubkey: '0x' + 'f'.repeat(64) }),
             });
-            mockWebClient.executeTransaction.mockResolvedValueOnce({});
-            mockWebClient.proveTransaction.mockResolvedValueOnce({});
-            mockWebClient.submitProvenTransaction.mockResolvedValueOnce(1n);
-            mockWebClient.applyTransaction.mockResolvedValueOnce(undefined);
+            mockWebClient.transactions.submit.mockResolvedValueOnce({});
             await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
-            expect(mockWebClient.executeTransaction).toHaveBeenCalledTimes(1);
+            expect(mockWebClient.transactions.submit).toHaveBeenCalledTimes(1);
         });
         it('should reject switch_guardian execution when endpoint commitment mismatches', async () => {
             const config = {