@openzeppelin/miden-multisig-client 0.13.1 → 0.13.3

package/dist/multisig.test.js

@@ -1,8 +1,17 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Multisig } from './multisig.js';
-import { PsmHttpClient } from '@openzeppelin/psm-client';
+import { GuardianHttpClient } from '@openzeppelin/guardian-client';
+import { buildUpdateProcedureThresholdTransactionRequest, buildUpdateGuardianTransactionRequest, buildUpdateSignersTransactionRequest, executeForSummary, } from './transaction.js';
+const { mockRpcGetAccountDetails, mockAccountDeserialize, mockDetectConfig } = vi.hoisted(() => ({
+    mockRpcGetAccountDetails: vi.fn(),
+    mockAccountDeserialize: vi.fn(),
+    mockDetectConfig: vi.fn(),
+}));
 // Mock the Miden SDK
 vi.mock('@miden-sdk/miden-sdk', () => ({
+    Account: {
+        deserialize: mockAccountDeserialize,
+    },
     AccountId: {
         fromHex: vi.fn((hex) => ({ toString: () => hex })),
     },
@@ -37,6 +46,10 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
             toHex: () => '0x' + 'e'.repeat(64),
         }),
     },
+    Endpoint: vi.fn().mockImplementation((url) => ({ url })),
+    RpcClient: vi.fn().mockImplementation(() => ({
+        getAccountDetails: mockRpcGetAccountDetails,
+    })),
 }));
 // Mock transaction module
 vi.mock('./transaction.js', () => ({
@@ -46,7 +59,12 @@ vi.mock('./transaction.js', () => ({
         salt: { toHex: () => '0x' + 'd'.repeat(64) },
         configHash: { toHex: () => '0x' + 'e'.repeat(64) },
     }),
-    buildUpdatePsmTransactionRequest: vi.fn().mockResolvedValue({
+    buildUpdateProcedureThresholdTransactionRequest: vi.fn().mockResolvedValue({
+        request: {},
+        salt: { toHex: () => '0x' + 'd'.repeat(64) },
+        configHash: { toHex: () => '0x' + 'e'.repeat(64) },
+    }),
+    buildUpdateGuardianTransactionRequest: vi.fn().mockResolvedValue({
         request: {},
         salt: { toHex: () => '0x' + 'd'.repeat(64) },
     }),
@@ -59,43 +77,83 @@ vi.mock('./transaction.js', () => ({
         salt: { toHex: () => '0x' + 'd'.repeat(64) },
     }),
 }));
-vi.mock('./utils/signature.js', () => ({
-    buildSignatureAdviceEntry: vi.fn().mockReturnValue({
-        key: { toHex: () => '0x' + 'f'.repeat(64) },
-        values: [1, 2, 3],
-    }),
-    signatureHexToBytes: vi.fn((hex) => new Uint8Array([0, 1, 2, 3])),
-}));
+vi.mock('./utils/signature.js', async () => {
+    const actual = await vi.importActual('./utils/signature.js');
+    return {
+        ...actual,
+        buildSignatureAdviceEntry: vi.fn().mockImplementation((signerCommitment) => ({
+            key: { toHex: () => signerCommitment.toHex ? signerCommitment.toHex() : '0x' + 'f'.repeat(64) },
+            values: [1, 2, 3],
+        })),
+        signatureHexToBytes: vi.fn((hex) => new Uint8Array([0, 1, 2, 3])),
+    };
+});
 vi.mock('./utils/encoding.js', async () => {
     const actual = await vi.importActual('./utils/encoding.js');
     return {
-        ensureHexPrefix: actual.ensureHexPrefix,
-        normalizeHexWord: vi.fn((hex) => '0x' + hex.replace(/^0x/i, '').padStart(64, '0')),
-        bytesToHex: actual.bytesToHex,
-        hexToBytes: actual.hexToBytes,
-        uint8ArrayToBase64: actual.uint8ArrayToBase64,
-        base64ToUint8Array: actual.base64ToUint8Array,
+        ...actual,
+        normalizeHexWord: vi.fn((hex) => '0x' + hex.replace(/^0x/i, '').toLowerCase().padStart(64, '0')),
     };
 });
-// Mock fetch for PSM client
+vi.mock('./inspector.js', () => ({
+    AccountInspector: {
+        fromAccount: mockDetectConfig,
+    },
+}));
+// Mock fetch for GUARDIAN client
 const mockFetch = vi.fn();
 vi.stubGlobal('fetch', mockFetch);
+function mockedAccount(commitmentHex, nonce = 0) {
+    return {
+        commitment: () => ({
+            toHex: () => commitmentHex,
+        }),
+        nonce: () => ({
+            asInt: () => BigInt(nonce),
+        }),
+    };
+}
 describe('Multisig', () => {
-    let psm;
+    let guardian;
     let mockSigner;
     let mockAccount;
     let mockWebClient;
     beforeEach(() => {
         mockFetch.mockReset();
-        psm = new PsmHttpClient('http://localhost:3000');
+        vi.mocked(executeForSummary).mockResolvedValue({
+            toCommitment: () => ({
+                toHex: () => '0x' + 'c'.repeat(64),
+            }),
+            serialize: () => new Uint8Array([1, 2, 3]),
+        });
+        mockRpcGetAccountDetails.mockReset();
+        mockAccountDeserialize.mockReset();
+        mockRpcGetAccountDetails.mockResolvedValue({
+            commitment: () => ({
+                toHex: () => '0x' + 'b'.repeat(64),
+            }),
+        });
+        mockAccountDeserialize.mockReturnValue(mockedAccount('0x' + 'b'.repeat(64), 1));
+        mockDetectConfig.mockReset();
+        mockDetectConfig.mockReturnValue({
+            threshold: 1,
+            numSigners: 1,
+            signerCommitments: ['0x' + 'a'.repeat(64)],
+            guardianEnabled: true,
+            guardianCommitment: '0x' + 'c'.repeat(64),
+            vaultBalances: [],
+            procedureThresholds: new Map(),
+        });
+        guardian = new GuardianHttpClient('http://localhost:3000');
         mockSigner = {
-            scheme: 'falcon',
             commitment: '0x' + '1'.repeat(64),
             publicKey: '0x' + '2'.repeat(64),
+            scheme: 'falcon',
             signAccountIdWithTimestamp: vi.fn().mockResolvedValue('0x' + 'a'.repeat(128)),
-            signCommitment: vi.fn().mockResolvedValue('0x' + 'b'.repeat(128)),
+            signRequest: vi.fn().mockReturnValue('0x' + 'a'.repeat(128)),
+            signCommitment: vi.fn().mockReturnValue('0x' + 'b'.repeat(128)),
         };
-        psm.setSigner(mockSigner);
+        guardian.setSigner(mockSigner);
         mockAccount = {
             id: () => ({
                 toString: () => '0x' + 'a'.repeat(30),
@@ -111,6 +169,8 @@ describe('Multisig', () => {
             applyTransaction: vi.fn(),
             getConsumableNotes: vi.fn().mockResolvedValue([]),
             syncState: vi.fn(),
+            getAccount: vi.fn().mockResolvedValue(null),
+            newAccount: vi.fn(),
         };
     });
     describe('constructor', () => {
@@ -118,23 +178,23 @@ describe('Multisig', () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.threshold).toBe(2);
             expect(multisig.signerCommitments).toEqual(config.signerCommitments);
-            expect(multisig.psmCommitment).toBe(config.psmCommitment);
+            expect(multisig.guardianCommitment).toBe(config.guardianCommitment);
             expect(multisig.account).toBe(mockAccount);
         });
-        it('should create Multisig without account (loaded)', () => {
+        it('should create Multisig with explicit accountId override', () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
             const accountId = '0x' + 'd'.repeat(30);
-            const multisig = new Multisig(null, config, psm, mockSigner, mockWebClient, accountId);
-            expect(multisig.account).toBeNull();
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, accountId);
+            expect(multisig.account).toBe(mockAccount);
             expect(multisig.accountId).toBe(accountId);
         });
     });
@@ -143,19 +203,19 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.accountId).toBe('0x' + 'a'.repeat(30));
         });
-        it('should return provided account ID for loaded multisig', () => {
+        it('should return provided account ID when constructor override is set', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
             const accountId = '0x' + 'e'.repeat(30);
-            const multisig = new Multisig(null, config, psm, mockSigner, mockWebClient, accountId);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, accountId);
             expect(multisig.accountId).toBe(accountId);
         });
     });
@@ -164,20 +224,20 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.signerCommitment).toBe(mockSigner.commitment);
         });
     });
     describe('fetchState', () => {
-        it('should fetch account state from PSM', async () => {
+        it('should fetch account state from GUARDIAN', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
@@ -194,14 +254,244 @@ describe('Multisig', () => {
             expect(state.stateDataBase64).toBe('base64state');
         });
     });
-    describe('registerOnPsm', () => {
-        it('should register account on PSM', async () => {
+    describe('syncState', () => {
+        it('should overwrite local state when account is missing 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, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(null);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await multisig.syncState();
+            expect(mockWebClient.newAccount).toHaveBeenCalledTimes(1);
+            expect(mockRpcGetAccountDetails).toHaveBeenCalledTimes(1);
+        });
+        it('should overwrite local state when incoming commitment matches on-chain commitment', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'a'.repeat(64), 0));
+            mockRpcGetAccountDetails.mockResolvedValueOnce({
+                commitment: () => ({
+                    toHex: () => '0x' + 'b'.repeat(64),
+                }),
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await multisig.syncState();
+            expect(mockWebClient.newAccount).toHaveBeenCalledTimes(1);
+        });
+        it('refreshes multisig config from synced account state', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                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),
+                }),
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            mockDetectConfig.mockReturnValueOnce({
+                threshold: 2,
+                numSigners: 2,
+                signerCommitments: ['0x' + '1'.repeat(64), '0x' + '2'.repeat(64)],
+                guardianEnabled: true,
+                guardianCommitment: '0x' + 'd'.repeat(64),
+                vaultBalances: [],
+                procedureThresholds: new Map(),
+            });
+            await multisig.syncState();
+            expect(multisig.threshold).toBe(2);
+            expect(multisig.signerCommitments).toEqual([
+                '0x' + '1'.repeat(64),
+                '0x' + '2'.repeat(64),
+            ]);
+            expect(multisig.guardianCommitment).toBe('0x' + 'd'.repeat(64));
+            expect(mockWebClient.newAccount).not.toHaveBeenCalled();
+        });
+        it('should overwrite local state when account is not found on-chain', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'a'.repeat(64), 0));
+            mockRpcGetAccountDetails.mockRejectedValueOnce(new Error('No account header record found for given ID'));
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await multisig.syncState();
+            expect(mockWebClient.newAccount).toHaveBeenCalledTimes(1);
+        });
+        it('should throw when incoming commitment does not match on-chain commitment', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'a'.repeat(64), 0));
+            mockAccountDeserialize.mockReturnValueOnce(mockedAccount('0x' + 'b'.repeat(64), 1));
+            mockRpcGetAccountDetails.mockResolvedValueOnce({
+                commitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
+            });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await expect(multisig.syncState()).rejects.toThrow('Refusing to overwrite local state');
+            expect(mockWebClient.newAccount).not.toHaveBeenCalled();
+        });
+        it('should throw when incoming state nonce is lower than local nonce', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'a'.repeat(64), 3));
+            mockAccountDeserialize.mockReturnValueOnce(mockedAccount('0x' + 'b'.repeat(64), 2));
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await expect(multisig.syncState()).rejects.toThrow('incoming nonce 2 is not greater than local nonce 3');
+            expect(mockWebClient.newAccount).not.toHaveBeenCalled();
+        });
+        it('should throw when incoming state nonce equals local nonce but commitment differs', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            mockWebClient.getAccount.mockResolvedValueOnce(mockedAccount('0x' + 'a'.repeat(64), 2));
+            mockAccountDeserialize.mockReturnValueOnce(mockedAccount('0x' + 'b'.repeat(64), 2));
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: multisig.accountId,
+                    commitment: '0x' + 'b'.repeat(64),
+                    state_json: { data: 'AQID' },
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-02T00:00:00Z',
+                }),
+            });
+            await expect(multisig.syncState()).rejects.toThrow('incoming nonce 2 is not greater than local nonce 2');
+            expect(mockWebClient.newAccount).not.toHaveBeenCalled();
+        });
+    });
+    describe('verifyStateCommitment', () => {
+        it('should pass when local and on-chain commitments match', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            mockWebClient.getAccount.mockResolvedValueOnce({
+                commitment: () => ({
+                    toHex: () => '0x' + 'b'.repeat(64),
+                }),
+            });
+            const multisigWithRpc = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            await expect(multisigWithRpc.verifyStateCommitment()).resolves.toMatchObject({
+                accountId: multisigWithRpc.accountId,
+            });
+        });
+        it('should throw when local account state is missing', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            mockWebClient.getAccount.mockResolvedValueOnce(null);
+            const multisigWithRpc = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            await expect(multisigWithRpc.verifyStateCommitment()).rejects.toThrow('Local account state not found');
+        });
+        it('should throw when local and on-chain commitments differ', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            mockWebClient.getAccount.mockResolvedValueOnce({
+                commitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
+            });
+            mockRpcGetAccountDetails.mockResolvedValueOnce({
+                commitment: () => ({
+                    toHex: () => '0x' + 'b'.repeat(64),
+                }),
+            });
+            const multisigWithRpc = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, undefined, 'https://rpc.devnet.miden.io');
+            await expect(multisigWithRpc.verifyStateCommitment()).rejects.toThrow('Local account commitment does not match on-chain commitment');
+        });
+    });
+    describe('registerOnGuardian', () => {
+        it('should register account on GUARDIAN', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
@@ -210,24 +500,45 @@ describe('Multisig', () => {
                     ack_pubkey: '0x' + 'd'.repeat(64),
                 }),
             });
-            await expect(multisig.registerOnPsm()).resolves.toBeUndefined();
+            await expect(multisig.registerOnGuardian()).resolves.toBeUndefined();
         });
