@cartridge/controller 0.10.0-alpha.1 → 0.10.1

package/src/utils/solana/spl-token.ts

@@ -0,0 +1,66 @@
+import * as sol from "micro-sol-signer";
+import bs58 from "bs58";
+
+// SPL Token Program IDs
+export const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export const ASSOCIATED_TOKEN_PROGRAM_ID =
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+
+// Helper to get associated token address
+export function getAssociatedTokenAddress(mint: string, owner: string): string {
+  // Derive the associated token account address
+  // This is a simplified implementation for compatibility
+  const seeds = [
+    bs58.decode(owner),
+    bs58.decode(TOKEN_PROGRAM_ID),
+    bs58.decode(mint),
+  ];
+
+  // For SPL Token ATAs, this is deterministic but simplified
+  // In production, use proper PDA derivation
+  const combined = Buffer.concat(seeds.map((s) => Buffer.from(s)));
+  const hash = Buffer.from(combined).slice(0, 32);
+  return bs58.encode(hash);
+}
+
+// Create associated token account instruction
+export function createAssociatedTokenAccountInstruction(
+  payer: string,
+  associatedToken: string,
+  owner: string,
+  mint: string,
+): sol.Instruction {
+  // Create the instruction to create an associated token account
+  return {
+    program: ASSOCIATED_TOKEN_PROGRAM_ID,
+    keys: [
+      { address: payer, sign: true, write: true },
+      { address: associatedToken, sign: false, write: true },
+      { address: owner, sign: false, write: false },
+      { address: mint, sign: false, write: false },
+      {
+        address: "11111111111111111111111111111111",
+        sign: false,
+        write: false,
+      }, // System program
+      { address: TOKEN_PROGRAM_ID, sign: false, write: false },
+    ],
+    data: new Uint8Array(0), // No data for create instruction
+  };
+}
+
+// Create transfer instruction
+export function createTransferInstruction(
+  source: string,
+  destination: string,
+  owner: string,
+  amount: bigint,
+): sol.Instruction {
+  // Use micro-sol-signer's token transfer instruction
+  return sol.token.transfer({
+    source,
+    destination,
+    owner,
+    amount,
+  });
+}

package/src/wallets/argent/index.ts

@@ -13,6 +13,8 @@ export class ArgentWallet implements WalletAdapter {
   private wallet: StarknetWindowObject | undefined = undefined;
   private account: string | undefined = undefined;
   private connectedAccounts: string[] = [];
+  private accountChangeListener: ((accounts?: string[]) => void) | undefined =
+    undefined;
 
   isAvailable(): boolean {
     return typeof window !== "undefined" && !!window.starknet_argentX;
@@ -58,9 +60,12 @@ export class ArgentWallet implements WalletAdapter {
         throw new Error("No accounts found");
       }
 
+      this.removeAccountChangeListener();
+
       this.wallet = wallet;
       this.account = accounts[0];
       this.connectedAccounts = accounts;
+      this.setupAccountChangeListener();
       return { success: true, wallet: this.type, account: this.account };
     } catch (error) {
       console.error(`Error connecting to Argent:`, error);
@@ -175,4 +180,35 @@ export class ArgentWallet implements WalletAdapter {
       error: "waitForTransaction not supported for Argent wallet",
     };
   }
+
+  private setupAccountChangeListener(): void {
+    if (!this.wallet) return;
+
+    this.accountChangeListener = (accounts: string[] | undefined) => {
+      if (accounts && accounts.length > 0) {
+        this.account = accounts[0];
+        this.connectedAccounts = accounts;
+      } else {
+        this.account = undefined;
+        this.connectedAccounts = [];
+      }
+    };
+
+    // Listen for account changes
+    this.wallet.on("accountsChanged", this.accountChangeListener);
+  }
+
+  private removeAccountChangeListener(): void {
+    if (this.wallet && this.accountChangeListener) {
+      this.wallet.off("accountsChanged", this.accountChangeListener);
+      this.accountChangeListener = undefined;
+    }
+  }
+
+  disconnect(): void {
+    this.removeAccountChangeListener();
+    this.wallet = undefined;
+    this.account = undefined;
+    this.connectedAccounts = [];
+  }
 }

package/src/wallets/base/index.ts

@@ -1,306 +1,8 @@
-import { getAddress } from "ethers/address";
-import { createStore, EIP6963ProviderDetail } from "mipd";
-import {
-  ExternalPlatform,
-  ExternalWallet,
-  ExternalWalletResponse,
-  ExternalWalletType,
-  WalletAdapter,
-} from "../types";
-import { chainIdToPlatform } from "../platform";
+import { ExternalWalletType } from "../types";
+import { EthereumWalletBase } from "../ethereum-base";
 
