@openzeppelin/miden-multisig-client 0.12.8 → 0.13.0

package/src/signer.ts

@@ -1,95 +1,2 @@
-import { SecretKey, Word, AccountId, Felt, FeltArray, Rpo256 } from '@demox-labs/miden-sdk';
-import type { Signer, SignatureScheme } from './types.js';
-import { bytesToHex } from './utils/encoding.js';
-
-export class FalconSigner implements Signer {
-  readonly commitment: string;
-  readonly publicKey: string;
-  readonly scheme: SignatureScheme = 'falcon';
-  private readonly secretKey: SecretKey;
-
-  constructor(secretKey: SecretKey) {
-    this.secretKey = secretKey;
-    const pubKey = secretKey.publicKey();
-    this.commitment = pubKey.toCommitment().toHex();
-    const serialized = pubKey.serialize();
-    const falconPubKey = serialized.slice(1);
-    this.publicKey = bytesToHex(falconPubKey);
-  }
-
-  signAccountIdWithTimestamp(accountId: string, timestamp: number): string {
-    const paddedHex = accountId.startsWith('0x') ? accountId : `0x${accountId}`;
-    const parsedAccountId = AccountId.fromHex(paddedHex);
-    const prefix = parsedAccountId.prefix();
-    const suffix = parsedAccountId.suffix();
-
-    const feltArray = new FeltArray([
-      prefix,
-      suffix,
-      new Felt(BigInt(timestamp)),
-      new Felt(BigInt(0)),
-    ]);
-
-    const digest = Rpo256.hashElements(feltArray);
-    const signature = this.secretKey.sign(digest);
-    const signatureBytes = signature.serialize();
-    const falconSignature = signatureBytes.slice(1);
-    return bytesToHex(falconSignature);
-  }
-
-  signCommitment(commitmentHex: string): string {
-    const paddedHex = commitmentHex.startsWith('0x') ? commitmentHex : `0x${commitmentHex}`;
-    const cleanHex = paddedHex.slice(2).padStart(64, '0');
-    const word = Word.fromHex(`0x${cleanHex}`);
-    const signature = this.secretKey.sign(word);
-    const signatureBytes = signature.serialize();
-    const falconSignature = signatureBytes.slice(1);
-    return bytesToHex(falconSignature);
-  }
-}
-
-export class EcdsaSigner implements Signer {
-  readonly commitment: string;
-  readonly publicKey: string;
-  readonly scheme: SignatureScheme = 'ecdsa';
-  private readonly secretKey: SecretKey;
-
-  constructor(secretKey: SecretKey) {
-    this.secretKey = secretKey;
-    const pubKey = secretKey.publicKey();
-    this.commitment = pubKey.toCommitment().toHex();
-    const serialized = pubKey.serialize();
-    const ecdsaPubKey = serialized.slice(1);
-    this.publicKey = bytesToHex(ecdsaPubKey);
-  }
-
-  signAccountIdWithTimestamp(accountId: string, timestamp: number): string {
-    const paddedHex = accountId.startsWith('0x') ? accountId : `0x${accountId}`;
-    const parsedAccountId = AccountId.fromHex(paddedHex);
-    const prefix = parsedAccountId.prefix();
-    const suffix = parsedAccountId.suffix();
-
-    const feltArray = new FeltArray([
-      prefix,
-      suffix,
-      new Felt(BigInt(timestamp)),
-      new Felt(BigInt(0)),
-    ]);
-
-    const digest = Rpo256.hashElements(feltArray);
-    const signature = this.secretKey.sign(digest);
-    const signatureBytes = signature.serialize();
-    const ecdsaSignature = signatureBytes.slice(1);
-    return bytesToHex(ecdsaSignature);
-  }
-
-  signCommitment(commitmentHex: string): string {
-    const paddedHex = commitmentHex.startsWith('0x') ? commitmentHex : `0x${commitmentHex}`;
-    const cleanHex = paddedHex.slice(2).padStart(64, '0');
-    const word = Word.fromHex(`0x${cleanHex}`);
-    const signature = this.secretKey.sign(word);
-    const signatureBytes = signature.serialize();
-    const ecdsaSignature = signatureBytes.slice(1);
-    return bytesToHex(ecdsaSignature);
-  }
-}
+export { FalconSigner } from './signers/falcon.js';
+export { EcdsaSigner } from './signers/ecdsa.js';