-        it('should throw when no account and no initial state', async () => {
+        it('should register ECDSA accounts with MidenEcdsa auth', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(null, config, psm, mockSigner, mockWebClient, '0x' + 'e'.repeat(30));
-            await expect(multisig.registerOnPsm()).rejects.toThrow('Cannot register on PSM');
+            const ecdsaSigner = {
+                ...mockSigner,
+                publicKey: '0x' + '2'.repeat(66),
+                scheme: 'ecdsa',
+            };
+            guardian.setSigner(ecdsaSigner);
+            const multisig = new Multisig(mockAccount, config, guardian, ecdsaSigner, mockWebClient);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    success: true,
+                    message: 'Account configured',
+                    ack_pubkey: '0x' + 'd'.repeat(66),
+                }),
+            });
+            await expect(multisig.registerOnGuardian()).resolves.toBeUndefined();
+            const [, requestInit] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(requestInit.body));
+            expect(body.auth).toEqual({
+                MidenEcdsa: {
+                    cosigner_commitments: config.signerCommitments,
+                },
+            });
         });
-        it('should accept initial state base64', async () => {
+        it('should accept explicit initial state base64', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(null, config, psm, mockSigner, mockWebClient, '0x' + 'e'.repeat(30));
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient, '0x' + 'e'.repeat(30));
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
@@ -235,15 +546,15 @@ describe('Multisig', () => {
                     message: 'Account configured',
                 }),
             });
