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

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@provablehq/aleo-wallet-adaptor-leo",
+  "version": "0.1.1-alpha.0",
+  "description": "Leo wallet adapter for Aleo",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "license": "GPL-3.0-or-later",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@provablehq/aleo-types": "0.1.1-alpha.0",
+    "@provablehq/aleo-wallet-standard": "0.1.1-alpha.0",
+    "@provablehq/aleo-wallet-adaptor-core": "0.1.1-alpha.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ProvableHQ/aleo-dev-toolkit.git",
+    "directory": "packages/aleo-wallet-adaptor/wallets/leo"
+  },
+  "homepage": "https://provable.com/",
+  "keywords": [
+    "aleo",
+    "wallet",
+    "adapter",
+    "leo"
+  ],
+  "author": "Provable Labs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "rimraf": "^5.0.5",
+    "tsup": "^7.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch"
+  }
+}

package/src/LeoWalletAdapter.ts

@@ -0,0 +1,405 @@
+import {
+  Account,
+  Network,
+  TransactionOptions,
+  TransactionStatus,
+  TransactionStatusResponse,
+} from '@provablehq/aleo-types';
+import {
+  AleoDeployment,
+  WalletDecryptPermission,
+  WalletName,
+  WalletReadyState,
+} from '@provablehq/aleo-wallet-standard';
+import {
+  BaseAleoWalletAdapter,
+  MethodNotImplementedError,
+  WalletConnectionError,
+  WalletDecryptionNotAllowedError,
+  WalletDecryptionError,
+  WalletDisconnectionError,
+  WalletError,
+  WalletNotConnectedError,
+  WalletSignMessageError,
+  WalletTransactionError,
+} from '@provablehq/aleo-wallet-adaptor-core';
+import {
+  AleoTransaction,
+  Deployment,
+  LEO_NETWORK_MAP,
+  LeoWallet,
+  LeoWalletAdapterConfig,
+  LeoWindow,
+} from './types';
+
+/**
+ * Leo wallet adapter
+ */
+export class LeoWalletAdapter extends BaseAleoWalletAdapter {
+  /**
+   * The wallet name
+   */
+  readonly name = 'Leo Wallet' as WalletName<'Leo Wallet'>;
+
+  /**
+   * The wallet URL
+   */
+  url = 'https://app.leo.app';
+
+  /**
+   * The wallet icon (base64-encoded SVG)
+   */
+  readonly icon =
+    'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFwAAABcCAMAAADUMSJqAAAASFBMVEVjTP////9kTf9GIP/5+P9dRP+ajf9WO//Jwv9fR/9KJv+Ccf9ZP//08/+Xiv9aQf+upf/c2P+Qgf96aP9TNv/Nx/+Fdf+6sv91nL8+AAABCUlEQVRoge2YyQ6EIBBEccVWBHf//09H42FESNRJk+ik3s06vANCQ0oIAAAAf0ps48u8XHKXiYVZsyE5pbxgj8s63RPpTAhZROkZ9QV7nKSRRb7JT0kTyCGHHPInyceAcppyBz0zyQVlDlJzyT1k+XvkZKQ0FEROqmqKoqkU8ctV327fba+45ar7Jp3ilVO/j3pilat2H7WKU06VnVXEKDeNnTWGUX6cioV8izzosgT9ocetuKzKWw5R0OMfdnAtKyPDjVwR9LI48ny5lu6zgm0rztp9EE1cJ9THyDW4fLBNRcghhxxyDvmh+vOxybVdB16p/pzS0sewesz90vJGtfpD3QoAAOCNfADu9hzTpMe3fQAAAABJRU5ErkJggg==';
+  /**
+   * The window object
+   */
+  private _window: LeoWindow | undefined;
+
+  /**
+   * Current network
+   */
+  network: Network;
+
+  /**
+   * The wallet's decrypt permission
+   */
+  decryptPermission: WalletDecryptPermission = WalletDecryptPermission.NoDecrypt;
+
+  /**
+   * Public key
+   */
+  private _publicKey: string = '';
+
+  _readyState: WalletReadyState =
+    typeof window === 'undefined' || typeof document === 'undefined'
+      ? WalletReadyState.UNSUPPORTED
+      : WalletReadyState.NOT_DETECTED;
+
+  /**
+   * Leo wallet instance
+   */
+  private _leoWallet: LeoWallet | undefined;
+
+  /**
+   * Create a new Leo wallet adapter
+   * @param config Adapter configuration
+   */
+  constructor(config?: LeoWalletAdapterConfig) {
+    super();
+    console.debug('LeoWalletAdapter constructor', config);
+    this.network = Network.TESTNET3;
+    this._checkAvailability();
+    this._leoWallet = this._window?.leoWallet || this._window?.leo;
+    if (config?.isMobile) {
+      this.url = `https://app.leo.app/browser?url=${config.mobileWebviewUrl}`;
+    }
+  }
+
+  /**
+   * Check if Leo wallet is available
+   */
+  private _checkAvailability(): void {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+      this.readyState = WalletReadyState.UNSUPPORTED;
+      return;
+    }
+
+    this._window = window as LeoWindow;
+
+    if (this._window.leoWallet || this._window.leo) {
+      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 Leo wallet
+   * @returns The connected account
+   */
+  async connect(
+    network: Network,
+    decryptPermission: WalletDecryptPermission,
+    programs?: string[],
+  ): Promise<Account> {
+    try {
+      if (this.readyState !== WalletReadyState.INSTALLED) {
+        throw new WalletConnectionError('Leo Wallet is not available');
+      }
+
+      // Call connect and extract address safely
+      try {
+        await this._leoWallet?.connect(decryptPermission, LEO_NETWORK_MAP[network], programs);
+        this.network = network;
+      } catch (error: unknown) {
+        if (
+          error instanceof Object &&
+          'name' in error &&
+          (error.name === 'InvalidParamsAleoWalletError' ||
+            error.name !== 'NotGrantedAleoWalletError')
+        ) {
+          // TODO: Handle wrongNetwork at WalletProvider level?
+          throw new WalletConnectionError(
+            'Connection failed: Likely due to a difference in configured network and the selected wallet network. Configured network: ' +
+              network,
+          );
+        }
+
+        throw new WalletConnectionError(
+          error instanceof Error ? error.message : 'Connection failed',
+        );
+      }
+
+      this._publicKey = this._leoWallet?.publicKey || '';
+      this.decryptPermission = decryptPermission;
+      if (!this._publicKey) {
+        throw new WalletConnectionError('No address returned from wallet');
+      }
+
+      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 Leo wallet
+   */
+  async disconnect(): Promise<void> {
+    try {
+      await this._leoWallet?.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 transaction with Leo wallet
+   * @param options Transaction options
+   * @returns The signed transaction
+   */
+  async signMessage(message: Uint8Array): Promise<Uint8Array> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    try {
+      // Pass only the parameters expected by the Leo SDK
+      const signature = await this._leoWallet?.signMessage(message);
+
+      if (!signature) {
+        throw new WalletSignMessageError('Failed to sign message');
+      }
+
+      return signature.signature;
+    } catch (error: Error | unknown) {
+      throw new WalletSignMessageError(
+        error instanceof Error ? error.message : 'Failed to sign message',
+      );
+    }
+  }
+
+  async decrypt(
+    cipherText: string,
+    tpk?: string,
+    programId?: string,
+    functionName?: string,
+    index?: number,
+  ) {
+    if (!this._leoWallet || !this._publicKey) {
+      throw new WalletNotConnectedError();
+    }
+    switch (this.decryptPermission) {
+      case WalletDecryptPermission.NoDecrypt:
+        throw new WalletDecryptionNotAllowedError();
+      case WalletDecryptPermission.UponRequest:
+      case WalletDecryptPermission.AutoDecrypt:
+      case WalletDecryptPermission.OnChainHistory: {
+        try {
+          const text = await this._leoWallet.decrypt(
+            cipherText,
+            tpk,
+            programId,
+            functionName,
+            index,
+          );
+          return text.text;
+        } catch (error: Error | unknown) {
+          throw new WalletDecryptionError(
+            error instanceof Error ? error.message : 'Failed to decrypt',
+          );
+        }
+      }
+      default:
+        throw new WalletDecryptionError();
+    }
+  }
+
+  /**
+   * Execute a transaction with Leo 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();
+    }
+
+    try {
+      const requestData = {
+        address: this._publicKey,
+        chainId: LEO_NETWORK_MAP[this.network],
+        fee: options.fee ? options.fee : 0.001,
+        feePrivate: options.privateFee ?? false,
+        transitions: [
+          {
+            program: options.program,
+            functionName: options.function,
+            inputs: options.inputs,
+          },
+        ],
+      } as AleoTransaction;
+
+      const result = await this._leoWallet?.requestTransaction(requestData);
+
+      if (!result?.transactionId) {
+        throw new WalletTransactionError('Could not create transaction');
+      }
+
+      return {
+        transactionId: result.transactionId,
+      };
+    } catch (error: Error | unknown) {
+      console.error('Leo 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 this._leoWallet?.transactionStatus(transactionId);
+
+      if (!result?.status) {
+        throw new WalletTransactionError('Could not get transaction status');
+      }
+
+      const leoStatus = result.status;
+      console.log('leoStatus', leoStatus);
+      const status =
+        leoStatus === 'Finalized'
+          ? TransactionStatus.ACCEPTED
+          : leoStatus === 'Completed' // Completed probably means Proving completed
+            ? TransactionStatus.PENDING
+            : leoStatus;
+
+      return {
+        status,
+      };
+    } 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, includePlaintext: boolean): Promise<unknown[]> {
+    if (!this._publicKey || !this.account) {
+      throw new WalletNotConnectedError();
+    }
+
+    try {
+      const result = includePlaintext
+        ? await this._leoWallet?.requestRecordPlaintexts(program)
+        : await this._leoWallet?.requestRecords(program);
+
+      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('Leo Wallet does not support switching networks');
+    throw new MethodNotImplementedError('switchNetwork');
+  }
+
+  /**
+   * Execute a deployment
+   * @param deployment The deployment to execute
+   * @returns The executed transaction ID
+   */
+  async executeDeployment(deployment: AleoDeployment): Promise<{ transactionId: string }> {
+    try {
+      if (!this._publicKey || !this.account) {
+        throw new WalletNotConnectedError();
+      }
+      try {
+        const leoDeployment = new Deployment(
+          this._publicKey,
+          LEO_NETWORK_MAP[this.network],
+          deployment.program,
+          deployment.fee,
+          deployment.feePrivate,
+        );
+        const result = await this._leoWallet?.requestDeploy(leoDeployment);
+        if (!result?.transactionId) {
+          throw new WalletTransactionError('Could not create deployment');
+        }
+        return {
+          transactionId: result.transactionId,
+        };
+      } catch (error: Error | unknown) {
+        throw new WalletTransactionError(
+          error instanceof Error ? error.message : 'Failed to execute deployment',
+        );
+      }
+    } catch (error: Error | unknown) {
+      this.emit('error', error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+}

package/src/index.ts

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

package/src/types.ts

@@ -0,0 +1,141 @@
+import { Network } from '@provablehq/aleo-types';
+import { EventEmitter, WalletDecryptPermission } from '@provablehq/aleo-wallet-standard';
+
+/**
+ * Leo wallet adapter configuration
+ */
+export interface LeoWalletAdapterConfig {
+  /**
+   * Application name
+   */
+  appName?: string;
+
+  /**
+   * Application icon URL
+   */
+  appIconUrl?: string;
+
+  /**
+   * Application description
+   */
+  appDescription?: string;
+
+  /**
+   * Program ID permissions by network
+   */
+  programIdPermissions?: Record<string, string[]>;
+
+  /**
+   * Whether the wallet is mobile
+   */
+  isMobile?: boolean;
+
+  /**
+   * The mobile webview URL
+   */
+  mobileWebviewUrl?: string;
+}
+
+export interface LeoWalletEvents {
+  connect(...args: unknown[]): unknown;
+  disconnect(...args: unknown[]): unknown;
+  accountChange(...args: unknown[]): unknown;
+}
+
+export type LeoNetwork = 'mainnet' | 'testnetbeta';
+
+export const LEO_NETWORK_MAP: Record<Network, LeoNetwork> = {
+  [Network.MAINNET]: 'mainnet',
+  [Network.TESTNET3]: 'testnetbeta',
+  [Network.CANARY]: 'testnetbeta',
+};
+
+export interface LeoWallet extends EventEmitter<LeoWalletEvents> {
+  publicKey?: string;
+  isAvailable(): Promise<boolean>;
+  signMessage(message: Uint8Array): Promise<{ signature: Uint8Array }>;
+  decrypt(
+    cipherText: string,
+    tpk?: string,
+    programId?: string,
+    functionName?: string,
+    index?: number,
+  ): Promise<{ text: string }>;
+  requestRecords(program: string): Promise<{ records: unknown[] }>;
+  requestTransaction(transaction: AleoTransaction): Promise<{ transactionId?: string }>;
+  requestExecution(transaction: AleoTransaction): Promise<{ transactionId?: string }>;
+  requestBulkTransactions(transactions: AleoTransaction[]): Promise<{ transactionIds?: string[] }>;
+  requestDeploy(deployment: AleoDeployment): Promise<{ transactionId?: string }>;
+  transactionStatus(transactionId: string): Promise<{ status: string }>;
+  transitionViewKeys(transactionId: string): Promise<{ viewKeys?: string[] }>;
+  getExecution(transactionId: string): Promise<{ execution: string }>;
+  requestRecordPlaintexts(program: string): Promise<{ records: unknown[] }>;
+  requestTransactionHistory(program: string): Promise<{ transactions: unknown[] }>;
+  connect(
+    decryptPermission: WalletDecryptPermission,
+    network: LeoNetwork,
+    programs?: string[],
+  ): Promise<void>;
+  disconnect(): Promise<void>;
+}
+
+export interface LeoWindow extends Window {
+  leoWallet?: LeoWallet;
+  leo?: LeoWallet;
+}
+
+export interface AleoTransaction {
+  address: string;
+  chainId: string;
+  transitions: AleoTransition[];
+  fee: number;
+  feePrivate: boolean;
+}
+
+export interface AleoTransition {
+  program: string;
+  functionName: string;
+  inputs: unknown[];
+}
+
+export class Transition implements AleoTransition {
+  program: string;
+  functionName: string;
+  inputs: unknown[];
+
+  constructor(program: string, functionName: string, inputs: unknown[]) {
+    this.program = program;
+    this.functionName = functionName;
+    this.inputs = inputs;
+  }
+}
+
+export interface AleoDeployment {
+  address: string;
+  chainId: string;
+  program: string;
+  fee: number;
+  feePrivate: boolean;
+}
+
+export class Deployment implements AleoDeployment {
+  address: string;
+  chainId: string;
+  program: string;
+  fee: number;
+  feePrivate: boolean;
+
+  constructor(
+    address: string,
+    chainId: string,
+    program: string,
+    fee: number,
+    feePrivate: boolean = true,
+  ) {
+    this.address = address;
+    this.chainId = chainId;
+    this.program = program;
+    this.fee = fee;
+    this.feePrivate = feePrivate;
+  }
+}