@openzeppelin/miden-multisig-client 0.13.1 → 0.13.3

package/src/account/storage.ts

@@ -1,8 +1,9 @@
 import type { MultisigConfig } from '../types.js';
 import { StorageSlot, StorageMap, Word } from '@miden-sdk/miden-sdk';
-import { normalizeHexWord } from '../utils/encoding.js';
+import { ensureHexPrefix } from '../utils/encoding.js';
 import { getProcedureRoot } from '../procedures.js';
 
+// Storage slot names matching the MASM definitions
 const MULTISIG_SLOT_NAMES = {
   THRESHOLD_CONFIG: 'openzeppelin::multisig::threshold_config',
   SIGNER_PUBLIC_KEYS: 'openzeppelin::multisig::signer_public_keys',
@@ -10,9 +11,9 @@ const MULTISIG_SLOT_NAMES = {
   PROCEDURE_THRESHOLDS: 'openzeppelin::multisig::procedure_thresholds',
 } as const;
 
-const PSM_SLOT_NAMES = {
-  SELECTOR: 'openzeppelin::psm::selector',
-  PUBLIC_KEY: 'openzeppelin::psm::public_key',
+const GUARDIAN_SLOT_NAMES = {
+  SELECTOR: 'openzeppelin::guardian::selector',
+  PUBLIC_KEY: 'openzeppelin::guardian::public_key',
 } as const;
 
 export class StorageLayoutBuilder {
@@ -31,18 +32,19 @@ export class StorageLayoutBuilder {
     const signersMap = new StorageMap();
     config.signerCommitments.forEach((commitment, index) => {
       const key = new Word(new BigUint64Array([BigInt(index), 0n, 0n, 0n]));
-      const value = Word.fromHex(normalizeHexWord(commitment));
+      const value = Word.fromHex(ensureHexPrefix(commitment));
       signersMap.insert(key, value);
     });
     const slot1 = StorageSlot.map(MULTISIG_SLOT_NAMES.SIGNER_PUBLIC_KEYS, signersMap);
 
     const slot2 = StorageSlot.map(MULTISIG_SLOT_NAMES.EXECUTED_TRANSACTIONS, new StorageMap());
 
+    // Map entries: PROC_ROOT => [proc_threshold, 0, 0, 0]
+    // Use SDK's Word.fromHex to match how account code procedure roots are represented
     const procThresholdMap = new StorageMap();
     if (config.procedureThresholds) {
-      const signatureScheme = config.signatureScheme ?? 'falcon';
       for (const pt of config.procedureThresholds) {
-        const rootHex = getProcedureRoot(pt.procedure, signatureScheme);
+        const rootHex = getProcedureRoot(pt.procedure);
         const key = Word.fromHex(rootHex);
         const value = new Word(new BigUint64Array([BigInt(pt.threshold), 0n, 0n, 0n]));
         procThresholdMap.insert(key, value);
@@ -53,16 +55,16 @@ export class StorageLayoutBuilder {
     return [slot0, slot1, slot2, slot3];
   }
 
-  buildPsmSlots(config: MultisigConfig): StorageSlot[] {
-    const selector = config.psmEnabled !== false ? 1n : 0n;
+  buildGuardianSlots(config: MultisigConfig): StorageSlot[] {
+    const selector = config.guardianEnabled !== false ? 1n : 0n;
     const selectorWord = new Word(new BigUint64Array([selector, 0n, 0n, 0n]));
-    const slot0 = StorageSlot.fromValue(PSM_SLOT_NAMES.SELECTOR, selectorWord);
+    const slot0 = StorageSlot.fromValue(GUARDIAN_SLOT_NAMES.SELECTOR, selectorWord);
 
-    const psmKeyMap = new StorageMap();
+    const guardianKeyMap = new StorageMap();
     const zeroKey = new Word(new BigUint64Array([0n, 0n, 0n, 0n]));
-    const psmKey = Word.fromHex(normalizeHexWord(config.psmCommitment));
-    psmKeyMap.insert(zeroKey, psmKey);
-    const slot1 = StorageSlot.map(PSM_SLOT_NAMES.PUBLIC_KEY, psmKeyMap);
+    const guardianKey = Word.fromHex(ensureHexPrefix(config.guardianCommitment));
+    guardianKeyMap.insert(zeroKey, guardianKey);
+    const slot1 = StorageSlot.map(GUARDIAN_SLOT_NAMES.PUBLIC_KEY, guardianKeyMap);
 
     return [slot0, slot1];
   }
@@ -74,8 +76,8 @@ export function buildMultisigStorageSlots(config: MultisigConfig): StorageSlot[]
   return defaultStorageBuilder.buildMultisigSlots(config);
 }
 
-export function buildPsmStorageSlots(config: MultisigConfig): StorageSlot[] {
-  return defaultStorageBuilder.buildPsmSlots(config);
+export function buildGuardianStorageSlots(config: MultisigConfig): StorageSlot[] {
+  return defaultStorageBuilder.buildGuardianSlots(config);
 }
 
 export const storageLayoutBuilder = defaultStorageBuilder;

package/src/client.test.ts

@@ -14,6 +14,7 @@ vi.mock('@miden-sdk/miden-sdk', () => ({
         prefix: () => ({ asInt: () => BigInt(1) }),
         suffix: () => ({ asInt: () => BigInt(2) }),
       }),
+      serialize: () => new Uint8Array([1, 2, 3]),
       storage: vi.fn(),
       vault: vi.fn(),
     })),
@@ -27,8 +28,8 @@ vi.mock('./inspector.js', () => ({
       threshold: 2,
       numSigners: 2,
       signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-      psmEnabled: true,
-      psmCommitment: '0x' + 'c'.repeat(64),
+      guardianEnabled: true,
+      guardianCommitment: '0x' + 'c'.repeat(64),
       vaultBalances: [],
       procedureThresholds: new Map(),
     })),
@@ -50,7 +51,7 @@ vi.mock('./account/index.js', () => ({
   }),
 }));
 
-// Mock fetch for PSM client
+// Mock fetch for GUARDIAN client
 const mockFetch = vi.fn();
 vi.stubGlobal('fetch', mockFetch);
 
@@ -73,30 +74,31 @@ describe('MultisigClient', () => {
     };
 
     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)),
     };
   });
 
   describe('constructor', () => {
-    it('should create client with default PSM endpoint', () => {
+    it('should create client with default GUARDIAN endpoint', () => {
       const client = new MultisigClient(webClient);
       expect(client).toBeInstanceOf(MultisigClient);
     });
 
-    it('should create client with custom PSM endpoint', () => {
-      const client = new MultisigClient(webClient, { psmEndpoint: 'http://custom:8080' });
+    it('should create client with custom GUARDIAN endpoint', () => {
+      const client = new MultisigClient(webClient, { guardianEndpoint: 'http://custom:8080' });
       expect(client).toBeInstanceOf(MultisigClient);
     });
   });
 
-  describe('psmClient getter', () => {
-    it('should expose PSM client for getting pubkey', () => {
+  describe('guardianClient getter', () => {
+    it('should expose GUARDIAN client for getting pubkey', () => {
       const client = new MultisigClient(webClient);
-      expect(client.psmClient).toBeDefined();
+      expect(client.guardianClient).toBeDefined();
     });
   });
 
@@ -107,7 +109,7 @@ describe('MultisigClient', () => {
       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 = await client.create(config, mockSigner);
@@ -115,16 +117,16 @@ describe('MultisigClient', () => {
       expect(multisig).toBeDefined();
       expect(multisig.threshold).toBe(2);
       expect(multisig.signerCommitments).toEqual(config.signerCommitments);
-      expect(multisig.psmCommitment).toBe(config.psmCommitment);
+      expect(multisig.guardianCommitment).toBe(config.guardianCommitment);
     });
 
-    it('should set signer on PSM client', async () => {
+    it('should set signer on GUARDIAN client', async () => {
       const client = new MultisigClient(webClient);
 
       const config = {
         threshold: 1,
         signerCommitments: ['0x' + 'a'.repeat(64)],
-        psmCommitment: '0x' + 'c'.repeat(64),
+        guardianCommitment: '0x' + 'c'.repeat(64),
       };
 
       const multisig = await client.create(config, mockSigner);
@@ -156,11 +158,11 @@ describe('MultisigClient', () => {
       // Config is detected from account storage via AccountInspector
       expect(multisig.threshold).toBe(2);
       expect(multisig.signerCommitments).toEqual(['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)]);
-      expect(multisig.psmCommitment).toBe('0x' + 'c'.repeat(64));
+      expect(multisig.guardianCommitment).toBe('0x' + 'c'.repeat(64));
       expect(multisig.account).not.toBeNull();
     });
 
-    it('should throw if account not found on PSM', async () => {
+    it('should throw if account not found on GUARDIAN', async () => {
       const client = new MultisigClient(webClient);
 
       mockFetch.mockResolvedValueOnce({
@@ -174,40 +176,34 @@ describe('MultisigClient', () => {
         client.load('0xnonexistent', mockSigner)
       ).rejects.toThrow();
     });
-  });
 
-  describe('initialize', () => {
-    it('should fetch PSM pubkey and return commitment', async () => {
+    it('should allow registerOnGuardian after load without explicit initial state', async () => {
       const client = new MultisigClient(webClient);
 
       mockFetch.mockResolvedValueOnce({
         ok: true,
         json: async () => ({
-          commitment: '0x' + 'f'.repeat(64),
-          pubkey: '0x' + 'e'.repeat(64),
+          account_id: '0x' + 'd'.repeat(30),
+          commitment: '0x' + 'e'.repeat(64),
+          state_json: { data: 'base64state' },
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-02T00:00:00Z',
         }),
       });
 
-      const result = await client.initialize('falcon');
-
-      expect(result.psmCommitment).toBe('0x' + 'f'.repeat(64));
-      expect(result.psmPublicKey).toBe('0x' + 'e'.repeat(64));
-    });
-
-    it('should work without specifying scheme', async () => {
-      const client = new MultisigClient(webClient);
-
       mockFetch.mockResolvedValueOnce({
         ok: true,
         json: async () => ({
-          commitment: '0x' + 'f'.repeat(64),
+          success: true,
+          message: 'Account configured',
+          ack_pubkey: '0x' + 'f'.repeat(64),
         }),
       });
 
-      const result = await client.initialize();
+      const accountId = '0x' + 'd'.repeat(30);
+      const multisig = await client.load(accountId, mockSigner);
 
-      expect(result.psmCommitment).toBe('0x' + 'f'.repeat(64));
-      expect(result.psmPublicKey).toBeUndefined();
+      await expect(multisig.registerOnGuardian()).resolves.toBeUndefined();
     });
   });
 });

package/src/client.ts

@@ -1,52 +1,119 @@
+/**
+ * MultisigClient - Factory for creating and loading multisig accounts.
+ *
+ * This is the main entry point for the multisig SDK. It provides methods
+ * to create new multisig accounts and load existing ones.
+ */
+
 import { type WebClient, Account, AccountId } from '@miden-sdk/miden-sdk';
-import { PsmHttpClient, type SignatureScheme } from '@openzeppelin/psm-client';
+import { GuardianHttpClient } from '@openzeppelin/guardian-client';
 import { Multisig } from './multisig.js';
 import { createMultisigAccount } from './account/index.js';
 import { AccountInspector } from './inspector.js';
 import type { MultisigConfig, Signer } from './types.js';
 
+/**
+ * Configuration for MultisigClient.
+ */
 export interface MultisigClientConfig {
-  psmEndpoint?: string;
+  /** GUARDIAN server endpoint */
+  guardianEndpoint?: string;
+  /** Miden node RPC endpoint used for state commitment verification */
+  midenRpcEndpoint?: string;
 }
 
+/**
+ * Client for creating and loading multisig accounts.
+ *
+ * @example
+ * ```typescript
+ * import { MultisigClient, FalconSigner } from '@openzeppelin/miden-multisig-client';
+ * import { WebClient, SecretKey } from '@miden-sdk/miden-sdk';
+ *
+ * // Initialize
+ * const webClient = await WebClient.createClient('https://rpc.testnet.miden.io:443');
+ * const secretKey = SecretKey.rpoFalconWithRNG(seed);
+ * const signer = new FalconSigner(secretKey);
+ *
+ * // Create client
+ * const client = new MultisigClient(webClient, {
+ *   guardianEndpoint: 'http://localhost:3000',
+ *   midenRpcEndpoint: 'https://rpc.testnet.miden.io:443',
+ * });
+ *
+ * // Get GUARDIAN pubkey for config
+ * const guardianCommitment = await client.guardianClient.getPubkey();
+ *
+ * // Create multisig
+ * const config = { threshold: 2, signerCommitments: [...], guardianCommitment };
+ * const multisig = await client.create(config, signer);
+ * ```
+ */
 export class MultisigClient {
   private readonly webClient: WebClient;
-  private _psmClient: PsmHttpClient;
+  private readonly midenRpcEndpoint?: string;
+  private _guardianClient: GuardianHttpClient;
 
   constructor(webClient: WebClient, config: MultisigClientConfig = {}) {
     this.webClient = webClient;
-    this._psmClient = new PsmHttpClient(config.psmEndpoint ?? 'http://localhost:3000');
-  }
-
-  setPsmEndpoint(endpoint: string): void {
-    this._psmClient = new PsmHttpClient(endpoint);
+    this.midenRpcEndpoint = config.midenRpcEndpoint;
+    this._guardianClient = new GuardianHttpClient(config.guardianEndpoint ?? 'http://localhost:3000');
   }
 
-  async initialize(scheme?: SignatureScheme): Promise<{ psmCommitment: string; psmPublicKey?: string }> {
-    const { commitment, pubkey } = await this._psmClient.getPubkey(scheme);
-    return { psmCommitment: commitment, psmPublicKey: pubkey };
+  /**
+   * Change the GUARDIAN endpoint.
+   * 
+   * @param endpoint - The new GUARDIAN server endpoint URL
+   */
+  setGuardianEndpoint(endpoint: string): void {
+    this._guardianClient = new GuardianHttpClient(endpoint);
   }
 
-  get psmClient(): PsmHttpClient {
-    return this._psmClient;
+  /**
+   * Access the internal GUARDIAN client.
+   */
+  get guardianClient(): GuardianHttpClient {
+    return this._guardianClient;
   }
 
+  /**
+   * Create a new multisig account.
+   *
+   * @param config - Multisig configuration (threshold, signers, GUARDIAN commitment)
+   * @param signer - The signer for this client (one of the cosigners)
+   * @returns A Multisig instance wrapping the created account
+   */
   async create(config: MultisigConfig, signer: Signer): Promise<Multisig> {
-    this._psmClient.setSigner(signer);
+    this._guardianClient.setSigner(signer);
 
     const { account } = await createMultisigAccount(this.webClient, config);
 
-    return new Multisig(account, config, this._psmClient, signer, this.webClient);
+    return new Multisig(
+      account,
+      config,
+      this._guardianClient,
+      signer,
+      this.webClient,
+      undefined,
+      this.midenRpcEndpoint
+    );
   }
 
+  /**
+   * Load an existing multisig account from GUARDIAN.
+   *
+   * @param accountId - The account ID to load
+   * @param signer - The signer for this client
+   * @returns A Multisig instance for the loaded account
+   */
   async load(accountId: string, signer: Signer): Promise<Multisig> {
-    this._psmClient.setSigner(signer);
+    this._guardianClient.setSigner(signer);
 
-    const stateResponse = await this._psmClient.getState(accountId);
+    const stateResponse = await this._guardianClient.getState(accountId);
 
     const accountBase64 = stateResponse.stateJson.data;
     if (!accountBase64) {
-      throw new Error('No account data found in PSM state');
+      throw new Error('No account data found in GUARDIAN state');
     }
 
     const binaryString = atob(accountBase64);
@@ -56,15 +123,12 @@ export class MultisigClient {
     }
     const account = Account.deserialize(accountBytes);
 
-    const detectedScheme: SignatureScheme = signer.scheme;
-
-    const detected = AccountInspector.fromAccount(account, detectedScheme);
+    const detected = AccountInspector.fromAccount(account);
     const config: MultisigConfig = {
       threshold: detected.threshold,
       signerCommitments: detected.signerCommitments,
-      psmCommitment: detected.psmCommitment ?? '',
-      psmEnabled: detected.psmEnabled,
-      signatureScheme: detected.signatureScheme,
+      guardianCommitment: detected.guardianCommitment ?? '',
+      guardianEnabled: detected.guardianEnabled,
       procedureThresholds: Array.from(detected.procedureThresholds.entries()).map(
         ([procedure, threshold]) => ({ procedure, threshold })
       ),
@@ -72,9 +136,17 @@ export class MultisigClient {
 
     const existingAccount = await this.webClient.getAccount(AccountId.fromHex(accountId));
     if (!existingAccount) {
-      await this.webClient.newAccount(account, true);
+        await this.webClient.newAccount(account, true);
     }
 
-    return new Multisig(account, config, this._psmClient, signer, this.webClient, accountId);
+    return new Multisig(
+      account,
+      config,
+      this._guardianClient,
+      signer,
+      this.webClient,
+      accountId,
+      this.midenRpcEndpoint
+    );
   }
 }

package/src/index.ts

@@ -1,38 +1,87 @@
+/**
+ * @openzeppelin/miden-multisig-client
+ *
+ * TypeScript SDK for Miden multisig accounts with Guardian integration.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MultisigClient,
+ *   FalconSigner,
+ * } from '@openzeppelin/miden-multisig-client';
+ * import { WebClient, SecretKey } from '@miden-sdk/miden-sdk';
+ *
+ * // Initialize WebClient
+ * const webClient = await WebClient.createClient('https://rpc.testnet.miden.io:443');
+ * await webClient.syncState();
+ *
+ * // Generate a key dynamically
+ * const seed = new Uint8Array(32);
+ * crypto.getRandomValues(seed);
+ * const secretKey = SecretKey.rpoFalconWithRNG(seed);
+ *
+ * // Store in miden-sdk's keystore
+ * await webClient.addAccountSecretKeyToWebStore(secretKey);
+ *
+ * // Create a signer
+ * const signer = new FalconSigner(secretKey);
+ *
+ * // Create multisig client
+ * const client = new MultisigClient(webClient, {
+ *   guardianEndpoint: 'http://localhost:3000',
+ *   midenRpcEndpoint: 'https://rpc.testnet.miden.io:443',
+ * });
+ *
+ * // Get GUARDIAN pubkey for config
+ * const guardianCommitment = await client.guardianClient.getPubkey();
+ *
+ * // Create multisig account
+ * const config = { threshold: 2, signerCommitments: [signer.commitment, ...], guardianCommitment };
+ * const multisig = await client.create(config, signer);
+ *
+ * // Register on GUARDIAN and work with proposals
+ * await multisig.registerOnGuardian();
+ * await multisig.syncProposals();
+ * ```
+ */
+
 export { MultisigClient, type MultisigClientConfig } from './client.js';
 export { Multisig, type AccountState } from './multisig.js';
 export { AccountInspector, type DetectedMultisigConfig, type VaultBalance } from './inspector.js';
 export {
   executeForSummary,
   buildUpdateSignersTransactionRequest,
-  buildUpdatePsmTransactionRequest,
+  buildUpdateProcedureThresholdTransactionRequest,
+  buildUpdateGuardianTransactionRequest,
   buildConsumeNotesTransactionRequest,
   buildP2idTransactionRequest,
 } from './transaction.js';
 
-export { PsmHttpClient, PsmHttpError } from '@openzeppelin/psm-client';
+export { GuardianHttpClient, GuardianHttpError } from '@openzeppelin/guardian-client';
 
-export { FalconSigner, EcdsaSigner, ParaSigner, MidenWalletSigner } from './signers/index.js';
-export type { ParaSigningContext } from './signers/para.js';
-export type { WalletSigningContext } from './signers/miden-wallet.js';
-export { AuthDigest } from './utils/digest.js';
-export { EcdsaFormat } from './utils/ecdsa.js';
+export {
+  FalconSigner,
+  EcdsaSigner,
+  ParaSigner,
+  MidenWalletSigner,
+  type ParaSigningContext,
+  type WalletSigningContext,
+} from './signer.js';
 export { PublicKeyFormat } from './utils/key.js';
-export { wordToBytes } from './utils/word.js';
-export { tryComputeEcdsaCommitmentHex, tryComputeCommitmentHex } from './utils/signature.js';
+export { EcdsaFormat } from './utils/ecdsa.js';
+export { tryComputeEcdsaCommitmentHex } from './utils/signature.js';
 
 export {
   createMultisigAccount,
   validateMultisigConfig,
   buildMultisigStorageSlots,
-  buildPsmStorageSlots,
+  buildGuardianStorageSlots,
   storageLayoutBuilder,
   StorageLayoutBuilder,
 } from './account/index.js';
 
 export {
   PROCEDURE_ROOTS,
-  PROCEDURE_ROOTS_FALCON,
-  PROCEDURE_ROOTS_ECDSA,
   getProcedureRoot,
   isProcedureName,
   getProcedureNames,
@@ -40,32 +89,45 @@ export {
 } from './procedures.js';
 
 export type {
+  // Account types
   MultisigAccountState,
   MultisigConfig,
   CreateAccountResult,
   ProcedureThreshold,
-  TransactionProposal,
-  TransactionProposalStatus,
-  TransactionProposalSignature,
-  ExportedTransactionProposal,
-  SignTransactionProposalParams,
-  SyncResult,
-  TransactionProposalResult,
+
+  // Proposal types
+  Proposal,
+  ProposalStatus,
+  ProposalSignatureEntry,
   ProposalMetadata,
   ProposalType,
+  ExportedProposal,
+  ExportedTransactionProposal,
+  SignTransactionProposalParams,
+  TransactionProposal,
+  TransactionProposalSignature,
+  TransactionProposalStatus,
+
+  // Transaction types
   TransactionType,
+
+  // Note types
   ConsumableNote,
   NoteAsset,
+
+  // Signature types
   FalconSignature,
-  EcdsaSignature,
-  ProposalSignature,
-  SignatureScheme,
   Signer,
+  SignatureScheme,
+
+  // GUARDIAN API types
   AuthConfig,
   DeltaObject,
   DeltaStatus,
   StateObject,
   CosignerSignature,
+
+  // Request/Response types
   ConfigureRequest,
   ConfigureResponse,
   DeltaProposalRequest,

package/src/inspector.test.ts

@@ -9,9 +9,9 @@ const MULTISIG_SLOT_NAMES = {
   PROCEDURE_THRESHOLDS: 'openzeppelin::multisig::procedure_thresholds',
 } as const;
 
-const PSM_SLOT_NAMES = {
-  SELECTOR: 'openzeppelin::psm::selector',
-  PUBLIC_KEY: 'openzeppelin::psm::public_key',
+const GUARDIAN_SLOT_NAMES = {
+  SELECTOR: 'openzeppelin::guardian::selector',
+  PUBLIC_KEY: 'openzeppelin::guardian::public_key',
 } as const;
 
 // Mock the Miden SDK
@@ -44,25 +44,25 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     Account: {
       deserialize: vi.fn((bytes: Uint8Array) => {
         // Return different mocked accounts based on test scenario
-        // Default: 2-of-3 multisig with PSM enabled
+        // Default: 2-of-3 multisig with GUARDIAN enabled
         const slot0 = createMockWord([2n, 3n, 0n, 0n]); // threshold=2, numSigners=3
-        const slot4 = createMockWord([1n, 0n, 0n, 0n]); // PSM enabled
+        const slot4 = createMockWord([1n, 0n, 0n, 0n]); // GUARDIAN enabled
 
         const signerMap = new Map<string, any>();
         signerMap.set('0', createMockWord([BigInt('0x1111111111111111'), BigInt('0x2222222222222222'), BigInt('0x3333333333333333'), BigInt('0x4444444444444444')]));
         signerMap.set('1', createMockWord([BigInt('0x5555555555555555'), BigInt('0x6666666666666666'), BigInt('0x7777777777777777'), BigInt('0x8888888888888888')]));
         signerMap.set('2', createMockWord([BigInt('0xaaaaaaaaaaaaaaaa'), BigInt('0xbbbbbbbbbbbbbbbb'), BigInt('0xcccccccccccccccc'), BigInt('0xdddddddddddddddd')]));
 
-        const psmMap = new Map<string, any>();
-        psmMap.set('0', createMockWord([BigInt('0xeeeeeeeeeeeeeeee'), BigInt('0xffffffffffffffff'), BigInt('0x0000000000000001'), BigInt('0x0000000000000002')]));
+        const guardianMap = new Map<string, any>();
+        guardianMap.set('0', createMockWord([BigInt('0xeeeeeeeeeeeeeeee'), BigInt('0xffffffffffffffff'), BigInt('0x0000000000000001'), BigInt('0x0000000000000002')]));
 
         const slots = new Map<string, any>();
         slots.set('openzeppelin::multisig::threshold_config', slot0);
-        slots.set('openzeppelin::psm::selector', slot4);
+        slots.set('openzeppelin::guardian::selector', slot4);
 
         const maps = new Map<string, Map<string, any>>();
         maps.set('openzeppelin::multisig::signer_public_keys', signerMap);
-        maps.set('openzeppelin::psm::public_key', psmMap);
+        maps.set('openzeppelin::guardian::public_key', guardianMap);
 
         return {
           storage: () => createMockStorage(slots, maps),
@@ -94,12 +94,12 @@ describe('AccountInspector', () => {
       expect(config.numSigners).toBe(3);
     });
 
-    it('extracts PSM status', () => {
+    it('extracts GUARDIAN status', () => {
       const base64 = btoa(String.fromCharCode(...new Uint8Array([1, 2, 3])));
       const config = AccountInspector.fromBase64(base64);
 
-      expect(config.psmEnabled).toBe(true);
-      expect(config.psmCommitment).toMatch(/^0x[a-f0-9]+$/);
+      expect(config.guardianEnabled).toBe(true);
+      expect(config.guardianCommitment).toMatch(/^0x[a-f0-9]+$/);
     });
 
     it('extracts signer commitments', () => {
@@ -146,7 +146,7 @@ describe('AccountInspector edge cases', () => {
     vi.clearAllMocks();
   });
 
-  it('handles account with PSM disabled', async () => {
+  it('handles account with GUARDIAN disabled', async () => {
     const { Account } = await import('@miden-sdk/miden-sdk');
 
     // Override mock for this test
@@ -154,7 +154,7 @@ describe('AccountInspector edge cases', () => {
       storage: () => ({
         getItem: (slotName: string) => {
           if (slotName === 'openzeppelin::multisig::threshold_config') return { toU64s: () => [1n, 1n, 0n, 0n] };
-          if (slotName === 'openzeppelin::psm::selector') return { toU64s: () => [0n, 0n, 0n, 0n] }; // PSM disabled
+          if (slotName === 'openzeppelin::guardian::selector') return { toU64s: () => [0n, 0n, 0n, 0n] }; // GUARDIAN disabled
           return { toU64s: () => [0n, 0n, 0n, 0n] };
         },
         getMapItem: (slotName: string, key: any) => {
@@ -175,8 +175,8 @@ describe('AccountInspector edge cases', () => {
     const account = Account.deserialize(new Uint8Array([1, 2, 3]));
     const config = AccountInspector.fromAccount(account);
 
-    expect(config.psmEnabled).toBe(false);
-    expect(config.psmCommitment).toBeNull();
+    expect(config.guardianEnabled).toBe(false);
+    expect(config.guardianCommitment).toBeNull();
   });
 
   it('handles account with empty vault', async () => {
@@ -207,7 +207,7 @@ describe('AccountInspector edge cases', () => {
       storage: () => ({
         getItem: (slotName: string) => {
           if (slotName === 'openzeppelin::multisig::threshold_config') return { toU64s: () => [2n, 5n, 0n, 0n] }; // threshold=2, numSigners=5
-          if (slotName === 'openzeppelin::psm::selector') return { toU64s: () => [0n, 0n, 0n, 0n] };
+          if (slotName === 'openzeppelin::guardian::selector') return { toU64s: () => [0n, 0n, 0n, 0n] };
           return { toU64s: () => [0n, 0n, 0n, 0n] };
         },
         getMapItem: () => {