@cartridge/controller 0.7.6 → 0.7.8

package/src/wallets/bridge.ts

@@ -0,0 +1,165 @@
+import {
+  ExternalWalletType,
+  WalletAdapter,
+  ExternalWallet,
+  ExternalWalletResponse,
+} from "./types";
+import { MetaMaskWallet } from "./metamask";
+import { PhantomWallet } from "./phantom";
+import { ArgentWallet } from "./argent";
+
+export class WalletBridge {
+  private readonly walletAdapters: Map<ExternalWalletType, WalletAdapter>;
+  private readonly connectedWallets: Map<ExternalWalletType, WalletAdapter> =
+    new Map();
+
+  constructor() {
+    this.walletAdapters = new Map<ExternalWalletType, WalletAdapter>();
+    this.walletAdapters.set("metamask", new MetaMaskWallet());
+    this.walletAdapters.set("phantom", new PhantomWallet());
+    this.walletAdapters.set("argent", new ArgentWallet());
+
+    if (typeof window !== "undefined") {
+      window.wallet_bridge = this;
+    }
+  }
+
+  getIFrameMethods() {
+    return {
+      externalDetectWallets: (_origin: string) => () => this.detectWallets(),
+      externalConnectWallet: (_origin: string) => (type: ExternalWalletType) =>
+        this.connectWallet(type),
+      externalSignMessage:
+        (_origin: string) => (type: ExternalWalletType, message: string) =>
+          this.signMessage(type, message),
+      externalSignTypedData:
+        (_origin: string) => (type: ExternalWalletType, data: any) =>
+          this.signTypedData(type, data),
+      externalGetBalance:
+        (_origin: string) =>
+        (type: ExternalWalletType, tokenAddress?: string) =>
+          this.getBalance(type, tokenAddress),
+    };
+  }
+
+  async detectWallets(): Promise<ExternalWallet[]> {
+    const wallets = Array.from(this.walletAdapters.values()).map((adapter) =>
+      adapter.getInfo(),
+    ) as ExternalWallet[];
+
+    return wallets;
+  }
+
+  private getWalletAdapter(type: ExternalWalletType): WalletAdapter {
+    const adapter = this.walletAdapters.get(type);
+    if (!adapter) {
+      throw new Error(`Unsupported wallet type: ${type}`);
+    }
+    return adapter;
+  }
+
+  private handleError(
+    type: ExternalWalletType,
+    error: unknown,
+    operation: string,
+  ): ExternalWalletResponse {
+    const errorMessage =
+      error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error ${operation} with ${type} wallet:`, error);
+    return { success: false, wallet: type, error: errorMessage };
+  }
+
+  async connectWallet(
+    type: ExternalWalletType,
+  ): Promise<ExternalWalletResponse> {
+    try {
+      if (this.connectedWallets.has(type)) {
+        const wallet = this.connectedWallets.get(type)!;
+        return { success: true, wallet: type, account: wallet.type };
+      }
+
+      const wallet = this.getWalletAdapter(type);
+      const response = await wallet.connect();
+
+      if (response.success) {
+        this.connectedWallets.set(type, wallet);
+      }
+
+      return response;
+    } catch (error) {
+      return this.handleError(type, error, "connecting to");
+    }
+  }
+
+  async signMessage(
+    type: ExternalWalletType,
+    message: string,
+  ): Promise<ExternalWalletResponse> {
+    try {
+      if (!this.connectedWallets.has(type)) {
+        throw new Error(`Wallet ${type} is not connected`);
+      }
+
+      const wallet = this.connectedWallets.get(type)!;
+      if (!wallet.signMessage) {
+        throw new Error(`Wallet ${type} does not support signing messages`);
+      }
+
+      return await wallet.signMessage(message);
+    } catch (error) {
+      return this.handleError(type, error, "signing message with");
+    }
+  }
+
+  async signTypedData(
+    type: ExternalWalletType,
+    data: any,
+  ): Promise<ExternalWalletResponse> {
+    try {
+      if (!this.connectedWallets.has(type)) {
+        throw new Error(`Wallet ${type} is not connected`);
+      }
+
+      const wallet = this.connectedWallets.get(type)!;
+      if (!wallet.signTypedData) {
+        throw new Error(`Wallet ${type} does not support signing typed data`);
+      }
+
+      return await wallet.signTypedData(data);
+    } catch (error) {
+      return this.handleError(type, error, "signing typed data with");
+    }
+  }
+
+  async getBalance(
+    type: ExternalWalletType,
+    tokenAddress?: string,
+  ): Promise<ExternalWalletResponse> {
+    try {
+      if (!this.connectedWallets.has(type)) {
+        throw new Error(`Wallet ${type} is not connected`);
+      }
+
+      const wallet = this.connectedWallets.get(type)!;
+      return await wallet.getBalance(tokenAddress);
+    } catch (error) {
+      return this.handleError(type, error, "getting balance from");
+    }
+  }
+}
+
+declare global {
+  interface Window {
+    ethereum?: any;
+    solana?: any;
+    starknet_argentX?: any;
+    wallet_bridge?: WalletBridge;
+  }
+}
+
+export type {
+  ExternalWalletType,
+  ExternalWallet,
+  ExternalWalletResponse,
+  WalletAdapter,
+} from "./types";

package/src/wallets/index.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./bridge";
+export * from "./metamask";
+export * from "./phantom";
+export * from "./argent";

package/src/wallets/metamask/index.ts

@@ -0,0 +1,210 @@
+import {
+  WalletAdapter,
+  ExternalWallet,
+  ExternalWalletResponse,
+  ExternalWalletType,
+  ExternalPlatform,
+} from "../types";
+import { MetaMaskSDK } from "@metamask/sdk";
+
+export class MetaMaskWallet implements WalletAdapter {
+  readonly type: ExternalWalletType = "metamask";
+  readonly platform: ExternalPlatform = "ethereum";
+  private MMSDK: MetaMaskSDK;
+  private account: string | undefined = undefined;
+
+  constructor() {
+    this.MMSDK = new MetaMaskSDK({
+      dappMetadata: {
+        name: "Cartridge Controller",
+        url: window.location.href,
+      },
+    });
+  }
+
+  isAvailable(): boolean {
+    return typeof window !== "undefined" && !!window.ethereum?.isMetaMask;
+  }
+
+  getInfo(): ExternalWallet {
+    const available = this.isAvailable();
+
+    return {
+      type: this.type,
+      available,
+      version: available ? window.ethereum?.version || "Unknown" : undefined,
+      chainId: available ? window.ethereum?.chainId : undefined,
+      name: "MetaMask",
+      platform: this.platform,
+    };
+  }
+
+  async connect(): Promise<ExternalWalletResponse<any>> {
+    if (this.account) {
+      return { success: true, wallet: this.type, account: this.account };
+    }
+
+    try {
+      if (!this.isAvailable()) {
+        throw new Error("MetaMask is not available");
+      }
+
+      const accounts = await this.MMSDK.connect();
+      if (accounts && accounts.length > 0) {
+        this.account = accounts[0];
+        return { success: true, wallet: this.type, account: this.account };
+      }
+
+      throw new Error("No accounts found");
+    } catch (error) {
+      console.error(`Error connecting to MetaMask:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signTransaction(
+    transaction: any,
+  ): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      const ethereum = this.MMSDK.getProvider();
+      if (!ethereum) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      const result = await ethereum.request({
+        method: "eth_sendTransaction",
+        params: [transaction],
+      });
+
+      return { success: true, wallet: this.type, result };
+    } catch (error) {
+      console.error(`Error signing transaction with MetaMask:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signMessage(message: string): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      const result = await this.MMSDK.connectAndSign({
+        msg: message,
+      });
+
+      return { success: true, wallet: this.type, result };
+    } catch (error) {
+      console.error(`Error signing message with MetaMask:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signTypedData(data: any): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      const ethereum = this.MMSDK.getProvider();
+      if (!ethereum) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      const result = await ethereum.request({
+        method: "eth_signTypedData_v4",
+        params: [this.account, JSON.stringify(data)],
+      });
+
+      return { success: true, wallet: this.type, result };
+    } catch (error) {
+      console.error(`Error signing typed data with MetaMask:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async switchChain(chainId: string): Promise<boolean> {
+    try {
+      if (!this.isAvailable()) {
+        throw new Error("MetaMask is not available");
+      }
+
+      const ethereum = this.MMSDK.getProvider();
+      if (!ethereum) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      try {
+        await ethereum.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId }],
+        });
+        return true;
+      } catch (error) {
+        if ((error as any).code === 4902) {
+          console.warn("Chain not added to MetaMask");
+        }
+        throw error;
+      }
+    } catch (error) {
+      console.error(`Error switching chain for MetaMask:`, error);
+      return false;
+    }
+  }
+
+  async getBalance(
+    tokenAddress?: string,
+  ): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("MetaMask is not connected");
+      }
+
+      if (tokenAddress) {
+        return {
+          success: false,
+          wallet: this.type,
+          error: "Not implemented for ERC20",
+        };
+      } else {
+        const ethereum = this.MMSDK.getProvider();
+        if (!ethereum) {
+          throw new Error("MetaMask is not connected");
+        }
+
+        const balance = await ethereum.request({
+          method: "eth_getBalance",
+          params: [this.account, "latest"],
+        });
+        return { success: true, wallet: this.type, result: balance };
+      }
+    } catch (error) {
+      console.error(`Error getting balance from MetaMask:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+}

package/src/wallets/phantom/index.ts

@@ -0,0 +1,124 @@
+import {
+  WalletAdapter,
+  ExternalWallet,
+  ExternalWalletResponse,
+  ExternalWalletType,
+  ExternalPlatform,
+} from "../types";
+
+export class PhantomWallet implements WalletAdapter {
+  readonly type: ExternalWalletType = "phantom";
+  readonly platform: ExternalPlatform = "solana";
+  private account: string | undefined = undefined;
+
+  isAvailable(): boolean {
+    return typeof window !== "undefined" && !!window.solana?.isPhantom;
+  }
+
+  getInfo(): ExternalWallet {
+    const available = this.isAvailable();
+
+    return {
+      type: this.type,
+      available,
+      version: "Unknown",
+      name: "Phantom",
+      platform: this.platform,
+    };
+  }
+
+  async connect(): Promise<ExternalWalletResponse<any>> {
+    if (this.account) {
+      return { success: true, wallet: this.type, account: this.account };
+    }
+
+    try {
+      if (!this.isAvailable()) {
+        throw new Error("Phantom is not available");
+      }
+
+      const response = await window.solana.connect();
+      if (response.publicKey) {
+        this.account = response.publicKey.toString();
+        return { success: true, wallet: this.type, account: this.account };
+      }
+
+      throw new Error("No accounts found");
+    } catch (error) {
+      console.error(`Error connecting to Phantom:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signTransaction(
+    transaction: any,
+  ): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("Phantom is not connected");
+      }
+
+      const result = await window.solana.signTransaction(transaction);
+      return { success: true, wallet: this.type, result };
+    } catch (error) {
+      console.error(`Error signing transaction with Phantom:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signMessage(message: string): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("Phantom is not connected");
+      }
+
+      const encodedMessage = new TextEncoder().encode(message);
+      const result = await window.solana.signMessage(encodedMessage, "utf8");
+      return { success: true, wallet: this.type, result };
+    } catch (error) {
+      console.error(`Error signing message with Phantom:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async switchChain(_chainId: string): Promise<boolean> {
+    console.warn("Chain switching not supported for Phantom");
+    return false;
+  }
+
+  async getBalance(
+    _tokenAddress?: string,
+  ): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.account) {
+        throw new Error("Phantom is not connected");
+      }
+
+      // TODO: Implement balance fetching based on Phantom's API
+      return {
+        success: true,
+        wallet: this.type,
+        result: "Implement based on Phantom API",
+      };
+    } catch (error) {
+      console.error(`Error getting balance from Phantom:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+}

package/src/wallets/types.ts

@@ -0,0 +1,32 @@
+export type ExternalWalletType = "argent" | "metamask" | "phantom";
+export type ExternalPlatform = "starknet" | "ethereum" | "solana";
+
+export interface ExternalWallet {
+  type: ExternalWalletType;
+  available: boolean;
+  version?: string;
+  chainId?: string;
+  name?: string;
+  platform?: ExternalPlatform;
+}
+
+export interface ExternalWalletResponse<T = unknown> {
+  success: boolean;
+  wallet: ExternalWalletType;
+  result?: T;
+  error?: string;
+  account?: string;
+}
+
+export interface WalletAdapter {
+  type: ExternalWalletType;
+  platform: ExternalPlatform;
+
+  // Methods
+  isAvailable(): boolean;
+  getInfo(): ExternalWallet;
+  connect(): Promise<ExternalWalletResponse<any>>;
+  signMessage?(message: string): Promise<ExternalWalletResponse<any>>;
+  signTypedData?(data: any): Promise<ExternalWalletResponse<any>>;
+  getBalance(tokenAddress?: string): Promise<ExternalWalletResponse<any>>;
+}