package/src/signers/ecdsa.ts

@@ -0,0 +1,35 @@
+import { AuthSecretKey } from '@miden-sdk/miden-sdk';
+import type { Signer, SignatureScheme } from '../types.js';
+import { bytesToHex, normalizeHexWord } from '../utils/encoding.js';
+import { AuthDigest } from '../utils/digest.js';
+
+export class EcdsaSigner implements Signer {
+  readonly commitment: string;
+  readonly publicKey: string;
+  readonly scheme: SignatureScheme = 'ecdsa';
+  private readonly secretKey: AuthSecretKey;
+
+  constructor(secretKey: AuthSecretKey) {
+    this.secretKey = secretKey;
+    const pubKey = secretKey.publicKey();
+    const serialized = pubKey.serialize();
+    this.publicKey = bytesToHex(serialized.slice(1));
+    this.commitment = normalizeHexWord(pubKey.toCommitment().toHex());
+  }
+
+  async signAccountIdWithTimestamp(accountId: string, timestamp: number): Promise<string> {
+    const digest = AuthDigest.fromAccountIdWithTimestamp(accountId, timestamp);
+    const signature = this.secretKey.sign(digest);
+    const signatureBytes = signature.serialize();
+    const ecdsaSignature = signatureBytes.slice(1);
+    return bytesToHex(ecdsaSignature);
+  }
+
+  async signCommitment(commitmentHex: string): Promise<string> {
+    const word = AuthDigest.fromCommitmentHex(commitmentHex);
+    const signature = this.secretKey.sign(word);
+    const signatureBytes = signature.serialize();
+    const ecdsaSignature = signatureBytes.slice(1);
+    return bytesToHex(ecdsaSignature);
+  }
+}

package/src/{signer.test.ts → signers/falcon.test.ts}

@@ -1,8 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { FalconSigner } from './signer.js';
+import { FalconSigner } from './falcon.js';
 