-const BASE_RDNS = "com.coinbase.wallet";
-
-export class BaseWallet implements WalletAdapter {
+export class BaseWallet extends EthereumWalletBase {
   readonly type: ExternalWalletType = "base";
-  platform: ExternalPlatform | undefined;
-
-  private account: string | undefined = undefined;
-  private store = createStore();
-  private provider: EIP6963ProviderDetail | undefined;
-  private connectedAccounts: string[] = [];
-
-  constructor() {
-    this.provider = this.store
-      .getProviders()
-      .find((provider) => provider.info.rdns === BASE_RDNS);
-
-    this.provider?.provider
-      .request({
-        method: "eth_accounts",
-      })
-      .then((accounts) => {
-        this.connectedAccounts = accounts.map(getAddress);
-        if (accounts.length > 0) {
-          this.account = getAddress(accounts?.[0]);
-        }
-      });
-
-    this.provider?.provider
-      .request({
-        method: "eth_chainId",
-      })
-      .then((chainId) => {
-        this.platform = chainIdToPlatform(chainId);
-      });
-
-    this.provider?.provider?.on("chainChanged", (chainId: string) => {
-      this.platform = chainIdToPlatform(chainId);
-    });
-
-    this.provider?.provider?.on("accountsChanged", (accounts: string[]) => {
-      if (accounts) {
-        this.connectedAccounts = accounts.map((account) => getAddress(account));
-        this.account = getAddress(accounts?.[0]);
-      }
-    });
-  }
-
-  isAvailable(): boolean {
-    return typeof window !== "undefined" && !!this.provider;
-  }
-
-  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: "Base Wallet",
-      platform: this.platform,
-      connectedAccounts: this.connectedAccounts,
-    };
-  }
-
-  getConnectedAccounts(): string[] {
-    return this.connectedAccounts;
-  }
-
-  async connect(address?: string): Promise<ExternalWalletResponse<any>> {
-    if (address && this.connectedAccounts.includes(getAddress(address))) {
-      this.account = getAddress(address);
-    }
-
-    if (this.account) {
-      return { success: true, wallet: this.type, account: this.account };
-    }
-
-    try {
-      if (!this.isAvailable()) {
-        throw new Error("Base Wallet is not available");
-      }
-
-      const accounts = await this.provider?.provider.request({
-        method: "eth_requestAccounts",
-      });
-      if (accounts && accounts.length > 0) {
-        this.account = getAddress(accounts[0]);
-        this.connectedAccounts = accounts.map(getAddress);
-        return { success: true, wallet: this.type, account: this.account };
-      }
-
-      throw new Error("No accounts found");
-    } catch (error) {
-      console.error(`Error connecting to Base Wallet:`, error);
-      return {
-        success: false,
-        wallet: this.type,
-        error: (error as Error).message || "Unknown error",
-      };
-    }
-  }
-
-  async signMessage(
-    message: `0x${string}`,
-    address?: string,
-  ): Promise<ExternalWalletResponse<any>> {
-    try {
-      if (!this.isAvailable() || !this.account) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const result = await this.provider?.provider.request({
-        method: "personal_sign",
-        params: [message, address || this.account] as any,
-      });
-
-      return { success: true, wallet: this.type, result };
-    } catch (error) {
-      console.error(`Error signing message with Base Wallet:`, 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("Base Wallet is not connected");
-      }
-
-      const provider = this.provider?.provider;
-      if (!provider) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const result = await provider.request({
-        method: "eth_signTypedData_v4",
-        params: [this.account, JSON.stringify(data)] as any,
-      });
-
-      return { success: true, wallet: this.type, result };
-    } catch (error) {
-      console.error(`Error signing typed data with Base Wallet:`, error);
-      return {
-        success: false,
-        wallet: this.type,
-        error: (error as Error).message || "Unknown error",
-      };
-    }
-  }
-
-  async sendTransaction(txn: any): Promise<ExternalWalletResponse<any>> {
-    try {
-      if (!this.isAvailable() || !this.account) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const provider = this.provider?.provider;
-      if (!provider) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const result = await provider.request({
-        method: "eth_sendTransaction",
-        params: [txn],
-      });
-
-      return { success: true, wallet: this.type, result };
-    } catch (error) {
-      console.error(`Error sending transaction with Base Wallet:`, 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("Base Wallet is not available");
-      }
-
-      const provider = this.provider?.provider;
-      if (!provider) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      try {
-        await provider.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId }],
-        });
-
-        this.platform = chainIdToPlatform(chainId);
-        return true;
-      } catch (error) {
-        if ((error as any).code === 4902) {
-          console.warn("Chain not added to Base Wallet");
-        }
-        throw error;
-      }
-    } catch (error) {
-      console.error(`Error switching chain for Base Wallet:`, error);
-      return false;
-    }
-  }
-
-  async getBalance(
-    tokenAddress?: string,
-  ): Promise<ExternalWalletResponse<any>> {
-    try {
-      if (!this.isAvailable() || !this.account) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      if (tokenAddress) {
-        return {
-          success: false,
-          wallet: this.type,
-          error: "Not implemented for ERC20",
-        };
-      } else {
-        const provider = this.provider?.provider;
-        if (!provider) {
-          throw new Error("Base Wallet is not connected");
-        }
-
-        const balance = await provider.request({
-          method: "eth_getBalance",
-          params: [this.account, "latest"] as any,
-        });
-        return { success: true, wallet: this.type, result: balance };
-      }
-    } catch (error) {
-      console.error(`Error getting balance from Base Wallet:`, error);
-      return {
-        success: false,
-        wallet: this.type,
-        error: (error as Error).message || "Unknown error",
-      };
-    }
-  }
-
-  async waitForTransaction(
-    txHash: string,
-    timeoutMs: number = 60000,
-  ): Promise<ExternalWalletResponse<any>> {
-    try {
-      if (!this.isAvailable()) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const provider = this.provider?.provider;
-      if (!provider) {
-        throw new Error("Base Wallet is not connected");
-      }
-
-      const startTime = Date.now();
-      const pollInterval = 1000; // 1 second
-
-      while (Date.now() - startTime < timeoutMs) {
-        const receipt = await provider.request({
-          method: "eth_getTransactionReceipt",
-          params: [txHash as `0x${string}`],
-        });
-
-        if (receipt) {
-          return {
-            success: true,
-            wallet: this.type,
-            result: receipt,
-          };
-        }
-
-        // Wait before polling again
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-      }
-
-      throw new Error("Transaction confirmation timed out");
-    } catch (error) {
-      console.error(`Error waiting for transaction with Base Wallet:`, error);
-      return {
-        success: false,
-        wallet: this.type,
-        error: (error as Error).message || "Unknown error",
-      };
-    }
-  }
+  readonly rdns = "com.coinbase.wallet";
+  readonly displayName = "Base Wallet";
 }