-            await expect(multisig.registerOnPsm('base64initialstate')).resolves.toBeUndefined();
+            await expect(multisig.registerOnGuardian('base64initialstate')).resolves.toBeUndefined();
         });
-        it('should throw on PSM registration failure', async () => {
+        it('should throw on GUARDIAN registration failure', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
@@ -251,17 +562,17 @@ describe('Multisig', () => {
                     message: 'Account already exists',
                 }),
             });
-            await expect(multisig.registerOnPsm()).rejects.toThrow('Failed to register on PSM');
+            await expect(multisig.registerOnGuardian()).rejects.toThrow('Failed to register on GUARDIAN');
         });
     });
-    describe('syncTransactionProposals', () => {
-        it('should sync proposals from PSM', async () => {
+    describe('syncProposals', () => {
+        it('should sync proposals from GUARDIAN', async () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockProposals = [
                 {
                     account_id: '0x' + 'a'.repeat(30),
@@ -283,7 +594,7 @@ describe('Multisig', () => {
                         proposer_id: '0x' + 'c'.repeat(64),
                         cosigner_sigs: [
                             {
-                                signer_id: '0x' + 'd'.repeat(64),
+                                signer_id: '0x' + 'a'.repeat(64),
                                 signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
                                 timestamp: '2024-01-01T00:00:00Z',
                             },
@@ -295,19 +606,18 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
+            const proposals = await multisig.syncProposals();
             expect(proposals.length).toBe(1);
             expect(proposals[0].nonce).toBe(1);
-            expect(proposals[0].status.type).toBe('pending');
-            expect(proposals[0].commitment).toBe(proposals[0].id);
+            expect(proposals[0].status).toBe('pending');
         });
         it('should return ready status when enough signatures', async () => {
             const config = {
                 threshold: 1, // Only 1 signature needed
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockProposals = [
                 {
                     account_id: '0x' + 'a'.repeat(30),
@@ -329,7 +639,7 @@ describe('Multisig', () => {
                         proposer_id: '0x' + 'c'.repeat(64),
                         cosigner_sigs: [
                             {
-                                signer_id: '0x' + 'd'.repeat(64),
+                                signer_id: '0x' + 'a'.repeat(64),
                                 signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
                                 timestamp: '2024-01-01T00:00:00Z',
                             },
@@ -341,99 +651,571 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
-            expect(proposals[0].status.type).toBe('ready');
-        });
-    });
-    describe('listTransactionProposals', () => {
-        it('should return empty list initially', () => {
-            const config = {
-                threshold: 1,
-                signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
-            };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            expect(multisig.listTransactionProposals()).toEqual([]);
+            const proposals = await multisig.syncProposals();
+            expect(proposals[0].status).toBe('ready');
         });
-    });
-    describe('createProposal', () => {
-        it('should create a new proposal', async () => {
+        it('should reject proposals whose metadata does not match tx_summary', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
-            };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            const mockDelta = {
-                account_id: '0x' + 'a'.repeat(30),
-                nonce: 1,
-                prev_commitment: '0x' + 'b'.repeat(64),
-                delta_payload: {
-                    tx_summary: { data: 'base64summary' },
-                    signatures: [],
-                },
-                status: {
-                    status: 'pending',
-                    timestamp: '2024-01-01T00:00:00Z',
-                    proposer_id: '0x' + 'c'.repeat(64),
-                    cosigner_sigs: [],
-                },
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({
-                    delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
+                    proposals: [
+                        {
+                            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',
+                                    target_threshold: 1,
+                                    signer_commitments: ['0x' + 'a'.repeat(64)],
+                                    description: '',
+                                },
+                            },
+                            status: {
+                                status: 'pending',
+                                timestamp: '2024-01-01T00:00:00Z',
+                                proposer_id: '0x' + 'c'.repeat(64),
+                                cosigner_sigs: [],
+                            },
+                        },
+                    ],
                 }),
             });
-            const proposal = await multisig.createProposal(1, 'AQID', {
-                proposalType: 'add_signer',
-                targetThreshold: 1,
-                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
-                description: '',
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
             });
-            expect(proposal.nonce).toBe(1);
-            expect(proposal.id).toBe('0x' + 'd'.repeat(64));
+            await expect(multisig.syncProposals()).rejects.toThrow('Invalid proposal: metadata does not match tx_summary');
         });
-    });
-    describe('signTransactionProposal', () => {
-        it('should sign a proposal', async () => {
+        it('should reject non-32-byte signer IDs from GUARDIAN proposals', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            // First create a proposal
-            const mockDelta = {
-                account_id: '0x' + 'a'.repeat(30),
-                nonce: 1,
-                prev_commitment: '0x' + 'b'.repeat(64),
-                delta_payload: {
-                    tx_summary: { data: 'AQID' },
-                    signatures: [],
-                },
-                status: {
-                    status: 'pending',
-                    timestamp: '2024-01-01T00:00:00Z',
-                    proposer_id: '0x' + 'c'.repeat(64),
-                    cosigner_sigs: [],
+            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',
+                            target_threshold: 1,
+                            signer_commitments: ['0x' + 'a'.repeat(64)],
+                            description: '',
+                        },
+                    },
+                    status: {
+                        status: 'pending',
+                        timestamp: '2024-01-01T00:00:00Z',
+                        proposer_id: '0x' + 'c'.repeat(64),
+                        cosigner_sigs: [
+                            {
+                                signer_id: '0x1',
+                                signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
+                                timestamp: '2024-01-01T00:00:00Z',
+                            },
+                        ],
+                    },
                 },
-            };
+            ];
             mockFetch.mockResolvedValueOnce({
                 ok: true,
-                json: async () => ({
-                    delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
-                }),
+                json: async () => ({ proposals: mockProposals }),
             });
-            await multisig.createProposal(1, 'AQID', {
-                proposalType: 'add_signer',
+            await expect(multisig.syncProposals()).rejects.toThrow('expected signerId as 32-byte hex');
+        });
+        it('should reject duplicate normalized signer IDs from GUARDIAN proposals', 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',
+                            target_threshold: 2,
+                            signer_commitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                            description: '',
+                        },
+                    },
+                    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',
+                            },
+                            {
+                                signer_id: '0x' + 'a'.repeat(64),
+                                signature: { scheme: 'falcon', signature: '0x' + 'f'.repeat(128) },
+                                timestamp: '2024-01-01T00:00:01Z',
+                            },
+                        ],
+                    },
+                },
+            ];
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ proposals: mockProposals }),
+            });
+            await expect(multisig.syncProposals()).rejects.toThrow('duplicate signatures for signer');
+        });
+    });
+    describe('listProposals', () => {
+        it('should return empty list initially', () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            expect(multisig.listProposals()).toEqual([]);
+        });
+    });
+    describe('createProposal', () => {
+        it('should create a new proposal', 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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            const proposal = await multisig.createProposal(1, 'AQID', {
+                proposalType: 'add_signer',
+                targetThreshold: 1,
+                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                description: '',
+            });
+            expect(proposal.nonce).toBe(1);
+            expect(proposal.id).toBe('0x' + 'c'.repeat(64));
+        });
+        it('should reject a mismatched returned commitment', 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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'd'.repeat(64),
+                }),
+            });
+            await expect(multisig.createProposal(1, 'AQID', {
+                proposalType: 'add_signer',
+                targetThreshold: 1,
+                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                description: '',
+            })).rejects.toThrow('Invalid proposal: commitment 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd does not match tx_summary 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc');
+        });
+        it('should reject a response whose tx_summary does not match the provided metadata', 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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
+            });
+            await expect(multisig.createProposal(1, 'AQID', {
+                proposalType: 'add_signer',
+                targetThreshold: 1,
+                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                description: '',
+            })).rejects.toThrow('Invalid proposal: metadata does not match tx_summary');
+        });
+    });
+    describe('createP2idProposal', () => {
+        it('should include the faucet asset in the proposal description', async () => {
+            const { executeForSummary } = await import('./transaction.js');
+            vi.mocked(executeForSummary).mockResolvedValue({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
+                serialize: () => new Uint8Array([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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                    metadata: {
+                        proposal_type: 'p2id',
+                        recipient_id: '0xrecipient',
+                        faucet_id: '0xfaucet',
+                        amount: '100',
+                        description: '',
+                    },
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            const proposal = await multisig.createP2idProposal('0xrecipient', '0xfaucet', 100n, 1);
+            expect(proposal.metadata.description).toBe('Send 100 of asset 0xfaucet... to 0xrecipien...');
+        });
+    });
+    describe('createChangeThresholdProposal', () => {
+        it('passes the signer scheme to update-signers requests', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
+                serialize: () => new Uint8Array([1, 2, 3]),
+            });
+            const ecdsaSigner = {
+                ...mockSigner,
+                publicKey: '0x' + '2'.repeat(66),
+                scheme: 'ecdsa',
+            };
+            guardian.setSigner(ecdsaSigner);
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                    metadata: {
+                        proposal_type: 'change_threshold',
+                        target_threshold: 2,
+                        description: '',
+                    },
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            const multisig = new Multisig(mockAccount, config, guardian, ecdsaSigner, mockWebClient);
+            await multisig.createChangeThresholdProposal(2, 1);
+            expect(buildUpdateSignersTransactionRequest).toHaveBeenCalledWith(mockWebClient, 2, config.signerCommitments, { signatureScheme: 'ecdsa' });
+        });
+    });
+    describe('createSwitchGuardianProposal', () => {
+        it('should verify new endpoint commitment before creating proposal', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                serialize: () => new Uint8Array([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 newGuardianPubkey = '0x' + '1'.repeat(64);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ commitment: newGuardianPubkey }),
+            });
+            const proposal = await multisig.createSwitchGuardianProposal('http://new-guardian.com', newGuardianPubkey);
+            expect(proposal.metadata?.proposalType).toBe('switch_guardian');
+            if (proposal.metadata?.proposalType === 'switch_guardian') {
+                expect(proposal.metadata.newGuardianEndpoint).toBe('http://new-guardian.com');
+            }
+            expect(mockFetch).toHaveBeenCalledWith('http://new-guardian.com/pubkey?scheme=falcon', expect.objectContaining({ method: 'GET' }));
+        });
+        it('should reject switch proposal when endpoint commitment does not match', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                serialize: () => new Uint8Array([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);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ commitment: '0x' + '2'.repeat(64) }),
+            });
+            await expect(multisig.createSwitchGuardianProposal('http://new-guardian.com', '0x' + '1'.repeat(64))).rejects.toThrow('Refusing to use GUARDIAN endpoint');
+        });
+        it('should use the signer scheme when resolving new GUARDIAN commitments', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                serialize: () => new Uint8Array([1, 2, 3]),
+            });
+            const ecdsaSigner = {
+                ...mockSigner,
+                publicKey: '0x' + '2'.repeat(66),
+                scheme: 'ecdsa',
+            };
+            guardian.setSigner(ecdsaSigner);
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, ecdsaSigner, mockWebClient);
+            const newGuardianCommitment = '0x' + '1'.repeat(64);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ commitment: newGuardianCommitment }),
+            });
+            await multisig.createSwitchGuardianProposal('http://new-guardian.com', newGuardianCommitment);
+            expect(mockFetch).toHaveBeenCalledWith('http://new-guardian.com/pubkey?scheme=ecdsa', expect.objectContaining({ method: 'GET' }));
+            expect(buildUpdateGuardianTransactionRequest).toHaveBeenCalledWith(mockWebClient, newGuardianCommitment, { signatureScheme: 'ecdsa' });
+        });
+    });
+    describe('createUpdateProcedureThresholdProposal', () => {
+        it('should create procedure-threshold update proposals', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
+                serialize: () => new Uint8Array([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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                    metadata: {
+                        proposal_type: 'update_procedure_threshold',
+                        target_threshold: 1,
+                        target_procedure: 'send_asset',
+                        description: '',
+                    },
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            const proposal = await multisig.createUpdateProcedureThresholdProposal('send_asset', 1, 1);
+            expect(buildUpdateProcedureThresholdTransactionRequest).toHaveBeenCalledWith(mockWebClient, 'send_asset', 1, { signatureScheme: 'falcon' });
+            expect(proposal.metadata.proposalType).toBe('update_procedure_threshold');
+            if (proposal.metadata.proposalType === 'update_procedure_threshold') {
+                expect(proposal.metadata.targetProcedure).toBe('send_asset');
+                expect(proposal.metadata.targetThreshold).toBe(1);
+            }
+        });
+        it('passes the signer scheme to ECDSA procedure-threshold updates', async () => {
+            vi.mocked(executeForSummary).mockResolvedValue({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
+                serialize: () => new Uint8Array([1, 2, 3]),
+            });
+            const ecdsaSigner = {
+                ...mockSigner,
+                publicKey: '0x' + '2'.repeat(66),
+                scheme: 'ecdsa',
+            };
+            guardian.setSigner(ecdsaSigner);
+            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, ecdsaSigner, mockWebClient);
+            const mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                    metadata: {
+                        proposal_type: 'update_procedure_threshold',
+                        target_threshold: 1,
+                        target_procedure: 'send_asset',
+                        description: '',
+                    },
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            await multisig.createUpdateProcedureThresholdProposal('send_asset', 1, 1);
+            expect(buildUpdateProcedureThresholdTransactionRequest).toHaveBeenCalledWith(mockWebClient, 'send_asset', 1, { signatureScheme: 'ecdsa' });
+        });
+    });
+    describe('signProposal', () => {
+        it('should sign a proposal', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: [mockSigner.commitment],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            // First create a proposal
+            const mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            await multisig.createProposal(1, 'AQID', {
+                proposalType: 'add_signer',
                 targetThreshold: 1,
                 targetSignerCommitments: ['0x' + 'a'.repeat(64)],
                 description: '',
             });
-            // Now sign it
             const signedDelta = {
                 ...mockDelta,
                 status: {
@@ -458,33 +1240,173 @@ describe('Multisig', () => {
                     },
                 },
             };
-            // Mock for signDeltaProposal
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                json: async () => signedDelta,
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => signedDelta,
+            });
+            const proposalId = '0x' + 'c'.repeat(64);
+            const signedProposal = await multisig.signProposal(proposalId);
+            expect(mockSigner.signCommitment).toHaveBeenCalledWith(proposalId);
+            expect(signedProposal.signatures.length).toBe(1);
+        });
+        it('should reject signing when 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 mockDelta = {
+                account_id: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                prev_commitment: '0x' + 'b'.repeat(64),
+                delta_payload: {
+                    tx_summary: { data: 'AQID' },
+                    signatures: [],
+                },
+                status: {
+                    status: 'pending',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    proposer_id: '0x' + 'c'.repeat(64),
+                    cosigner_sigs: [],
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    delta: mockDelta,
+                    commitment: '0x' + 'c'.repeat(64),
+                }),
+            });
+            await multisig.createProposal(1, 'AQID', {
+                proposalType: 'add_signer',
+                targetThreshold: 1,
+                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                description: '',
+            });
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
+            });
+            await expect(multisig.signProposal('0x' + 'c'.repeat(64))).rejects.toThrow('Invalid proposal: metadata does not match tx_summary');
+        });
+        it('should reject proposals for a different account before signing', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: [mockSigner.commitment],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const proposalId = '0x' + 'd'.repeat(64);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    proposals: [
+                        {
+                            account_id: '0x' + 'f'.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: 1,
+                                    signer_commitments: [mockSigner.commitment],
+                                },
+                            },
+                            status: {
+                                status: 'pending',
+                                timestamp: '2024-01-01T00:00:00Z',
+                                proposer_id: '0x' + 'c'.repeat(64),
+                                cosigner_sigs: [],
+                            },
+                        },
+                    ],
+                }),
+            });
+            await expect(multisig.signProposal(proposalId)).rejects.toThrow('Proposal is for a different account: 0x' + 'f'.repeat(30));
+            expect(mockSigner.signCommitment).not.toHaveBeenCalled();
+        });
+    });
+    describe('importProposal', () => {
+        it('should reject imported proposals whose 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);
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
+            });
+            await expect(multisig.importProposal(JSON.stringify({
+                accountId: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [],
+                metadata: {
+                    proposalType: 'add_signer',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            }))).rejects.toThrow('Invalid proposal: metadata does not match tx_summary');
+        });
+    });
+    describe('signProposalOffline', () => {
+        it('should reject signing imported proposals whose 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);
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'c'.repeat(64),
+                }),
             });