-// Mock the Miden SDK
-vi.mock('@demox-labs/miden-sdk', () => {
+vi.mock('@miden-sdk/miden-sdk', () => {
   const mockSignature = {
     serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
   };
@@ -20,7 +19,7 @@ vi.mock('@demox-labs/miden-sdk', () => {
   };
 
   return {
-    SecretKey: {
+    AuthSecretKey: {
       rpoFalconWithRNG: vi.fn().mockReturnValue(mockSecretKey),
     },
     Word: {
@@ -51,8 +50,8 @@ describe('FalconSigner', () => {
 
   beforeEach(async () => {
     vi.clearAllMocks();
-    const { SecretKey } = await import('@demox-labs/miden-sdk');
-    mockSecretKey = SecretKey.rpoFalconWithRNG(new Uint8Array(32));
+    const { AuthSecretKey } = await import('@miden-sdk/miden-sdk');
+    mockSecretKey = AuthSecretKey.rpoFalconWithRNG(new Uint8Array(32));
     signer = new FalconSigner(mockSecretKey);
   });
 
@@ -62,7 +61,6 @@ describe('FalconSigner', () => {
     });
 
     it('extracts public key without first byte', () => {
-      // Public key serialized is [0, 1, 2, ...15], slice(1) removes first byte
       expect(signer.publicKey).toBe('0x0102030405060708090a0b0c0d0e0f');
     });
 
@@ -72,63 +70,61 @@ describe('FalconSigner', () => {
   });
 
   describe('signAccountIdWithTimestamp', () => {
-    it('handles account ID with 0x prefix', () => {
-      const signature = signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
+    it('handles account ID with 0x prefix', async () => {
+      const signature = await signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
       expect(signature).toMatch(/^0x[a-f0-9]+$/);
     });
 
-    it('handles account ID without 0x prefix', () => {
-      const signature = signer.signAccountIdWithTimestamp('a'.repeat(30), 1700000000);
+    it('handles account ID without 0x prefix', async () => {
+      const signature = await signer.signAccountIdWithTimestamp('a'.repeat(30), 1700000000);
       expect(signature).toMatch(/^0x[a-f0-9]+$/);
     });
 
-    it('calls sign method with hashed digest', () => {
-      signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
+    it('calls sign method with hashed digest', async () => {
+      await signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
       expect(mockSecretKey.sign).toHaveBeenCalled();
     });
 
-    it('returns signature without first byte', () => {
-      // Signature serialized is [0, 1, 2, ...9], slice(1) returns [1, 2, ...9]
-      const signature = signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
+    it('returns signature without first byte', async () => {
+      const signature = await signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
       expect(signature).toBe('0x010203040506070809');
     });
 
     it('includes timestamp in signed payload', async () => {
-      const { Felt, FeltArray } = await import('@demox-labs/miden-sdk');
-      signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
-      // Verify FeltArray was called with timestamp in the third position
+      const { Felt, FeltArray } = await import('@miden-sdk/miden-sdk');
+      await signer.signAccountIdWithTimestamp('0x' + 'a'.repeat(30), 1700000000);
       expect(FeltArray).toHaveBeenCalledWith(expect.arrayContaining([
-        expect.anything(), // prefix
-        expect.anything(), // suffix
-        expect.anything(), // timestamp
-        expect.anything(), // zero padding
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
       ]));
     });
   });
 
   describe('signCommitment', () => {
-    it('handles commitment with 0x prefix', () => {
-      const signature = signer.signCommitment('0x' + 'c'.repeat(64));
+    it('handles commitment with 0x prefix', async () => {
+      const signature = await signer.signCommitment('0x' + 'c'.repeat(64));
       expect(signature).toMatch(/^0x[a-f0-9]+$/);
     });
 
-    it('handles commitment without 0x prefix', () => {
-      const signature = signer.signCommitment('c'.repeat(64));
+    it('handles commitment without 0x prefix', async () => {
+      const signature = await signer.signCommitment('c'.repeat(64));
       expect(signature).toMatch(/^0x[a-f0-9]+$/);
     });
 
-    it('pads short commitment hex to 64 characters', () => {
-      const signature = signer.signCommitment('abc');
+    it('pads short commitment hex to 64 characters', async () => {
+      const signature = await signer.signCommitment('abc');
       expect(signature).toMatch(/^0x[a-f0-9]+$/);
     });
 
-    it('calls sign method with word from hex', () => {
-      signer.signCommitment('0x' + 'c'.repeat(64));
+    it('calls sign method with word from hex', async () => {
+      await signer.signCommitment('0x' + 'c'.repeat(64));
       expect(mockSecretKey.sign).toHaveBeenCalled();
     });
 
-    it('returns signature without first byte', () => {
-      const signature = signer.signCommitment('0x' + 'c'.repeat(64));
+    it('returns signature without first byte', async () => {
+      const signature = await signer.signCommitment('0x' + 'c'.repeat(64));
       expect(signature).toBe('0x010203040506070809');
     });
   });

package/src/signers/falcon.ts

@@ -0,0 +1,36 @@
+import { AuthSecretKey } from '@miden-sdk/miden-sdk';
+import type { Signer, SignatureScheme } from '../types.js';
+import { bytesToHex } from '../utils/encoding.js';
+import { AuthDigest } from '../utils/digest.js';
+
+export class FalconSigner implements Signer {
+  readonly commitment: string;
+  readonly publicKey: string;
+  readonly scheme: SignatureScheme = 'falcon';
+  private readonly secretKey: AuthSecretKey;
+
+  constructor(secretKey: AuthSecretKey) {
+    this.secretKey = secretKey;
+    const pubKey = secretKey.publicKey();
+    this.commitment = pubKey.toCommitment().toHex();
+    const serialized = pubKey.serialize();
+    const falconPubKey = serialized.slice(1);
+    this.publicKey = bytesToHex(falconPubKey);
+  }
+
+  async signAccountIdWithTimestamp(accountId: string, timestamp: number): Promise<string> {
+    const digest = AuthDigest.fromAccountIdWithTimestamp(accountId, timestamp);
+    const signature = this.secretKey.sign(digest);
+    const signatureBytes = signature.serialize();
+    const falconSignature = signatureBytes.slice(1);
+    return bytesToHex(falconSignature);
+  }
+
+  async signCommitment(commitmentHex: string): Promise<string> {
+    const word = AuthDigest.fromCommitmentHex(commitmentHex);
+    const signature = this.secretKey.sign(word);
+    const signatureBytes = signature.serialize();
+    const falconSignature = signatureBytes.slice(1);
+    return bytesToHex(falconSignature);
+  }
+}

package/src/signers/index.ts

@@ -0,0 +1,4 @@
+export { FalconSigner } from './falcon.js';
+export { EcdsaSigner } from './ecdsa.js';
+export { ParaSigner, type ParaSigningContext } from './para.js';
+export { MidenWalletSigner, type WalletSigningContext } from './miden-wallet.js';

package/src/signers/miden-wallet.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MidenWalletSigner } from './miden-wallet.js';
+import type { WalletSigningContext } from './miden-wallet.js';
+import type { Signer } from '../types.js';
+
+vi.mock('@miden-sdk/miden-sdk', () => ({
+  Word: {
+    fromHex: vi.fn((hex: string) => ({
+      toHex: () => hex,
+      toFelts: () => [
+        { asInt: () => 1n },
+        { asInt: () => 2n },
+        { asInt: () => 3n },
+        { asInt: () => 4n },
+      ],
+    })),
+  },
+  AccountId: {
+    fromHex: vi.fn(() => ({
+      prefix: () => ({ asInt: () => BigInt(1) }),
+      suffix: () => ({ asInt: () => BigInt(2) }),
+    })),
+  },
+  Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
+  FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
+  Rpo256: {
+    hashElements: vi.fn().mockReturnValue({
+      toHex: () => '0x' + 'bb'.repeat(32),
+      toFelts: () => [
+        { asInt: () => 10n },
+        { asInt: () => 20n },
+        { asInt: () => 30n },
+        { asInt: () => 40n },
+      ],
+    }),
+  },
+}));
+
+describe('MidenWalletSigner', () => {
+  let mockWallet: WalletSigningContext;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWallet = {
+      signBytes: vi.fn().mockResolvedValue(new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04])),
+    };
+  });
+
+  describe('constructor', () => {
+    it('should set commitment, scheme, and publicKey', () => {
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'falcon');
+      expect(signer.commitment).toBe('0xcommitment');
+      expect(signer.scheme).toBe('falcon');
+      expect(signer.publicKey).toBe('0xcommitment');
+    });
+
+    it('should use localAuthSigner publicKey when provided', () => {
+      const localSigner: Signer = {
+        commitment: '0xlocal',
+        publicKey: '0xlocalpubkey',
+        scheme: 'ecdsa',
+        signAccountIdWithTimestamp: vi.fn(),
+        signCommitment: vi.fn(),
+      };
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'ecdsa', localSigner);
+      expect(signer.publicKey).toBe('0xlocalpubkey');
+    });
+  });
+
+  describe('signAccountIdWithTimestamp', () => {
+    it('should delegate to localAuthSigner when present', async () => {
+      const localSigner: Signer = {
+        commitment: '0xlocal',
+        publicKey: '0xlocalpubkey',
+        scheme: 'ecdsa',
+        signAccountIdWithTimestamp: vi.fn().mockResolvedValue('0xlocalsig'),
+        signCommitment: vi.fn(),
+      };
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'ecdsa', localSigner);
+      const result = await signer.signAccountIdWithTimestamp('0x' + 'aa'.repeat(15), 1700000000);
+      expect(result).toBe('0xlocalsig');
+      expect(localSigner.signAccountIdWithTimestamp).toHaveBeenCalledWith('0x' + 'aa'.repeat(15), 1700000000);
+      expect(mockWallet.signBytes).not.toHaveBeenCalled();
+    });
+
+    it('should use wallet signing when no localAuthSigner', async () => {
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'falcon');
+      const result = await signer.signAccountIdWithTimestamp('0x' + 'aa'.repeat(15), 1700000000);
+      expect(mockWallet.signBytes).toHaveBeenCalled();
+      expect(result).toMatch(/^0x/);
+    });
+  });
+
+  describe('signCommitment', () => {
+    it('should always use wallet signing', async () => {
+      const localSigner: Signer = {
+        commitment: '0xlocal',
+        publicKey: '0xlocalpubkey',
+        scheme: 'ecdsa',
+        signAccountIdWithTimestamp: vi.fn(),
+        signCommitment: vi.fn(),
+      };
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'ecdsa', localSigner);
+      await signer.signCommitment('0x' + 'cc'.repeat(32));
+      expect(mockWallet.signBytes).toHaveBeenCalled();
+    });
+  });
+
+  describe('signature byte stripping', () => {
+    it('should strip the first byte from wallet signature response', async () => {
+      (mockWallet.signBytes as ReturnType<typeof vi.fn>).mockResolvedValue(
+        new Uint8Array([0x00, 0xaa, 0xbb, 0xcc]),
+      );
+      const signer = new MidenWalletSigner(mockWallet, '0xcommitment', 'falcon');
+      const result = await signer.signCommitment('0x' + 'cc'.repeat(32));
+      expect(result).toBe('0xaabbcc');
+    });
+  });
+});

package/src/signers/miden-wallet.ts

@@ -0,0 +1,49 @@
+import type { Signer, SignatureScheme } from '../types.js';
+import { AuthDigest } from '../utils/digest.js';
+import { bytesToHex } from '../utils/encoding.js';
+import { wordToBytes } from '../utils/word.js';
+
+export interface WalletSigningContext {
+  signBytes(data: Uint8Array, kind: 'word' | 'signingInputs'): Promise<Uint8Array>;
+}
+
+export class MidenWalletSigner implements Signer {
+  readonly commitment: string;
+  readonly publicKey: string;
+  readonly scheme: SignatureScheme;
+  private readonly wallet: WalletSigningContext;
+  private readonly localAuthSigner: Signer | null;
+
+  constructor(
+    wallet: WalletSigningContext,
+    commitment: string,
+    scheme: SignatureScheme,
+    localAuthSigner?: Signer,
+  ) {
+    this.wallet = wallet;
+    this.commitment = commitment;
+    this.scheme = scheme;
+    this.localAuthSigner = localAuthSigner ?? null;
+    this.publicKey = localAuthSigner?.publicKey ?? commitment;
+  }
+
+  async signAccountIdWithTimestamp(accountId: string, timestamp: number): Promise<string> {
+    if (this.localAuthSigner) {
+      return this.localAuthSigner.signAccountIdWithTimestamp(accountId, timestamp);
+    }
+    const word = AuthDigest.fromAccountIdWithTimestamp(accountId, timestamp);
+    return this.signWord(word);
+  }
+
+  async signCommitment(commitmentHex: string): Promise<string> {
+    const word = AuthDigest.fromCommitmentHex(commitmentHex);
+    return this.signWord(word);
+  }
+
+  private async signWord(word: { toFelts: () => Array<{ asInt: () => bigint }> }): Promise<string> {
+    const bytes = wordToBytes(word);
+    const signatureBytes = await this.wallet.signBytes(bytes, 'word');
+    const rawSignature = signatureBytes.slice(1);
+    return bytesToHex(rawSignature);
+  }
+}

package/src/signers/para.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ParaSigner } from './para.js';
+import type { ParaSigningContext } from './para.js';
+
+vi.mock('@miden-sdk/miden-sdk', () => ({
+  Word: {
+    fromHex: vi.fn((hex: string) => ({
+      toHex: () => hex,
+      toFelts: () => [
+        { asInt: () => 1n },
+        { asInt: () => 2n },
+        { asInt: () => 3n },
+        { asInt: () => 4n },
+      ],
+    })),
+  },
+  AccountId: {
+    fromHex: vi.fn(() => ({
+      prefix: () => ({ asInt: () => BigInt(1) }),
+      suffix: () => ({ asInt: () => BigInt(2) }),
+    })),
+  },
+  Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
+  FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
+  Rpo256: {
+    hashElements: vi.fn().mockReturnValue({
+      toHex: () => '0x' + 'bb'.repeat(32),
+      toFelts: () => [
+        { asInt: () => 10n },
+        { asInt: () => 20n },
+        { asInt: () => 30n },
+        { asInt: () => 40n },
+      ],
+    }),
+  },
+}));
+
+describe('ParaSigner', () => {
+  let mockPara: ParaSigningContext;
+  const validCompressedKey = '0x02' + 'aa'.repeat(32);
+  const validUncompressedKey = '0x04' + 'aa'.repeat(32) + 'bb'.repeat(31) + 'b0';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPara = {
+      signMessage: vi.fn().mockResolvedValue({
+        signature: '0x' + 'cc'.repeat(64),
+      }),
+    };
+  });
+
+  describe('constructor', () => {
+    it('should accept a valid compressed public key', () => {
+      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
+      expect(signer.publicKey).toBe(validCompressedKey);
+      expect(signer.commitment).toBe('0xcommitment');
+      expect(signer.scheme).toBe('ecdsa');
+    });
+
+    it('should compress an uncompressed public key', () => {
+      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validUncompressedKey);
+      expect(signer.publicKey).toBe('0x02' + 'aa'.repeat(32));
+    });
+
+    it('should throw on invalid public key', () => {
+      expect(
+        () => new ParaSigner(mockPara, 'wallet-1', '0xcommitment', '0xinvalid'),
+      ).toThrow('Invalid ECDSA public key for ParaSigner');
+    });
+  });
+
+  describe('signAccountIdWithTimestamp', () => {
+    it('should call para signMessage and return normalized signature', async () => {
+      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
+      const result = await signer.signAccountIdWithTimestamp('0x' + 'aa'.repeat(15), 1700000000);
+      expect(mockPara.signMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          walletId: 'wallet-1',
+          messageBase64: expect.any(String),
+        }),
+      );
+      expect(result).toMatch(/^0x/);
+    });
+  });
+
+  describe('signCommitment', () => {
+    it('should call para signMessage', async () => {
+      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
+      await signer.signCommitment('0x' + 'cc'.repeat(32));
+      expect(mockPara.signMessage).toHaveBeenCalled();
+    });
+  });
+
+  describe('signing denial', () => {
+    it('should throw when para returns no signature', async () => {
+      (mockPara.signMessage as ReturnType<typeof vi.fn>).mockResolvedValue({ signature: undefined });
+      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
+      await expect(signer.signCommitment('0x' + 'cc'.repeat(32))).rejects.toThrow(
+        'Para signing was denied by user',
+      );
+    });
+  });
+});

package/src/signers/para.ts

@@ -0,0 +1,60 @@
+import type { Signer, SignatureScheme } from '../types.js';
+import { AuthDigest } from '../utils/digest.js';
+import { EcdsaFormat } from '../utils/ecdsa.js';
+import { hexToBytes, uint8ArrayToBase64 } from '../utils/encoding.js';
+import { wordToBytes } from '../utils/word.js';
+
+export interface ParaSigningContext {
+  signMessage(params: { walletId: string; messageBase64: string }): Promise<{ signature?: string }>;
+}
+
+export class ParaSigner implements Signer {
+  readonly commitment: string;
+  readonly publicKey: string;
+  readonly scheme: SignatureScheme = 'ecdsa';
+  private readonly para: ParaSigningContext;
+  private readonly walletId: string;
+
+  constructor(
+    para: ParaSigningContext,
+    walletId: string,
+    commitment: string,
+    publicKey: string,
+  ) {
+    if (!EcdsaFormat.validatePublicKeyHex(publicKey)) {
+      throw new Error('Invalid ECDSA public key for ParaSigner');
+    }
+    this.para = para;
+    this.walletId = walletId;
+    this.commitment = commitment;
+    this.publicKey = EcdsaFormat.compressPublicKey(publicKey);
+  }
+
+  async signAccountIdWithTimestamp(accountId: string, timestamp: number): Promise<string> {
+    const digest = AuthDigest.fromAccountIdWithTimestamp(accountId, timestamp);
+    return this.signWord(digest);
+  }
+
+  async signCommitment(commitmentHex: string): Promise<string> {
+    const word = AuthDigest.fromCommitmentHex(commitmentHex);
+    return this.signWord(word);
+  }
+
+  private async signWord(word: { toHex: () => string; toFelts: () => Array<{ asInt: () => bigint }> }): Promise<string> {
+    const wordBytes = wordToBytes(word);
+    const hashedHex = EcdsaFormat.keccakDigestHex(wordBytes);
+    const cleanHex = hashedHex.slice(2);
+    const messageBase64 = uint8ArrayToBase64(hexToBytes(cleanHex));
+
+    const res = await this.para.signMessage({
+      walletId: this.walletId,
+      messageBase64,
+    });
+
+    if (!res.signature) {
+      throw new Error('Para signing was denied by user');
+    }
+
+    return EcdsaFormat.normalizeRecoveryByte(res.signature);
+  }
+}