package/src/wallets/braavos/index.ts

@@ -13,6 +13,8 @@ export class BraavosWallet implements WalletAdapter {
   private wallet: StarknetWindowObject | undefined = undefined;
   private account: string | undefined = undefined;
   private connectedAccounts: string[] = [];
+  private accountChangeListener: ((accounts?: string[]) => void) | undefined =
+    undefined;
 
   isAvailable(): boolean {
     return typeof window !== "undefined" && !!window.starknet_braavos;
@@ -58,9 +60,12 @@ export class BraavosWallet implements WalletAdapter {
         throw new Error("No accounts found");
       }
 
+      this.removeAccountChangeListener();
+
       this.wallet = wallet;
       this.account = accounts[0];
       this.connectedAccounts = accounts;
+      this.setupAccountChangeListener();
       return { success: true, wallet: this.type, account: this.account };
     } catch (error) {
       console.error(`Error connecting to Braavos:`, error);
@@ -174,4 +179,35 @@ export class BraavosWallet implements WalletAdapter {
       error: "waitForTransaction not supported for Braavos wallet",
     };
   }
+
+  private setupAccountChangeListener(): void {
+    if (!this.wallet) return;
+
+    this.accountChangeListener = (accounts: string[] | undefined) => {
+      if (accounts && accounts.length > 0) {
+        this.account = accounts[0];
+        this.connectedAccounts = accounts;
+      } else {
+        this.account = undefined;
+        this.connectedAccounts = [];
+      }
+    };
+
+    // Listen for account changes
+    this.wallet.on("accountsChanged", this.accountChangeListener);
+  }
+
+  private removeAccountChangeListener(): void {
+    if (this.wallet && this.accountChangeListener) {
+      this.wallet.off("accountsChanged", this.accountChangeListener);
+      this.accountChangeListener = undefined;
+    }
+  }
+
+  disconnect(): void {
+    this.removeAccountChangeListener();
+    this.wallet = undefined;
+    this.account = undefined;
+    this.connectedAccounts = [];
+  }
 }