-            // Mock for auto-sync (syncTransactionProposals)
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                json: async () => ({ proposals: [signedDelta] }),
+            const proposal = await multisig.importProposal(JSON.stringify({
+                accountId: '0x' + 'a'.repeat(30),
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [],
+                metadata: {
+                    proposalType: 'add_signer',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            }));
+            proposal.metadata = {
+                proposalType: 'add_signer',
+                targetThreshold: 2,
+                targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                description: '',
+            };
+            vi.mocked(executeForSummary).mockResolvedValueOnce({
+                toCommitment: () => ({
+                    toHex: () => '0x' + 'f'.repeat(64),
+                }),
             });
-            const proposalId = '0x' + 'd'.repeat(64);
-            const proposals = await multisig.signTransactionProposal(proposalId);
-            expect(mockSigner.signCommitment).toHaveBeenCalledWith(proposalId);
-            expect(proposals.length).toBeGreaterThanOrEqual(1);
-            expect(proposals[0].signatures.length).toBe(1);
-            expect(proposals[0].commitment).toBe(proposals[0].id);
+            await expect(multisig.signProposalOffline(proposal.id)).rejects.toThrow('Invalid proposal: metadata does not match tx_summary');
         });
     });
-    describe('exportTransactionProposalToJson', () => {
-        it('should export proposal to JSON from local cache', async () => {
+    describe('exportProposal', () => {
+        it('should export proposal for offline signing', async () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            // First sync proposals to populate local cache
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockProposals = [
                 {
                     account_id: '0x' + 'a'.repeat(30),
@@ -506,7 +1428,7 @@ describe('Multisig', () => {
                         proposer_id: '0x' + 'c'.repeat(64),
                         cosigner_sigs: [
                             {
-                                signer_id: '0x' + 'd'.repeat(64),
+                                signer_id: '0x' + 'a'.repeat(64),
                                 signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
                                 timestamp: '2024-01-01T00:00:00Z',
                             },
@@ -516,45 +1438,223 @@ describe('Multisig', () => {
             ];
             mockFetch.mockResolvedValueOnce({
                 ok: true,
-                json: async () => ({ proposals: mockProposals }),
+                json: async () => mockProposals[0],
             });
-            await multisig.syncTransactionProposals();
             // The proposal ID is computed from tx_summary, which is mocked to return 'c'.repeat(64)
-            const json = multisig.exportTransactionProposalToJson('0x' + 'c'.repeat(64));
-            const exported = JSON.parse(json);
+            const exported = await multisig.exportProposal('0x' + 'c'.repeat(64));
             expect(exported.accountId).toBe('0x' + 'a'.repeat(30));
             expect(exported.nonce).toBe(1);
             expect(exported.txSummaryBase64).toBe('AQID');
             expect(exported.signatures.length).toBe(1);
-            expect(exported.commitment).toBe('0x' + 'c'.repeat(64));
         });
-        it('should throw if proposal not found in cache', () => {
+        it('should preserve ECDSA signature metadata in exported proposals', 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 publicKey = '0x' + 'd'.repeat(66);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    account_id: '0x' + 'a'.repeat(30),
+                    nonce: 1,
+                    prev_commitment: '0x' + 'b'.repeat(64),
+                    delta_payload: {
+                        tx_summary: { data: 'AQID' },
+                        signatures: [],
+                        metadata: {
+                            proposal_type: 'change_threshold',
+                            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: 'ecdsa',
+                                    signature: '0x' + 'e'.repeat(130),
+                                    public_key: publicKey,
+                                },
+                                timestamp: '2024-01-01T00:00:00Z',
+                            },
+                        ],
+                    },
+                }),
+            });
+            const exported = await multisig.exportProposal('0x' + 'c'.repeat(64));
+            expect(exported.signatures).toEqual([
+                {
+                    commitment: '0x' + 'a'.repeat(64),
+                    signatureHex: '0x' + 'e'.repeat(130),
+                    scheme: 'ecdsa',
+                    publicKey,
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ]);
+        });
+        it('should throw if proposal not found', async () => {
+            const config = {
+                threshold: 1,
+                signerCommitments: ['0x' + 'a'.repeat(64)],
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+                text: async () => 'Proposal not found',
+            });
+            await expect(multisig.exportProposal('0x' + 'nonexistent'.repeat(5))).rejects.toThrow('Proposal not found');
+        });
+    });
+    describe('importProposal', () => {
+        it('should reject imported signatures with non-32-byte signer IDs', 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 exported = {
+                accountId: multisig.accountId,
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [
+                    {
+                        commitment: '0x1',
+                        signatureHex: '0x' + 'b'.repeat(128),
+                    },
+                ],
+                metadata: {
+                    proposalType: 'add_signer',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            };
+            await expect(multisig.importProposal(JSON.stringify(exported))).rejects.toThrow('expected signerId as 32-byte hex');
+        });
+        it('should preserve ECDSA imported signature metadata', 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 publicKey = '0x' + 'd'.repeat(66);
+            const proposal = await multisig.importProposal(JSON.stringify({
+                accountId: multisig.accountId,
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [
+                    {
+                        commitment: '0x' + 'a'.repeat(64),
+                        signatureHex: '0x' + 'b'.repeat(130),
+                        scheme: 'ecdsa',
+                        publicKey,
+                        timestamp: '2024-01-01T00:00:00Z',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'change_threshold',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            }));
+            expect(proposal.signatures).toEqual([
+                {
+                    signerId: '0x' + 'a'.repeat(64),
+                    signature: {
+                        scheme: 'ecdsa',
+                        signature: '0x' + 'b'.repeat(130),
+                        publicKey,
+                    },
+                    timestamp: '2024-01-01T00:00:00Z',
+                },
+            ]);
+        });
+        it('should reject imported ECDSA signatures without a public key', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
+            };
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            await expect(multisig.importProposal(JSON.stringify({
+                accountId: multisig.accountId,
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [
+                    {
+                        commitment: '0x' + 'a'.repeat(64),
+                        signatureHex: '0x' + 'b'.repeat(130),
+                        scheme: 'ecdsa',
+                    },
+                ],
+                metadata: {
+                    proposalType: 'change_threshold',
+                    targetThreshold: 1,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64)],
+                    description: '',
+                },
+            }))).rejects.toThrow('ECDSA signature for 0x' + 'a'.repeat(64) + ' is missing publicKey');
+        });
+        it('should reject offline signing if an imported proposal account is changed', async () => {
+            const config = {
+                threshold: 2,
+                signerCommitments: ['0x' + 'a'.repeat(64), mockSigner.commitment],
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            expect(() => multisig.exportTransactionProposalToJson('0x' + 'nonexistent'.repeat(5))).toThrow('Proposal not found');
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const exported = {
+                accountId: multisig.accountId,
+                nonce: 1,
+                commitment: '0x' + 'c'.repeat(64),
+                txSummaryBase64: 'AQID',
+                signatures: [],
+                metadata: {
+                    proposalType: 'add_signer',
+                    targetThreshold: 2,
+                    targetSignerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+                    description: '',
+                },
+            };
+            const proposal = await multisig.importProposal(JSON.stringify(exported));
+            proposal.accountId = '0x' + 'f'.repeat(30);
+            await expect(multisig.signProposalOffline(proposal.id)).rejects.toThrow('Proposal is for a different account: 0x' + 'f'.repeat(30));
+            expect(mockSigner.signCommitment).not.toHaveBeenCalled();
         });
     });
-    describe('executeTransactionProposal', () => {
+    describe('executeProposal', () => {
         it('should throw if proposal not found locally', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            await expect(multisig.executeTransactionProposal('0x' + 'nonexistent'.repeat(5))).rejects.toThrow('Proposal not found');
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            await expect(multisig.executeProposal('0x' + 'nonexistent'.repeat(5))).rejects.toThrow('Proposal not found');
         });
         it('should throw if proposal is still pending', async () => {
             const config = {
                 threshold: 2, // Need 2 signatures
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             // Sync with pending proposal (only 1 signature)
             const mockProposals = [
                 {
@@ -577,7 +1677,7 @@ describe('Multisig', () => {
                         proposer_id: '0x' + 'c'.repeat(64),
                         cosigner_sigs: [
                             {
-                                signer_id: '0x' + 'd'.repeat(64),
+                                signer_id: '0x' + 'a'.repeat(64),
                                 signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
                                 timestamp: '2024-01-01T00:00:00Z',
                             },
@@ -589,17 +1689,17 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposals }),
             });
-            await multisig.syncTransactionProposals();
+            await multisig.syncProposals();
             // Proposal ID is mocked to return 'c'.repeat(64)
-            await expect(multisig.executeTransactionProposal('0x' + 'c'.repeat(64))).rejects.toThrow('not ready for execution');
+            await expect(multisig.executeProposal('0x' + 'c'.repeat(64))).rejects.toThrow('not ready for execution');
         });
-        it('should fail when PSM ack signature is missing (selector ON)', async () => {
+        it('should fail when GUARDIAN ack signature is missing (selector ON)', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const readyDelta = {
                 account_id: '0x' + 'a'.repeat(30),
                 nonce: 1,
@@ -620,7 +1720,7 @@ describe('Multisig', () => {
                     proposer_id: '0x' + 'c'.repeat(64),
                     cosigner_sigs: [
                         {
-                            signer_id: '0x' + 'd'.repeat(64),
+                            signer_id: '0x' + 'a'.repeat(64),
                             signature: { scheme: 'falcon', signature: '0x' + 'e'.repeat(128) },
                             timestamp: '2024-01-01T00:00:00Z',
                         },
@@ -633,18 +1733,353 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: [readyDelta] }),
             });
-            await multisig.syncTransactionProposals();
-            // executeProposal: getDeltaProposals
+            await multisig.syncProposals();
+            // executeProposal: getDeltaProposal
             mockFetch.mockResolvedValueOnce({
                 ok: true,
-                json: async () => ({ proposals: [readyDelta] }),
+                json: async () => readyDelta,
             });
             // executeProposal: pushDelta without ack_sig
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 json: async () => ({ ...readyDelta, ack_sig: null }),
             });
-            await expect(multisig.executeTransactionProposal(proposalId)).rejects.toThrow('PSM did not return acknowledgment signature');
+            await expect(multisig.executeProposal(proposalId)).rejects.toThrow('GUARDIAN did not return acknowledgment signature');
+        });
+        it('should encode ECDSA proposal and ack signatures with scheme-aware advice', 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 proposalId = '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);
+            multisig.proposals.set(proposalId, {
+                id: proposalId,
+                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',
+                }),
+            });
+            mockWebClient.executeTransaction.mockResolvedValueOnce({});
+            mockWebClient.proveTransaction.mockResolvedValueOnce({});
+            mockWebClient.submitProvenTransaction.mockResolvedValueOnce(1n);
+            mockWebClient.applyTransaction.mockResolvedValueOnce(undefined);
+            await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
+            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);
+        });
+        it('should execute imported ECDSA proposals with scheme-aware advice', 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 proposalId = '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);
+            await multisig.importProposal(JSON.stringify({
+                accountId: multisig.accountId,
+                nonce: 1,
+                commitment: proposalId,
+                txSummaryBase64: 'AQID',
+                signatures: [
+                    {
+                        commitment: '0x' + 'a'.repeat(64),
+                        signatureHex: cosignerSignature,
+                        scheme: 'ecdsa',
+                        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',
+                }),
+            });
+            mockWebClient.executeTransaction.mockResolvedValueOnce({});
+            mockWebClient.proveTransaction.mockResolvedValueOnce({});
+            mockWebClient.submitProvenTransaction.mockResolvedValueOnce(1n);
+            mockWebClient.applyTransaction.mockResolvedValueOnce(undefined);
+            await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
+            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);
+        });
+        it('should verify switch_guardian endpoint commitment before execution', 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);
+            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 }),
+            });
+            mockWebClient.getAccount.mockResolvedValueOnce({
+                serialize: () => new Uint8Array([1, 2, 3]),
+            });
+            mockFetch.mockResolvedValueOnce({
+                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);
+            await expect(multisig.executeProposal(proposalId)).resolves.toBeUndefined();
+            expect(mockWebClient.executeTransaction).toHaveBeenCalledTimes(1);
+        });
+        it('should reject switch_guardian execution 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.executeProposal(proposalId)).rejects.toThrow('Refusing to use GUARDIAN endpoint');
+            expect(mockWebClient.executeTransaction).not.toHaveBeenCalled();
+        });
+        it('should reject duplicate normalized signer IDs during execution', 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.executeProposal(proposalId)).rejects.toThrow('duplicate signatures for signer');
+        });
+        it('should reject advice-map key collisions during execution', 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.executeProposal(proposalId)).rejects.toThrow('Duplicate advice-map key detected');
         });
     });
     describe('proposal metadata preservation', () => {
@@ -652,9 +2087,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             // Create a proposal with metadata
             const mockDelta = {
                 account_id: '0x' + 'a'.repeat(30),
@@ -663,7 +2098,11 @@ describe('Multisig', () => {
                 delta_payload: {
                     tx_summary: { data: 'AQID' },
                     signatures: [],
-                    metadata: { proposal_type: 'add_signer' },
+                    metadata: {
+                        proposal_type: 'add_signer',
+                        target_threshold: 2,
+                        signer_commitments: ['0x1', '0x2'],
+                    },
                 },
                 status: {
                     status: 'pending',
@@ -676,7 +2115,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({
                     delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
+                    commitment: '0x' + 'c'.repeat(64),
                 }),
             });
             const proposal = await multisig.createProposal(1, 'AQID', {
@@ -693,17 +2132,17 @@ describe('Multisig', () => {
                     proposals: [mockDelta],
                 }),
             });
-            const syncedProposals = await multisig.syncTransactionProposals();
+            const syncedProposals = await multisig.syncProposals();
             const syncedProposal = syncedProposals.find(p => p.nonce === 1);
             expect(syncedProposal?.metadata?.proposalType).toBe('add_signer');
         });
-        it('should use PSM metadata for new proposals from other signers', async () => {
+        it('should use GUARDIAN metadata for new proposals from other signers', async () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             // Sync proposals - no local proposals exist
             const mockProposals = [
                 {
@@ -732,7 +2171,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
+            const proposals = await multisig.syncProposals();
             expect(proposals.length).toBe(1);
             expect(proposals[0].metadata?.proposalType).toBe('p2id');
         });
@@ -742,9 +2181,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockDelta = {
                 account_id: '0x' + 'a'.repeat(30),
                 nonce: 1,
@@ -770,7 +2209,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({
                     delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
+                    commitment: '0x' + 'c'.repeat(64),
                 }),
             });
             const proposal = await multisig.createProposal(1, 'AQID', {
@@ -784,9 +2223,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockDelta = {
                 account_id: '0x' + 'a'.repeat(30),
                 nonce: 1,
@@ -812,7 +2251,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({
                     delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
+                    commitment: '0x' + 'c'.repeat(64),
                 }),
             });
             const proposal = await multisig.createProposal(1, 'AQID', {
@@ -824,13 +2263,13 @@ describe('Multisig', () => {
             });
             expect(proposal.metadata?.proposalType).toBe('p2id');
         });
-        it('should create switch_psm proposal', async () => {
+        it('should create switch_guardian proposal', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             const mockDelta = {
                 account_id: '0x' + 'a'.repeat(30),
                 nonce: 1,
@@ -856,16 +2295,16 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({
                     delta: mockDelta,
-                    commitment: '0x' + 'd'.repeat(64),
+                    commitment: '0x' + 'c'.repeat(64),
                 }),
             });
             const proposal = await multisig.createProposal(1, 'AQID', {
-                proposalType: 'switch_psm',
-                newPsmPubkey: '0xnewpubkey',
-                newPsmEndpoint: 'http://new-psm.com',
+                proposalType: 'switch_guardian',
+                newGuardianPubkey: '0xnewpubkey',
+                newGuardianEndpoint: 'http://new-guardian.com',
                 description: '',
             });
-            expect(proposal.metadata?.proposalType).toBe('switch_psm');
+            expect(proposal.metadata?.proposalType).toBe('switch_guardian');
         });
     });
     describe('proposal status transitions', () => {
@@ -873,9 +2312,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             // First sync with 1 signature (pending)
             const mockProposalsPending = [
                 {
@@ -910,8 +2349,8 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposalsPending }),
             });
-            let proposals = await multisig.syncTransactionProposals();
-            expect(proposals[0].status.type).toBe('pending');
+            let proposals = await multisig.syncProposals();
+            expect(proposals[0].status).toBe('pending');
             // Second sync with 2 signatures (ready)
             const mockProposalsReady = [
                 {
@@ -948,8 +2387,8 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: mockProposalsReady }),
             });
-            proposals = await multisig.syncTransactionProposals();
-            expect(proposals[0].status.type).toBe('ready');
+            proposals = await multisig.syncProposals();
+            expect(proposals[0].status).toBe('ready');
         });
     });
     describe('getters', () => {
@@ -957,9 +2396,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 3,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64), '0x' + 'c'.repeat(64)],
-                psmCommitment: '0x' + 'd'.repeat(64),
+                guardianCommitment: '0x' + 'd'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.threshold).toBe(3);
         });
         it('should expose signerCommitments', () => {
@@ -967,28 +2406,28 @@ describe('Multisig', () => {
             const config = {
                 threshold: 2,
                 signerCommitments,
-                psmCommitment: '0x' + 'd'.repeat(64),
+                guardianCommitment: '0x' + 'd'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.signerCommitments).toEqual(signerCommitments);
         });
-        it('should expose psmCommitment', () => {
-            const psmCommitment = '0x' + 'psm'.repeat(20);
+        it('should expose guardianCommitment', () => {
+            const guardianCommitment = '0x' + 'guardian'.repeat(20);
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment,
+                guardianCommitment,
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            expect(multisig.psmCommitment).toBe(psmCommitment);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            expect(multisig.guardianCommitment).toBe(guardianCommitment);
         });
         it('should expose account when provided', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'd'.repeat(64),
+                guardianCommitment: '0x' + 'd'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             expect(multisig.account).toBe(mockAccount);
         });
     });
@@ -997,10 +2436,10 @@ describe('Multisig', () => {
             const config = {
                 threshold: 2,
                 signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            // Simulates a PSM response with canonical snake_case metadata
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            // Simulates a GUARDIAN response with canonical snake_case metadata
             const rustProposals = [
                 {
                     account_id: '0x' + 'a'.repeat(30),
@@ -1028,7 +2467,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: rustProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
+            const proposals = await multisig.syncProposals();
             expect(proposals.length).toBe(1);
             // The TS client should normalize snake_case to camelCase
             expect(proposals[0].metadata?.proposalType).toBe('change_threshold');
@@ -1041,9 +2480,9 @@ describe('Multisig', () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
             // P2ID proposal with canonical snake_case fields
             const p2idProposals = [
                 {
@@ -1079,7 +2518,7 @@ describe('Multisig', () => {
                 ok: true,
                 json: async () => ({ proposals: p2idProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
+            const proposals = await multisig.syncProposals();
             expect(proposals.length).toBe(1);
             expect(proposals[0].metadata?.proposalType).toBe('p2id');
             if (proposals[0].metadata?.proposalType === 'p2id') {
@@ -1088,14 +2527,14 @@ describe('Multisig', () => {
                 expect(proposals[0].metadata.amount).toBe('12345');
             }
         });
-        it('should parse switch_psm proposal with snake_case fields', async () => {
+        it('should parse switch_guardian proposal with snake_case fields', async () => {
             const config = {
                 threshold: 1,
                 signerCommitments: ['0x' + 'a'.repeat(64)],
-                psmCommitment: '0x' + 'c'.repeat(64),
+                guardianCommitment: '0x' + 'c'.repeat(64),
             };
-            const multisig = new Multisig(mockAccount, config, psm, mockSigner, mockWebClient);
-            const switchPsmProposals = [
+            const multisig = new Multisig(mockAccount, config, guardian, mockSigner, mockWebClient);
+            const switchGuardianProposals = [
                 {
                     account_id: '0x' + 'a'.repeat(30),
                     nonce: 1,
@@ -1104,9 +2543,9 @@ describe('Multisig', () => {
                         tx_summary: { data: 'AQID' },
                         signatures: [],
                         metadata: {
-                            proposal_type: 'switch_psm',
-                            new_psm_pubkey: '0xnewpubkey',
-                            new_psm_endpoint: 'http://new-psm.com',
+                            proposal_type: 'switch_guardian',
+                            new_guardian_pubkey: '0xnewpubkey',
+                            new_guardian_endpoint: 'http://new-guardian.com',
                             salt: '0xsalt',
                         },
                     },
@@ -1120,14 +2559,14 @@ describe('Multisig', () => {
             ];
             mockFetch.mockResolvedValueOnce({
                 ok: true,
-                json: async () => ({ proposals: switchPsmProposals }),
+                json: async () => ({ proposals: switchGuardianProposals }),
             });
-            const proposals = await multisig.syncTransactionProposals();
+            const proposals = await multisig.syncProposals();
             expect(proposals.length).toBe(1);
-            expect(proposals[0].metadata?.proposalType).toBe('switch_psm');
-            if (proposals[0].metadata?.proposalType === 'switch_psm') {
-                expect(proposals[0].metadata.newPsmPubkey).toBe('0xnewpubkey');
-                expect(proposals[0].metadata.newPsmEndpoint).toBe('http://new-psm.com');
+            expect(proposals[0].metadata?.proposalType).toBe('switch_guardian');
+            if (proposals[0].metadata?.proposalType === 'switch_guardian') {
+                expect(proposals[0].metadata.newGuardianPubkey).toBe('0xnewpubkey');
+                expect(proposals[0].metadata.newGuardianEndpoint).toBe('http://new-guardian.com');
             }
         });
     });