@miden-sdk/miden-wallet-adapter-base 0.15.2 → 0.16.0-rc.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/adapter.test.ts

@@ -1,25 +1,25 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import {
   WalletReadyState,
   BaseWalletAdapter,
   scopePollingDetectionStrategy,
-} from '../adapter';
+} from "../adapter";
 
-describe('WalletReadyState enum', () => {
-  it('has correct values', () => {
-    expect(WalletReadyState.Installed).toBe('Installed');
-    expect(WalletReadyState.NotDetected).toBe('NotDetected');
-    expect(WalletReadyState.Loadable).toBe('Loadable');
-    expect(WalletReadyState.Unsupported).toBe('Unsupported');
+describe("WalletReadyState enum", () => {
+  it("has correct values", () => {
+    expect(WalletReadyState.Installed).toBe("Installed");
+    expect(WalletReadyState.NotDetected).toBe("NotDetected");
+    expect(WalletReadyState.Loadable).toBe("Loadable");
+    expect(WalletReadyState.Unsupported).toBe("Unsupported");
   });
 });
 
-describe('BaseWalletAdapter', () => {
+describe("BaseWalletAdapter", () => {
   // Concrete subclass for testing
   class TestAdapter extends BaseWalletAdapter {
-    name = 'Test' as any;
-    url = 'https://test.com';
-    icon = 'icon';
+    name = "Test" as any;
+    url = "https://test.com";
+    icon = "icon";
     readyState = WalletReadyState.Installed;
     address: string | null = null;
     publicKey: Uint8Array | null = null;
@@ -30,19 +30,19 @@ describe('BaseWalletAdapter', () => {
     async disconnect() {}
   }
 
-  it('connected returns true when address is set', () => {
+  it("connected returns true when address is set", () => {
     const adapter = new TestAdapter();
-    adapter.address = '0xabc';
+    adapter.address = "0xabc";
     expect(adapter.connected).toBe(true);
   });
 
-  it('connected returns false when address is null', () => {
+  it("connected returns false when address is null", () => {
     const adapter = new TestAdapter();
     expect(adapter.connected).toBe(false);
   });
 });
 
-describe('scopePollingDetectionStrategy', () => {
+describe("scopePollingDetectionStrategy", () => {
   beforeEach(() => {
     vi.useFakeTimers();
   });
@@ -51,13 +51,13 @@ describe('scopePollingDetectionStrategy', () => {
     vi.useRealTimers();
   });
 
-  it('calls detect immediately and cleans up on detection', () => {
+  it("calls detect immediately and cleans up on detection", () => {
     const detect = vi.fn().mockReturnValue(true);
     scopePollingDetectionStrategy(detect);
     expect(detect).toHaveBeenCalled();
   });
 
-  it('sets up polling interval when not immediately detected', () => {
+  it("sets up polling interval when not immediately detected", () => {
     let callCount = 0;
     const detect = vi.fn(() => {
       callCount++;

package/__tests__/errors.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   WalletError,
   WalletNotReadyError,
@@ -23,77 +23,77 @@ import {
   WalletDecryptionError,
   WalletRecordsError,
   WalletTransactionError,
-} from '../errors';
+} from "../errors";
 
 const errorClasses = [
-  { Class: WalletNotReadyError, name: 'WalletNotReadyError' },
-  { Class: WalletLoadError, name: 'WalletLoadError' },
-  { Class: WalletConfigError, name: 'WalletConfigError' },
-  { Class: WalletConnectionError, name: 'WalletConnectionError' },
-  { Class: WalletNotSelectedError, name: 'WalletNotSelectedError' },
-  { Class: WalletDisconnectedError, name: 'WalletDisconnectedError' },
-  { Class: WalletDisconnectionError, name: 'WalletDisconnectionError' },
-  { Class: WalletAccountError, name: 'WalletAccountError' },
-  { Class: WalletAddressError, name: 'WalletAddressError' },
-  { Class: WalletKeypairError, name: 'WalletKeypairError' },
-  { Class: WalletNotConnectedError, name: 'WalletNotConnectedError' },
-  { Class: WalletSendTransactionError, name: 'WalletSendTransactionError' },
-  { Class: WalletSignMessageError, name: 'WalletSignMessageError' },
-  { Class: WalletSignTransactionError, name: 'WalletSignTransactionError' },
-  { Class: WalletTimeoutError, name: 'WalletTimeoutError' },
-  { Class: WalletWindowBlockedError, name: 'WalletWindowBlockedError' },
-  { Class: WalletWindowClosedError, name: 'WalletWindowClosedError' },
+  { Class: WalletNotReadyError, name: "WalletNotReadyError" },
+  { Class: WalletLoadError, name: "WalletLoadError" },
+  { Class: WalletConfigError, name: "WalletConfigError" },
+  { Class: WalletConnectionError, name: "WalletConnectionError" },
+  { Class: WalletNotSelectedError, name: "WalletNotSelectedError" },
+  { Class: WalletDisconnectedError, name: "WalletDisconnectedError" },
+  { Class: WalletDisconnectionError, name: "WalletDisconnectionError" },
+  { Class: WalletAccountError, name: "WalletAccountError" },
+  { Class: WalletAddressError, name: "WalletAddressError" },
+  { Class: WalletKeypairError, name: "WalletKeypairError" },
+  { Class: WalletNotConnectedError, name: "WalletNotConnectedError" },
+  { Class: WalletSendTransactionError, name: "WalletSendTransactionError" },
+  { Class: WalletSignMessageError, name: "WalletSignMessageError" },
+  { Class: WalletSignTransactionError, name: "WalletSignTransactionError" },
+  { Class: WalletTimeoutError, name: "WalletTimeoutError" },
+  { Class: WalletWindowBlockedError, name: "WalletWindowBlockedError" },
+  { Class: WalletWindowClosedError, name: "WalletWindowClosedError" },
   {
     Class: WalletDecryptionNotAllowedError,
-    name: 'WalletDecryptionNotAllowedError',
+    name: "WalletDecryptionNotAllowedError",
   },
   {
     Class: WalletPrivateDataPermissionError,
-    name: 'WalletPrivateDataPermissionError',
+    name: "WalletPrivateDataPermissionError",
   },
-  { Class: WalletDecryptionError, name: 'WalletDecryptionError' },
-  { Class: WalletRecordsError, name: 'WalletRecordsError' },
-  { Class: WalletTransactionError, name: 'WalletTransactionError' },
+  { Class: WalletDecryptionError, name: "WalletDecryptionError" },
+  { Class: WalletRecordsError, name: "WalletRecordsError" },
+  { Class: WalletTransactionError, name: "WalletTransactionError" },
 ] as const;
 
-describe('WalletError', () => {
-  it('extends Error', () => {
-    const err = new WalletError('test message');
+describe("WalletError", () => {
+  it("extends Error", () => {
+    const err = new WalletError("test message");
     expect(err).toBeInstanceOf(Error);
     expect(err).toBeInstanceOf(WalletError);
   });
 
-  it('sets message property', () => {
-    const err = new WalletError('my message');
-    expect(err.message).toBe('my message');
+  it("sets message property", () => {
+    const err = new WalletError("my message");
+    expect(err.message).toBe("my message");
   });
 
-  it('stores inner error', () => {
-    const inner = new Error('inner');
-    const err = new WalletError('outer', inner);
+  it("stores inner error", () => {
+    const inner = new Error("inner");
+    const err = new WalletError("outer", inner);
     expect(err.error).toBe(inner);
   });
 });
 
-describe('error subclasses', () => {
+describe("error subclasses", () => {
   for (const { Class, name } of errorClasses) {
     describe(name, () => {
-      it('extends WalletError and Error', () => {
+      it("extends WalletError and Error", () => {
         const err = new Class();
         expect(err).toBeInstanceOf(WalletError);
         expect(err).toBeInstanceOf(Error);
       });
 
-      it('has correct name property', () => {
+      it("has correct name property", () => {
         const err = new Class();
         expect(err.name).toBe(name);
       });
 
-      it('stores inner error', () => {
-        const inner = new Error('cause');
-        const err = new Class('msg', inner);
+      it("stores inner error", () => {
+        const inner = new Error("cause");
+        const err = new Class("msg", inner);
         expect(err.error).toBe(inner);
-        expect(err.message).toBe('msg');
+        expect(err.message).toBe("msg");
       });
     });
   }

package/__tests__/helpers.test.ts

@@ -1,36 +1,36 @@
-import { describe, it, expect } from 'vitest';
-import { u8ToB64, b64ToU8 } from '../helpers';
+import { describe, it, expect } from "vitest";
+import { u8ToB64, b64ToU8 } from "../helpers";
 
-describe('u8ToB64', () => {
-  it('encodes a known value correctly', () => {
+describe("u8ToB64", () => {
+  it("encodes a known value correctly", () => {
     const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
-    expect(u8ToB64(bytes)).toBe('SGVsbG8=');
+    expect(u8ToB64(bytes)).toBe("SGVsbG8=");
   });
 
-  it('encodes an empty array', () => {
-    expect(u8ToB64(new Uint8Array([]))).toBe('');
+  it("encodes an empty array", () => {
+    expect(u8ToB64(new Uint8Array([]))).toBe("");
   });
 });
 
-describe('b64ToU8', () => {
-  it('decodes a known value correctly', () => {
-    const result = b64ToU8('SGVsbG8=');
+describe("b64ToU8", () => {
+  it("decodes a known value correctly", () => {
+    const result = b64ToU8("SGVsbG8=");
     expect(result).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
   });
 
-  it('decodes an empty string', () => {
-    expect(b64ToU8('')).toEqual(new Uint8Array([]));
+  it("decodes an empty string", () => {
+    expect(b64ToU8("")).toEqual(new Uint8Array([]));
   });
 });
 
-describe('roundtrip', () => {
-  it('encode then decode returns original bytes', () => {
+describe("roundtrip", () => {
+  it("encode then decode returns original bytes", () => {
     const original = new Uint8Array([0, 1, 127, 128, 255]);
     const decoded = b64ToU8(u8ToB64(original));
     expect(decoded).toEqual(original);
   });
 
-  it('handles a large array (256 bytes)', () => {
+  it("handles a large array (256 bytes)", () => {
     const original = new Uint8Array(256);
     for (let i = 0; i < 256; i++) original[i] = i;
     const decoded = b64ToU8(u8ToB64(original));

package/__tests__/signer.test.ts

@@ -1,8 +1,8 @@
-import { describe, it, expect } from 'vitest';
-import type { GuardianInfo } from '../types';
+import { describe, it, expect } from "vitest";
+import type { GuardianInfo } from "../types";
 
-describe('GuardianInfo', () => {
-  it('has the agreed shape', () => {
+describe("GuardianInfo", () => {
+  it("has the agreed shape", () => {
     const g: GuardianInfo = {
       isGuardianAccount: false,
       guardianEndpoint: null,
@@ -11,10 +11,10 @@ describe('GuardianInfo', () => {
     };
 
     expect(Object.keys(g).sort()).toEqual([
-      'guardianEndpoint',
-      'guardianProvider',
-      'guardianSyncStatus',
-      'isGuardianAccount',
+      "guardianEndpoint",
+      "guardianProvider",
+      "guardianSyncStatus",
+      "isGuardianAccount",
     ]);
   });
 });

package/__tests__/transaction.test.ts

@@ -1,44 +1,44 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi } from "vitest";
 import {
   SendTransaction,
   ConsumeTransaction,
   CustomTransaction,
   Transaction,
   TransactionType,
-} from '../transaction';
-import { u8ToB64 } from '../helpers';
+} from "../transaction";
+import { u8ToB64 } from "../helpers";
 
-describe('TransactionType enum', () => {
-  it('has correct values', () => {
-    expect(TransactionType.Send).toBe('send');
-    expect(TransactionType.Consume).toBe('consume');
-    expect(TransactionType.Custom).toBe('custom');
+describe("TransactionType enum", () => {
+  it("has correct values", () => {
+    expect(TransactionType.Send).toBe("send");
+    expect(TransactionType.Consume).toBe("consume");
+    expect(TransactionType.Custom).toBe("custom");
   });
 });
 
-describe('SendTransaction', () => {
-  it('sets all fields correctly', () => {
+describe("SendTransaction", () => {
+  it("sets all fields correctly", () => {
     const tx = new SendTransaction(
-      'sender-addr',
-      'recipient-addr',
-      'faucet-123',
-      'public',
+      "sender-addr",
+      "recipient-addr",
+      "faucet-123",
+      "public",
       1000
     );
-    expect(tx.senderAddress).toBe('sender-addr');
-    expect(tx.recipientAddress).toBe('recipient-addr');
-    expect(tx.faucetId).toBe('faucet-123');
-    expect(tx.noteType).toBe('public');
+    expect(tx.senderAddress).toBe("sender-addr");
+    expect(tx.recipientAddress).toBe("recipient-addr");
+    expect(tx.faucetId).toBe("faucet-123");
+    expect(tx.noteType).toBe("public");
     expect(tx.amount).toBe(1000);
     expect(tx.recallBlocks).toBeUndefined();
   });
 
-  it('sets optional recallBlocks', () => {
+  it("sets optional recallBlocks", () => {
     const tx = new SendTransaction(
-      'sender',
-      'recipient',
-      'faucet',
-      'private',
+      "sender",
+      "recipient",
+      "faucet",
+      "private",
       500,
       10
     );
@@ -46,63 +46,63 @@ describe('SendTransaction', () => {
   });
 });
 
-describe('ConsumeTransaction', () => {
-  it('sets fields correctly', () => {
-    const tx = new ConsumeTransaction('faucet-1', 'note-1', 'public', 100);
-    expect(tx.faucetId).toBe('faucet-1');
-    expect(tx.noteId).toBe('note-1');
-    expect(tx.noteType).toBe('public');
+describe("ConsumeTransaction", () => {
+  it("sets fields correctly", () => {
+    const tx = new ConsumeTransaction("faucet-1", "note-1", "public", 100);
+    expect(tx.faucetId).toBe("faucet-1");
+    expect(tx.noteId).toBe("note-1");
+    expect(tx.noteType).toBe("public");
     expect(tx.amount).toBe(100);
     expect(tx.noteBytes).toBeUndefined();
   });
 
-  it('converts noteBytes Uint8Array to base64', () => {
+  it("converts noteBytes Uint8Array to base64", () => {
     const bytes = new Uint8Array([1, 2, 3]);
-    const tx = new ConsumeTransaction('faucet', 'note', 'private', 50, bytes);
+    const tx = new ConsumeTransaction("faucet", "note", "private", 50, bytes);
     expect(tx.noteBytes).toBe(u8ToB64(bytes));
   });
 
-  it('leaves noteBytes undefined when not provided', () => {
-    const tx = new ConsumeTransaction('faucet', 'note', 'public', 50);
+  it("leaves noteBytes undefined when not provided", () => {
+    const tx = new ConsumeTransaction("faucet", "note", "public", 50);
     expect(tx.noteBytes).toBeUndefined();
   });
 });
 
-describe('CustomTransaction', () => {
-  it('serializes transactionRequest to base64', () => {
+describe("CustomTransaction", () => {
+  it("serializes transactionRequest to base64", () => {
     const mockBytes = new Uint8Array([10, 20, 30]);
     const mockRequest = {
       serialize: vi.fn().mockReturnValue(mockBytes),
     } as any;
 
-    const tx = new CustomTransaction('addr', 'recipient', mockRequest);
+    const tx = new CustomTransaction("addr", "recipient", mockRequest);
     expect(mockRequest.serialize).toHaveBeenCalled();
     expect(tx.transactionRequest).toBe(u8ToB64(mockBytes));
-    expect(tx.address).toBe('addr');
-    expect(tx.recipientAddress).toBe('recipient');
+    expect(tx.address).toBe("addr");
+    expect(tx.recipientAddress).toBe("recipient");
   });
 
-  it('sets optional inputNoteIds', () => {
+  it("sets optional inputNoteIds", () => {
     const mockRequest = {
       serialize: vi.fn().mockReturnValue(new Uint8Array([1])),
     } as any;
-    const tx = new CustomTransaction('addr', 'recipient', mockRequest, [
-      'id1',
-      'id2',
+    const tx = new CustomTransaction("addr", "recipient", mockRequest, [
+      "id1",
+      "id2",
     ]);
-    expect(tx.inputNoteIds).toEqual(['id1', 'id2']);
+    expect(tx.inputNoteIds).toEqual(["id1", "id2"]);
   });
 
-  it('converts importNotes from Uint8Array[] to base64 strings', () => {
+  it("converts importNotes from Uint8Array[] to base64 strings", () => {
     const mockRequest = {
       serialize: vi.fn().mockReturnValue(new Uint8Array([1])),
     } as any;
     const noteBytes = [new Uint8Array([4, 5]), new Uint8Array([6, 7])];
     const tx = new CustomTransaction(
-      'addr',
-      'recipient',
+      "addr",
+      "recipient",
       mockRequest,
-      ['id1'],
+      ["id1"],
       noteBytes
     );
     expect(tx.importNotes).toEqual([
@@ -111,53 +111,53 @@ describe('CustomTransaction', () => {
     ]);
   });
 
-  it('leaves optional fields undefined when not provided', () => {
+  it("leaves optional fields undefined when not provided", () => {
     const mockRequest = {
       serialize: vi.fn().mockReturnValue(new Uint8Array([1])),
     } as any;
-    const tx = new CustomTransaction('addr', 'recipient', mockRequest);
+    const tx = new CustomTransaction("addr", "recipient", mockRequest);
     expect(tx.inputNoteIds).toBeUndefined();
     expect(tx.importNotes).toBeUndefined();
   });
 });
 
-describe('Transaction factory', () => {
-  it('createSendTransaction returns correct type and payload', () => {
+describe("Transaction factory", () => {
+  it("createSendTransaction returns correct type and payload", () => {
     const tx = Transaction.createSendTransaction(
-      'sender',
-      'recipient',
-      'faucet',
-      'public',
+      "sender",
+      "recipient",
+      "faucet",
+      "public",
       100
     );
     expect(tx.type).toBe(TransactionType.Send);
     expect(tx.payload).toBeInstanceOf(SendTransaction);
     const payload = tx.payload as SendTransaction;
-    expect(payload.senderAddress).toBe('sender');
+    expect(payload.senderAddress).toBe("sender");
     expect(payload.amount).toBe(100);
   });
 
-  it('createConsumeTransaction returns correct type and payload', () => {
+  it("createConsumeTransaction returns correct type and payload", () => {
     const tx = Transaction.createConsumeTransaction(
-      'faucet',
-      'note-id',
-      'private',
+      "faucet",
+      "note-id",
+      "private",
       200
     );
     expect(tx.type).toBe(TransactionType.Consume);
     expect(tx.payload).toBeInstanceOf(ConsumeTransaction);
     const payload = tx.payload as ConsumeTransaction;
-    expect(payload.faucetId).toBe('faucet');
-    expect(payload.noteId).toBe('note-id');
+    expect(payload.faucetId).toBe("faucet");
+    expect(payload.noteId).toBe("note-id");
   });
 
-  it('createCustomTransaction returns correct type and payload', () => {
+  it("createCustomTransaction returns correct type and payload", () => {
     const mockRequest = {
       serialize: vi.fn().mockReturnValue(new Uint8Array([1, 2])),
     } as any;
     const tx = Transaction.createCustomTransaction(
-      'addr',
-      'recipient',
+      "addr",
+      "recipient",
       mockRequest
     );
     expect(tx.type).toBe(TransactionType.Custom);

package/adapter.ts

@@ -1,11 +1,11 @@
-import EventEmitter from 'eventemitter3';
-import type { WalletError } from './errors';
+import EventEmitter from "eventemitter3";
+import type { WalletError } from "./errors";
 import type {
   AllowedPrivateData,
   PrivateDataPermission,
   SupportedTransactionVersions,
   WalletAdapterNetwork,
-} from './types';
+} from "./types";
 
 export { EventEmitter };
 
@@ -19,7 +19,7 @@ export interface WalletAdapterEvents {
 // WalletName is a nominal type that wallet adapters should use, e.g. `'MyCryptoWallet' as WalletName<'MyCryptoWallet'>`
 // https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d
 export type WalletName<T extends string = string> = T & {
-  __brand__: 'WalletName';
+  __brand__: "WalletName";
 };
 
 export interface WalletAdapterProps<Name extends string = string> {
@@ -59,18 +59,18 @@ export enum WalletReadyState {
    * that they've injected into the global context. If such an API is present,
    * we consider the wallet to have been installed.
    */
-  Installed = 'Installed',
-  NotDetected = 'NotDetected',
+  Installed = "Installed",
+  NotDetected = "NotDetected",
   /**
    * Loadable wallets are always available to you. Since you can load them at
    * any time, it's meaningless to say that they have been detected.
    */
-  Loadable = 'Loadable',
+  Loadable = "Loadable",
   /**
    * If a wallet is not supported on a given platform (eg. server-rendering, or
    * mobile) then it will stay in the `Unsupported` state.
    */
-  Unsupported = 'Unsupported',
+  Unsupported = "Unsupported",
 }
 
 export abstract class BaseWalletAdapter<Name extends string = string>
@@ -100,7 +100,7 @@ export abstract class BaseWalletAdapter<Name extends string = string>
 
 export function scopePollingDetectionStrategy(detect: () => boolean): void {
   // Early return when server-side rendering
-  if (typeof window === 'undefined' || typeof document === 'undefined') return;
+  if (typeof window === "undefined" || typeof document === "undefined") return;
 
   const disposers: (() => void)[] = [];
 
@@ -122,23 +122,23 @@ export function scopePollingDetectionStrategy(detect: () => boolean): void {
   // Strategy #2: Detect as soon as the DOM becomes 'ready'/'interactive'.
   if (
     // Implies that `DOMContentLoaded` has not yet fired.
-    document.readyState === 'loading'
+    document.readyState === "loading"
   ) {
-    document.addEventListener('DOMContentLoaded', detectAndDispose, {
+    document.addEventListener("DOMContentLoaded", detectAndDispose, {
       once: true,
     });
     disposers.push(() =>
-      document.removeEventListener('DOMContentLoaded', detectAndDispose)
+      document.removeEventListener("DOMContentLoaded", detectAndDispose)
     );
   }
 
   // Strategy #3: Detect after the `window` has fully loaded.
   if (
     // If the `complete` state has been reached, we're too late.
-    document.readyState !== 'complete'
+    document.readyState !== "complete"
   ) {
-    window.addEventListener('load', detectAndDispose, { once: true });
-    disposers.push(() => window.removeEventListener('load', detectAndDispose));
+    window.addEventListener("load", detectAndDispose, { once: true });
+    disposers.push(() => window.removeEventListener("load", detectAndDispose));
   }
 
   // Strategy #4: Detect synchronously, now.