@miden-sdk/miden-wallet-adapter-base 0.13.0

package/adapter.ts

@@ -0,0 +1,146 @@
+import EventEmitter from 'eventemitter3';
+import type { WalletError } from './errors';
+import type {
+  AllowedPrivateData,
+  PrivateDataPermission,
+  SupportedTransactionVersions,
+  WalletAdapterNetwork,
+} from './types';
+
+export { EventEmitter };
+
+export interface WalletAdapterEvents {
+  connect(address: string, allowedPrivateData?: AllowedPrivateData): void;
+  disconnect(): void;
+  error(error: WalletError): void;
+  readyStateChange(readyState: WalletReadyState): void;
+}
+
+// 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';
+};
+
+export interface WalletAdapterProps<Name extends string = string> {
+  name: WalletName<Name>;
+  url: string;
+  icon: string;
+  readyState: WalletReadyState;
+  address: string | null;
+  publicKey: Uint8Array | null;
+  connecting: boolean;
+  connected: boolean;
+  supportedTransactionVersions: SupportedTransactionVersions;
+
+  connect(
+    privateDataPermission: PrivateDataPermission,
+    network: WalletAdapterNetwork,
+    allowedPrivateData?: AllowedPrivateData
+  ): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+export type WalletAdapter<Name extends string = string> =
+  WalletAdapterProps<Name> & EventEmitter<WalletAdapterEvents>;
+
+/**
+ * A wallet's readiness describes a series of states that the wallet can be in,
+ * depending on what kind of wallet it is. An installable wallet (eg. a browser
+ * extension like Phantom) might be `Installed` if we've found the Phantom API
+ * in the global scope, or `NotDetected` otherwise. A loadable, zero-install
+ * runtime (eg. Torus Wallet) might simply signal that it's `Loadable`. Use this
+ * metadata to personalize the wallet list for each user (eg. to show their
+ * installed wallets first).
+ */
+export enum WalletReadyState {
+  /**
+   * User-installable wallets can typically be detected by scanning for an API
+   * 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',
+  /**
+   * 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',
+  /**
+   * 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',
+}
+
+export abstract class BaseWalletAdapter<Name extends string = string>
+  extends EventEmitter<WalletAdapterEvents>
+  implements WalletAdapter<Name>
+{
+  abstract name: WalletName<Name>;
+  abstract url: string;
+  abstract icon: string;
+  abstract readyState: WalletReadyState;
+  abstract address: string | null;
+  abstract publicKey: Uint8Array | null;
+  abstract connecting: boolean;
+  abstract supportedTransactionVersions: SupportedTransactionVersions;
+
+  get connected() {
+    return !!this.address;
+  }
+
+  abstract connect(
+    privateDataPermission: PrivateDataPermission,
+    network: WalletAdapterNetwork,
+    allowedPrivateData?: AllowedPrivateData
+  ): Promise<void>;
+  abstract disconnect(): Promise<void>;
+}
+
+export function scopePollingDetectionStrategy(detect: () => boolean): void {
+  // Early return when server-side rendering
+  if (typeof window === 'undefined' || typeof document === 'undefined') return;
+
+  const disposers: (() => void)[] = [];
+
+  function detectAndDispose() {
+    const detected = detect();
+    if (detected) {
+      for (const dispose of disposers) {
+        dispose();
+      }
+    }
+  }
+
+  // Strategy #1: Try detecting every second.
+  const interval =
+    // TODO: #334 Replace with idle callback strategy.
+    setInterval(detectAndDispose, 1000);
+  disposers.push(() => clearInterval(interval));
+
+  // Strategy #2: Detect as soon as the DOM becomes 'ready'/'interactive'.
+  if (
+    // Implies that `DOMContentLoaded` has not yet fired.
+    document.readyState === 'loading'
+  ) {
+    document.addEventListener('DOMContentLoaded', detectAndDispose, {
+      once: true,
+    });
+    disposers.push(() =>
+      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'
+  ) {
+    window.addEventListener('load', detectAndDispose, { once: true });
+    disposers.push(() => window.removeEventListener('load', detectAndDispose));
+  }
+
+  // Strategy #4: Detect synchronously, now.
+  detectAndDispose();
+}

package/dist/adapter.d.ts

@@ -0,0 +1,69 @@
+import EventEmitter from 'eventemitter3';
+import type { WalletError } from './errors';
+import type { AllowedPrivateData, PrivateDataPermission, SupportedTransactionVersions, WalletAdapterNetwork } from './types';
+export { EventEmitter };
+export interface WalletAdapterEvents {
+    connect(address: string, allowedPrivateData?: AllowedPrivateData): void;
+    disconnect(): void;
+    error(error: WalletError): void;
+    readyStateChange(readyState: WalletReadyState): void;
+}
+export type WalletName<T extends string = string> = T & {
+    __brand__: 'WalletName';
+};
+export interface WalletAdapterProps<Name extends string = string> {
+    name: WalletName<Name>;
+    url: string;
+    icon: string;
+    readyState: WalletReadyState;
+    address: string | null;
+    publicKey: Uint8Array | null;
+    connecting: boolean;
+    connected: boolean;
+    supportedTransactionVersions: SupportedTransactionVersions;
+    connect(privateDataPermission: PrivateDataPermission, network: WalletAdapterNetwork, allowedPrivateData?: AllowedPrivateData): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export type WalletAdapter<Name extends string = string> = WalletAdapterProps<Name> & EventEmitter<WalletAdapterEvents>;
+/**
+ * A wallet's readiness describes a series of states that the wallet can be in,
+ * depending on what kind of wallet it is. An installable wallet (eg. a browser
+ * extension like Phantom) might be `Installed` if we've found the Phantom API
+ * in the global scope, or `NotDetected` otherwise. A loadable, zero-install
+ * runtime (eg. Torus Wallet) might simply signal that it's `Loadable`. Use this
+ * metadata to personalize the wallet list for each user (eg. to show their
+ * installed wallets first).
+ */
+export declare enum WalletReadyState {
+    /**
+     * User-installable wallets can typically be detected by scanning for an API
+     * 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",
+    /**
+     * 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",
+    /**
+     * 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"
+}
+export declare abstract class BaseWalletAdapter<Name extends string = string> extends EventEmitter<WalletAdapterEvents> implements WalletAdapter<Name> {
+    abstract name: WalletName<Name>;
+    abstract url: string;
+    abstract icon: string;
+    abstract readyState: WalletReadyState;
+    abstract address: string | null;
+    abstract publicKey: Uint8Array | null;
+    abstract connecting: boolean;
+    abstract supportedTransactionVersions: SupportedTransactionVersions;
+    get connected(): boolean;
+    abstract connect(privateDataPermission: PrivateDataPermission, network: WalletAdapterNetwork, allowedPrivateData?: AllowedPrivateData): Promise<void>;
+    abstract disconnect(): Promise<void>;
+}
+export declare function scopePollingDetectionStrategy(detect: () => boolean): void;

package/dist/adapter.js

@@ -0,0 +1,74 @@
+import EventEmitter from 'eventemitter3';
+export { EventEmitter };
+/**
+ * A wallet's readiness describes a series of states that the wallet can be in,
+ * depending on what kind of wallet it is. An installable wallet (eg. a browser
+ * extension like Phantom) might be `Installed` if we've found the Phantom API
+ * in the global scope, or `NotDetected` otherwise. A loadable, zero-install
+ * runtime (eg. Torus Wallet) might simply signal that it's `Loadable`. Use this
+ * metadata to personalize the wallet list for each user (eg. to show their
+ * installed wallets first).
+ */
+export var WalletReadyState;
+(function (WalletReadyState) {
+    /**
+     * User-installable wallets can typically be detected by scanning for an API
+     * that they've injected into the global context. If such an API is present,
+     * we consider the wallet to have been installed.
+     */
+    WalletReadyState["Installed"] = "Installed";
+    WalletReadyState["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.
+     */
+    WalletReadyState["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.
+     */
+    WalletReadyState["Unsupported"] = "Unsupported";
+})(WalletReadyState || (WalletReadyState = {}));
+export class BaseWalletAdapter extends EventEmitter {
+    get connected() {
+        return !!this.address;
+    }
+}
+export function scopePollingDetectionStrategy(detect) {
+    // Early return when server-side rendering
+    if (typeof window === 'undefined' || typeof document === 'undefined')
+        return;
+    const disposers = [];
+    function detectAndDispose() {
+        const detected = detect();
+        if (detected) {
+            for (const dispose of disposers) {
+                dispose();
+            }
+        }
+    }
+    // Strategy #1: Try detecting every second.
+    const interval = 
+    // TODO: #334 Replace with idle callback strategy.
+    setInterval(detectAndDispose, 1000);
+    disposers.push(() => clearInterval(interval));
+    // Strategy #2: Detect as soon as the DOM becomes 'ready'/'interactive'.
+    if (
+    // Implies that `DOMContentLoaded` has not yet fired.
+    document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', detectAndDispose, {
+            once: true,
+        });
+        disposers.push(() => 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') {
+        window.addEventListener('load', detectAndDispose, { once: true });
+        disposers.push(() => window.removeEventListener('load', detectAndDispose));
+    }
+    // Strategy #4: Detect synchronously, now.
+    detectAndDispose();
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../adapter.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AASzC,OAAO,EAAE,YAAY,EAAE,CAAC;AAqCxB;;;;;;;;GAQG;AACH,MAAM,CAAN,IAAY,gBAkBX;AAlBD,WAAY,gBAAgB;IAC1B;;;;OAIG;IACH,2CAAuB,CAAA;IACvB,+CAA2B,CAAA;IAC3B;;;OAGG;IACH,yCAAqB,CAAA;IACrB;;;OAGG;IACH,+CAA2B,CAAA;AAC7B,CAAC,EAlBW,gBAAgB,KAAhB,gBAAgB,QAkB3B;AAED,MAAM,OAAgB,iBACpB,SAAQ,YAAiC;IAYzC,IAAI,SAAS;QACX,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;CAQF;AAED,MAAM,UAAU,6BAA6B,CAAC,MAAqB;IACjE,0CAA0C;IAC1C,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,QAAQ,KAAK,WAAW;QAAE,OAAO;IAE7E,MAAM,SAAS,GAAmB,EAAE,CAAC;IAErC,SAAS,gBAAgB;QACvB,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC;QAC1B,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;gBAChC,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;IACH,CAAC;IAED,2CAA2C;IAC3C,MAAM,QAAQ;IACZ,kDAAkD;IAClD,WAAW,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;IACtC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;IAE9C,wEAAwE;IACxE;IACE,qDAAqD;IACrD,QAAQ,CAAC,UAAU,KAAK,SAAS,EACjC,CAAC;QACD,QAAQ,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,gBAAgB,EAAE;YAC9D,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QACH,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAClB,QAAQ,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CACnE,CAAC;IACJ,CAAC;IAED,2DAA2D;IAC3D;IACE,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,KAAK,UAAU,EAClC,CAAC;QACD,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAClE,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED,0CAA0C;IAC1C,gBAAgB,EAAE,CAAC;AACrB,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,70 @@
+export declare class WalletError extends Error {
+    error: any;
+    constructor(message?: string, error?: any);
+}
+export declare class WalletNotReadyError extends WalletError {
+    name: string;
+}
+export declare class WalletLoadError extends WalletError {
+    name: string;
+}
+export declare class WalletConfigError extends WalletError {
+    name: string;
+}
+export declare class WalletConnectionError extends WalletError {
+    name: string;
+}
+export declare class WalletNotSelectedError extends WalletError {
+    name: string;
+}
+export declare class WalletDisconnectedError extends WalletError {
+    name: string;
+}
+export declare class WalletDisconnectionError extends WalletError {
+    name: string;
+}
+export declare class WalletAccountError extends WalletError {
+    name: string;
+}
+export declare class WalletAddressError extends WalletError {
+    name: string;
+}
+export declare class WalletKeypairError extends WalletError {
+    name: string;
+}
+export declare class WalletNotConnectedError extends WalletError {
+    name: string;
+}
+export declare class WalletSendTransactionError extends WalletError {
+    name: string;
+}
+export declare class WalletSignMessageError extends WalletError {
+    name: string;
+}
+export declare class WalletSignTransactionError extends WalletError {
+    name: string;
+}
+export declare class WalletTimeoutError extends WalletError {
+    name: string;
+}
+export declare class WalletWindowBlockedError extends WalletError {
+    name: string;
+}
+export declare class WalletWindowClosedError extends WalletError {
+    name: string;
+}
+export declare class WalletDecryptionNotAllowedError extends WalletError {
+    name: string;
+}
+export declare class WalletPrivateDataPermissionError extends WalletError {
+    name: string;
+}
+export declare class WalletDecryptionError extends WalletError {
+    name: string;
+}
+export declare class WalletRecordsError extends WalletError {
+    name: string;
+}
+export declare class WalletTransactionError extends WalletError {
+    name: string;
+}

package/dist/errors.js

@@ -0,0 +1,75 @@
+export class WalletError extends Error {
+    error;
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    constructor(message, error) {
+        super(message);
+        this.error = error;
+    }
+}
+export class WalletNotReadyError extends WalletError {
+    name = 'WalletNotReadyError';
+}
+export class WalletLoadError extends WalletError {
+    name = 'WalletLoadError';
+}
+export class WalletConfigError extends WalletError {
+    name = 'WalletConfigError';
+}
+export class WalletConnectionError extends WalletError {
+    name = 'WalletConnectionError';
+}
+export class WalletNotSelectedError extends WalletError {
+    name = 'WalletNotSelectedError';
+}
+export class WalletDisconnectedError extends WalletError {
+    name = 'WalletDisconnectedError';
+}
+export class WalletDisconnectionError extends WalletError {
+    name = 'WalletDisconnectionError';
+}
+export class WalletAccountError extends WalletError {
+    name = 'WalletAccountError';
+}
+export class WalletAddressError extends WalletError {
+    name = 'WalletAddressError';
+}
+export class WalletKeypairError extends WalletError {
+    name = 'WalletKeypairError';
+}
+export class WalletNotConnectedError extends WalletError {
+    name = 'WalletNotConnectedError';
+}
+export class WalletSendTransactionError extends WalletError {
+    name = 'WalletSendTransactionError';
+}
+export class WalletSignMessageError extends WalletError {
+    name = 'WalletSignMessageError';
+}
+export class WalletSignTransactionError extends WalletError {
+    name = 'WalletSignTransactionError';
+}
+export class WalletTimeoutError extends WalletError {
+    name = 'WalletTimeoutError';
+}
+export class WalletWindowBlockedError extends WalletError {
+    name = 'WalletWindowBlockedError';
+}
+export class WalletWindowClosedError extends WalletError {
+    name = 'WalletWindowClosedError';
+}
+export class WalletDecryptionNotAllowedError extends WalletError {
+    name = 'WalletDecryptionNotAllowedError';
+}
+export class WalletPrivateDataPermissionError extends WalletError {
+    name = 'WalletPrivateDataPermissionError';
+}
+export class WalletDecryptionError extends WalletError {
+    name = 'WalletDecryptionError';
+}
+export class WalletRecordsError extends WalletError {
+    name = 'WalletRecordsError';
+}
+export class WalletTransactionError extends WalletError {
+    name = 'WalletTransactionError';
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,WAAY,SAAQ,KAAK;IAClC,KAAK,CAAM;IAEX,6EAA6E;IAC7E,YAAY,OAAgB,EAAE,KAAW;QACrC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;CACJ;AAED,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAChD,IAAI,GAAG,qBAAqB,CAAC;CAChC;AAED,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC5C,IAAI,GAAG,iBAAiB,CAAC;CAC5B;AAED,MAAM,OAAO,iBAAkB,SAAQ,WAAW;IAC9C,IAAI,GAAG,mBAAmB,CAAC;CAC9B;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAClD,IAAI,GAAG,uBAAuB,CAAC;CAClC;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACnD,IAAI,GAAG,wBAAwB,CAAC;CACnC;AAED,MAAM,OAAO,uBAAwB,SAAQ,WAAW;IACpD,IAAI,GAAG,yBAAyB,CAAC;CACpC;AAED,MAAM,OAAO,wBAAyB,SAAQ,WAAW;IACrD,IAAI,GAAG,0BAA0B,CAAC;CACrC;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAC/C,IAAI,GAAG,oBAAoB,CAAC;CAC/B;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAC/C,IAAI,GAAG,oBAAoB,CAAC;CAC/B;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAC/C,IAAI,GAAG,oBAAoB,CAAC;CAC/B;AAED,MAAM,OAAO,uBAAwB,SAAQ,WAAW;IACpD,IAAI,GAAG,yBAAyB,CAAC;CACpC;AAED,MAAM,OAAO,0BAA2B,SAAQ,WAAW;IACvD,IAAI,GAAG,4BAA4B,CAAC;CACvC;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACnD,IAAI,GAAG,wBAAwB,CAAC;CACnC;AAED,MAAM,OAAO,0BAA2B,SAAQ,WAAW;IACvD,IAAI,GAAG,4BAA4B,CAAC;CACvC;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAC/C,IAAI,GAAG,oBAAoB,CAAC;CAC/B;AAED,MAAM,OAAO,wBAAyB,SAAQ,WAAW;IACrD,IAAI,GAAG,0BAA0B,CAAC;CACrC;AAED,MAAM,OAAO,uBAAwB,SAAQ,WAAW;IACpD,IAAI,GAAG,yBAAyB,CAAC;CACpC;AAED,MAAM,OAAO,+BAAgC,SAAQ,WAAW;IAC5D,IAAI,GAAG,iCAAiC,CAAC;CAC5C;AAED,MAAM,OAAO,gCAAiC,SAAQ,WAAW;IAC7D,IAAI,GAAG,kCAAkC,CAAC;CAC7C;AAED,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAClD,IAAI,GAAG,uBAAuB,CAAC;CAClC;AAED,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAC/C,IAAI,GAAG,oBAAoB,CAAC;CAC/B;AAED,MAAM,OAAO,sBAAuB,SAAQ,WAAW;IACnD,IAAI,GAAG,wBAAwB,CAAC;CACnC"}

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function u8ToB64(u8: Uint8Array): string;
+export declare function b64ToU8(b64: string): Uint8Array;

package/dist/helpers.js

@@ -0,0 +1,32 @@
+// Encode a Uint8Array to base64
+export function u8ToB64(u8) {
+    // Prefer browser builtins (no polyfills)
+    if (typeof globalThis.btoa === 'function') {
+        let s = '';
+        for (let i = 0; i < u8.length; i++)
+            s += String.fromCharCode(u8[i]);
+        return globalThis.btoa(s);
+    }
+    // Node/Buffer fallback (won’t be bundled if never executed in browsers)
+    const Buf = globalThis.Buffer;
+    if (Buf)
+        return Buf.from(u8).toString('base64');
+    throw new Error('No base64 encoder available in this environment');
+}
+// Decode base64 to Uint8Array
+export function b64ToU8(b64) {
+    // Prefer browser builtins (no polyfills)
+    if (typeof globalThis.atob === 'function') {
+        const bin = globalThis.atob(b64);
+        const out = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            out[i] = bin.charCodeAt(i);
+        return out;
+    }
+    // Node/Buffer fallback (won’t be bundled if never executed in browsers)
+    const Buf = globalThis.Buffer;
+    if (Buf)
+        return new Uint8Array(Buf.from(b64, 'base64'));
+    throw new Error('No base64 decoder available in this environment');
+}
+//# sourceMappingURL=helpers.js.map

package/dist/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../helpers.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,UAAU,OAAO,CAAC,EAAc;IACpC,yCAAyC;IACzC,IAAI,OAAO,UAAU,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC1C,IAAI,CAAC,GAAG,EAAE,CAAC;QACX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE;YAAE,CAAC,IAAI,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC;IACD,wEAAwE;IACxE,MAAM,GAAG,GAAS,UAAkB,CAAC,MAAM,CAAC;IAC5C,IAAI,GAAG;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;AACrE,CAAC;AAED,8BAA8B;AAC9B,MAAM,UAAU,OAAO,CAAC,GAAW;IACjC,yCAAyC;IACzC,IAAI,OAAO,UAAU,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC1C,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAChE,OAAO,GAAG,CAAC;IACb,CAAC;IACD,wEAAwE;IACxE,MAAM,GAAG,GAAS,UAAkB,CAAC,MAAM,CAAC;IAC5C,IAAI,GAAG;QAAE,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;AACrE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './adapter';
+export * from './errors';
+export * from './signer';
+export * from './types';
+export * from './transaction';
+export * from './helpers';

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './adapter';
+export * from './errors';
+export * from './signer';
+export * from './types';
+export * from './transaction';
+export * from './helpers';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC"}

package/dist/signer.d.ts

@@ -0,0 +1,34 @@
+import type { NoteFilterTypes } from '@miden-sdk/miden-sdk';
+import type { WalletAdapter, WalletAdapterProps } from './adapter';
+import { BaseWalletAdapter } from './adapter';
+import { MidenConsumeTransaction, MidenSendTransaction, MidenTransaction } from './transaction';
+import { Asset, InputNoteDetails, SignKind, TransactionOutput } from './types';
+export type Adapter = WalletAdapter | SignerWalletAdapter | MessageSignerWalletAdapter;
+export interface SignerWalletAdapterProps<Name extends string = string> extends WalletAdapterProps<Name> {
+}
+export type SignerWalletAdapter<Name extends string = string> = WalletAdapter<Name> & SignerWalletAdapterProps<Name>;
+export declare abstract class BaseSignerWalletAdapter<Name extends string = string> extends BaseWalletAdapter<Name> implements SignerWalletAdapter<Name> {
+}
+export interface MessageSignerWalletAdapterProps<Name extends string = string> extends WalletAdapterProps<Name> {
+    requestTransaction(transaction: MidenTransaction): Promise<string>;
+    requestAssets(): Promise<Asset[]>;
+    requestPrivateNotes(noteFilterType: NoteFilterTypes, noteIds?: string[]): Promise<InputNoteDetails[]>;
+    signBytes(data: Uint8Array, kind: SignKind): Promise<Uint8Array>;
+    importPrivateNote(note: Uint8Array): Promise<string>;
+    requestConsumableNotes(): Promise<InputNoteDetails[]>;
+    waitForTransaction(txId: string, timeout?: number): Promise<TransactionOutput>;
+    requestSend(transaction: MidenSendTransaction): Promise<string>;
+    requestConsume(transaction: MidenConsumeTransaction): Promise<string>;
+}
+export type MessageSignerWalletAdapter<Name extends string = string> = WalletAdapter<Name> & MessageSignerWalletAdapterProps<Name>;
+export declare abstract class BaseMessageSignerWalletAdapter<Name extends string = string> extends BaseSignerWalletAdapter<Name> implements MessageSignerWalletAdapter<Name> {
+    abstract requestSend(transaction: MidenSendTransaction): Promise<string>;
+    abstract requestConsume(transaction: MidenConsumeTransaction): Promise<string>;
+    abstract requestTransaction(transaction: MidenTransaction): Promise<string>;
+    abstract requestAssets(): Promise<Asset[]>;
+    abstract requestPrivateNotes(noteFilterType: NoteFilterTypes, noteIds?: string[]): Promise<InputNoteDetails[]>;
+    abstract signBytes(data: Uint8Array, kind: SignKind): Promise<Uint8Array>;
+    abstract importPrivateNote(note: Uint8Array): Promise<string>;
+    abstract requestConsumableNotes(): Promise<InputNoteDetails[]>;
+    abstract waitForTransaction(txId: string, timeout?: number): Promise<TransactionOutput>;
+}

package/dist/signer.js

@@ -0,0 +1,6 @@
+import { BaseWalletAdapter } from './adapter';
+export class BaseSignerWalletAdapter extends BaseWalletAdapter {
+}
+export class BaseMessageSignerWalletAdapter extends BaseSignerWalletAdapter {
+}
+//# sourceMappingURL=signer.js.map

package/dist/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","sourceRoot":"","sources":["../signer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAmB9C,MAAM,OAAgB,uBACpB,SAAQ,iBAAuB;CACQ;AAwBzC,MAAM,OAAgB,8BAGpB,SAAQ,uBAA6B;CAoBtC"}

package/dist/transaction.d.ts

@@ -0,0 +1,67 @@
+import type { TransactionRequest } from '@miden-sdk/miden-sdk';
+export type NoteTypeString = 'public' | 'private';
+export interface MidenSendTransaction {
+    senderAddress: string;
+    recipientAddress: string;
+    faucetId: string;
+    noteType: NoteTypeString;
+    amount: number;
+    recallBlocks?: number;
+}
+export declare class SendTransaction implements MidenSendTransaction {
+    senderAddress: string;
+    recipientAddress: string;
+    faucetId: string;
+    noteType: NoteTypeString;
+    amount: number;
+    recallBlocks?: number;
+    constructor(sender: string, recipient: string, faucetId: string, noteType: NoteTypeString, amount: number, recallBlocks?: number);
+}
+export interface MidenConsumeTransaction {
+    faucetId: string;
+    noteId: string;
+    noteType: NoteTypeString;
+    amount: number;
+    noteBytes?: string;
+}
+export declare class ConsumeTransaction implements MidenConsumeTransaction {
+    faucetId: string;
+    noteId: string;
+    noteType: NoteTypeString;
+    amount: number;
+    noteBytes?: string;
+    constructor(faucetId: string, noteId: string, noteType: NoteTypeString, amount: number, noteBytes?: Uint8Array);
+}
+export interface MidenCustomTransaction {
+    address: string;
+    recipientAddress: string;
+    transactionRequest: string;
+    inputNoteIds?: string[];
+    importNotes?: string[];
+}
+export declare class CustomTransaction implements MidenCustomTransaction {
+    address: string;
+    recipientAddress: string;
+    transactionRequest: string;
+    inputNoteIds?: string[];
+    importNotes?: string[];
+    constructor(address: string, recipientAddress: string, transactionRequest: TransactionRequest, inputNotesIds?: string[], inputNoteBytes?: Uint8Array[]);
+}
+export declare enum TransactionType {
+    Send = "send",
+    Consume = "consume",
+    Custom = "custom"
+}
+export type TransactionPayload = MidenSendTransaction | MidenConsumeTransaction | MidenCustomTransaction;
+export interface MidenTransaction {
+    type: TransactionType;
+    payload: TransactionPayload;
+}
+export declare class Transaction implements MidenTransaction {
+    type: TransactionType;
+    payload: TransactionPayload;
+    constructor(type: TransactionType, payload: TransactionPayload);
+    static createSendTransaction(sender: string, recipient: string, faucetId: string, noteType: NoteTypeString, amount: number, recallBlocks?: number): Transaction;
+    static createConsumeTransaction(faucetId: string, noteId: string, noteType: NoteTypeString, amount: number, noteBytes?: Uint8Array): Transaction;
+    static createCustomTransaction(address: string, recipientAddress: string, transactionRequest: TransactionRequest, inputNoteIds?: string[], noteBytes?: Uint8Array[]): Transaction;
+}