@provablehq/aleo-wallet-adaptor-puzzle 0.1.1-alpha.0

package/src/PuzzleWalletAdapter.ts

@@ -0,0 +1,382 @@
+import {
+  Account,
+  TransactionOptions,
+  Network,
+  TransactionStatusResponse,
+  TransactionStatus,
+} from '@provablehq/aleo-types';
+import {
+  AleoDeployment,
+  WalletDecryptPermission,
+  WalletName,
+  WalletReadyState,
+} from '@provablehq/aleo-wallet-standard';
+import {
+  BaseAleoWalletAdapter,
+  DecryptPermission,
+  MethodNotImplementedError,
+  WalletConnectionError,
+  WalletDecryptionError,
+  WalletDecryptionNotAllowedError,
+  WalletDisconnectionError,
+  WalletError,
+  WalletNotConnectedError,
+  WalletSignMessageError,
+  WalletTransactionError,
+} from '@provablehq/aleo-wallet-adaptor-core';
+import {
+  connect,
+  disconnect,
+  requestCreateEvent,
+  requestSignature,
+  EventType,
+  decrypt as puzzleDecrypt,
+  getRecords,
+  getEvent,
+} from '@puzzlehq/sdk-core';
+import { PuzzleWindow, PuzzleWalletAdapterConfig, PUZZLE_NETWORK_MAP } from './types';
+import { PuzzleIcon } from './icon';
+
+/**
+ * Puzzle wallet adapter
+ */
+export class PuzzleWalletAdapter extends BaseAleoWalletAdapter {
+  /**
+   * The wallet name
+   */
+  name = 'Puzzle Wallet' as WalletName<'Puzzle Wallet'>;
+
+  /**
+   * The wallet URL
+   */
+  url = 'https://puzzle.online/wallet';
+
+  /**
+   * The wallet icon (base64-encoded SVG)
+   */
+  icon = PuzzleIcon;
+  /**
+   * The window object
+   */
+  private _window: PuzzleWindow | undefined;
+
+  /**
+   * App name
+   */
+  private _appName: string;
+
+  /**
+   * App icon URL
+   */
+  private _appIconUrl?: string;
+
+  /**
+   * App description
+   */
+  private _appDescription?: string;
+
+  /**
+   * Current network
+   */
+  network: Network = Network.TESTNET3;
+
+  /**
+   * The wallet's decrypt permission
+   */
+  decryptPermission: WalletDecryptPermission = WalletDecryptPermission.NoDecrypt;
+
+  _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.UNSUPPORTED
+      : WalletReadyState.NOT_DETECTED;
+
+  /**
+   * Public key
+   */
+  private _publicKey: string = '';
+
+  /**
+   * Create a new Puzzle wallet adapter
+   * @param config Adapter configuration
+   */
+  constructor(config?: PuzzleWalletAdapterConfig) {
+    super();
+    this._appName = config?.appName || 'Aleo App';
+    this._appIconUrl = config?.appIconUrl;
+    this._appDescription = config?.appDescription;
+    this._checkAvailability();
+  }
+
+  /**
+   * Check if Puzzle wallet is available
+   */
+  private _checkAvailability(): void {
+    if (typeof window === 'undefined') {
+      this.readyState = WalletReadyState.UNSUPPORTED;
+      return;
+    }
+
+    this._window = window as PuzzleWindow;
+
+    if (this._window.puzzle) {
+      this.readyState = WalletReadyState.INSTALLED;
+    } else {
+      // Check if user is on a mobile device
+      const isMobile = /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
+      if (isMobile) {
+        this.readyState = WalletReadyState.LOADABLE;
+      }
+    }
+  }
+
+  /**
+   * Connect to Puzzle wallet
+   * @param network The network to connect to
+   * @returns The connected account
+   */
+  async connect(
+    network: Network,
+    decryptPermission: WalletDecryptPermission,
+    programs?: string[],
+  ): Promise<Account> {
+    try {
+      if (this.readyState !== WalletReadyState.INSTALLED) {
+        throw new WalletConnectionError('Puzzle Wallet is not available');
+      }
+
+      // Call connect and extract address safely
+      const response = await connect({
+        dAppInfo: {
+          name: this._appName,
+          description: this._appDescription,
+          iconUrl: this._appIconUrl,
+        },
+        permissions: {
+          programIds: {
+            [PUZZLE_NETWORK_MAP[network]]: programs,
+          },
+        },
+      });
+
+      // Type guard to check response structure
+      if (!response || typeof response !== 'object' || !('connection' in response)) {
+        throw new WalletConnectionError('Invalid response from wallet');
+      }
+
+      this.network = network;
+      this.decryptPermission = decryptPermission;
+      const address = (response as { connection: { address: string } }).connection?.address;
+
+      if (!address) {
+        throw new WalletConnectionError('No address returned from wallet');
+      }
+
+      this._publicKey = address;
+
+      const account: Account = {
+        address: this._publicKey,
+      };
+
+      this.account = account;
+      this.emit('connect', account);
+
+      return account;
+    } catch (err: Error | unknown) {
+      this.emit('error', err instanceof Error ? err : new Error(String(err)));
+      throw new WalletConnectionError(err instanceof Error ? err.message : 'Connection failed');
+    }
+  }
+
+  /**
+   * Disconnect from Puzzle wallet
+   */
+  async disconnect(): Promise<void> {
+    try {
+      await disconnect();
+      this._publicKey = '';
+      this.account = undefined;
+      this.emit('disconnect');
+    } catch (err: Error | unknown) {
+      this.emit('error', err instanceof Error ? err : new Error(String(err)));
+      throw new WalletDisconnectionError(
+        err instanceof Error ? err.message : 'Disconnection failed',
+      );
+    }
+  }
+
+  /**
+   * Sign a message with Puzzle wallet
+   * @param message The message to sign
+   * @returns The signed message
+   */
+  async signMessage(message: Uint8Array): Promise<Uint8Array> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    try {
+      // Pass only the parameters expected by the Puzzle SDK
+      const signature = await requestSignature({
+        message: message.toString(),
+        address: this._publicKey,
+      });
+
+      return new TextEncoder().encode(signature.signature);
+    } catch (error: Error | unknown) {
+      throw new WalletSignMessageError(
+        error instanceof Error ? error.message : 'Failed to sign message',
+      );
+    }
+  }
+
+  async decrypt(cipherText: string) {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+    switch (this.decryptPermission) {
+      case WalletDecryptPermission.NoDecrypt:
+        throw new WalletDecryptionNotAllowedError();
+
+      case WalletDecryptPermission.UponRequest:
+      case DecryptPermission.AutoDecrypt:
+      case DecryptPermission.OnChainHistory: {
+        try {
+          const text = await puzzleDecrypt({ ciphertexts: [cipherText] });
+          return text.plaintexts![0];
+        } catch (error: Error | unknown) {
+          throw new WalletDecryptionError(
+            error instanceof Error ? error.message : 'Failed to decrypt',
+          );
+        }
+      }
+      default:
+        throw new WalletDecryptionError();
+    }
+  }
+
+  /**
+   * Execute a transaction with Puzzle wallet
+   * @param options Transaction options
+   * @returns The executed temporary transaction ID
+   */
+  async executeTransaction(options: TransactionOptions): Promise<{ transactionId: string }> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    if (options.privateFee) {
+      throw new WalletTransactionError('Private fee is not supported by Puzzle wallet');
+    }
+
+    try {
+      const fee = options.fee ? options.fee / 1000000 : 0.001;
+
+      const requestData = {
+        type: EventType.Execute,
+        programId: options.program,
+        functionId: options.function,
+        fee,
+        inputs: options.inputs,
+        address: this._publicKey,
+        network: PUZZLE_NETWORK_MAP[this.network],
+      };
+
+      const result = await requestCreateEvent(requestData);
+
+      if (result.error) {
+        throw new WalletTransactionError(result.error);
+      }
+
+      if (!result.eventId) {
+        throw new WalletTransactionError('Could not create transaction');
+      }
+
+      return {
+        transactionId: result.eventId,
+      };
+    } catch (error: Error | unknown) {
+      console.error('Puzzle Wallet executeTransaction error', error);
+      if (error instanceof WalletError) {
+        throw error;
+      }
+      throw new WalletTransactionError(
+        error instanceof Error ? error.message : 'Failed to execute transaction',
+      );
+    }
+  }
+
+  /**
+   * Get transaction status
+   * @param transactionId The transaction ID
+   * @returns The transaction status
+   */
+  async transactionStatus(transactionId: string): Promise<TransactionStatusResponse> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    try {
+      const result = await getEvent({
+        id: transactionId,
+        address: this._publicKey,
+        network: PUZZLE_NETWORK_MAP[this.network],
+      });
+
+      return {
+        status: result.event?.status || TransactionStatus.PENDING,
+        transactionId: result.event?.transactionId,
+        error: result.event?.error,
+      };
+    } catch (error: Error | unknown) {
+      throw new WalletTransactionError(
+        error instanceof Error ? error.message : 'Failed to get transaction status',
+      );
+    }
+  }
+  /**
+   * Request records from Leo wallet
+   * @param program The program to request records from
+   * @param includePlaintext Whether to include plaintext on each record
+   * @returns The records
+   */
+  async requestRecords(program: string): Promise<unknown[]> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    try {
+      const result = await getRecords({
+        filter: {
+          programIds: [program],
+          status: 'All',
+        },
+        address: this._publicKey,
+        network: PUZZLE_NETWORK_MAP[this.network],
+      });
+
+      return result?.records || [];
+    } catch (error: Error | unknown) {
+      throw new WalletError(error instanceof Error ? error.message : 'Failed to request records');
+    }
+  }
+
+  /**
+   * Switch the network
+   * @param network The network to switch to
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async switchNetwork(_network: Network): Promise<void> {
+    console.error('Puzzle Wallet does not support switching networks');
+    throw new MethodNotImplementedError('switchNetwork');
+  }
+
+  /**
+   * Execute a deployment
+   * @param deployment The deployment to execute
+   * @returns The executed transaction ID
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async executeDeployment(_deployment: AleoDeployment): Promise<{ transactionId: string }> {
+    throw new MethodNotImplementedError('executeDeployment');
+  }
+}

package/src/icon.ts

@@ -0,0 +1,2 @@
+export const PuzzleIcon =
+  'data:image/webp;base64,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';

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './PuzzleWalletAdapter';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,44 @@
+import { Network } from '@provablehq/aleo-types';
+import { Network as PuzzleNetwork } from '@puzzlehq/sdk-core';
+
+/**
+ * Puzzle window interface
+ */
+export interface PuzzleWindow extends Window {
+  puzzle?: {
+    connected: boolean;
+    connect(): Promise<unknown>;
+    disconnect(): Promise<void>;
+  };
+}
+
+/**
+ * Puzzle wallet adapter configuration
+ */
+export interface PuzzleWalletAdapterConfig {
+  /**
+   * Application name
+   */
+  appName?: string;
+
+  /**
+   * Application icon URL
+   */
+  appIconUrl?: string;
+
+  /**
+   * Application description
+   */
+  appDescription?: string;
+
+  /**
+   * Program ID permissions by network
+   */
+  programIdPermissions?: Record<string, string[]>;
+}
+
+export const PUZZLE_NETWORK_MAP: Record<Network, PuzzleNetwork> = {
+  [Network.MAINNET]: PuzzleNetwork.AleoMainnet,
+  [Network.TESTNET3]: PuzzleNetwork.AleoTestnet,
+  [Network.CANARY]: PuzzleNetwork.AleoTestnet,
+};