@cartridge/controller 0.7.7 → 0.7.9-alpha.1

package/dist/telegram/backend.d.ts

@@ -0,0 +1,30 @@
+import { UnifiedBackend } from '../session/backend';
+/**
+ * Implements the UnifiedBackend interface for Telegram storage operations.
+ */
+export declare class TelegramBackend implements UnifiedBackend {
+    /**
+     * Retrieves the value associated with the specified key from Telegram cloud storage.
+     * @param key - The key to look up in the storage.
+     * @returns A promise that resolves to the stored value as a string, or null if the key doesn't exist.
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Stores a key-value pair in Telegram cloud storage.
+     * @param key - The key under which to store the value.
+     * @param value - The value to be stored.
+     * @returns A promise that resolves when the value has been successfully stored.
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Removes the key-value pair associated with the specified key from Telegram cloud storage.
+     * @param key - The key of the item to be removed.
+     * @returns A promise that resolves when the item has been successfully removed.
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Opens the specified URL using Telegram's openLink function.
+     * @param url - The URL to open.
+     */
+    openLink(url: string): void;
+}

package/dist/telegram/provider.d.ts

@@ -0,0 +1,24 @@
+import { WalletAccount } from 'starknet';
+import { default as BaseProvider } from '../provider';
+import { SessionPolicies } from '@cartridge/presets';
+import { AddStarknetChainParameters } from '@starknet-io/types-js';
+import { ParsedSessionPolicies } from '../policies';
+export default class TelegramProvider extends BaseProvider {
+    private _tmaUrl;
+    protected _chainId: string;
+    protected _username?: string;
+    protected _policies: ParsedSessionPolicies;
+    private _rpcUrl;
+    constructor({ rpc, chainId, policies, tmaUrl, }: {
+        rpc: string;
+        chainId: string;
+        policies: SessionPolicies;
+        tmaUrl: string;
+    });
+    probe(): Promise<WalletAccount | undefined>;
+    connect(): Promise<WalletAccount | undefined>;
+    switchStarknetChain(_chainId: string): Promise<boolean>;
+    addStarknetChain(_chain: AddStarknetChainParameters): Promise<boolean>;
+    disconnect(): Promise<void>;
+    tryRetrieveFromQueryOrStorage(): Promise<WalletAccount | undefined>;
+}

package/dist/types.d.ts

@@ -0,0 +1,146 @@
+import { constants, BigNumberish, Call, Abi, InvocationsDetails } from 'starknet';
+import { AddInvokeTransactionResult, ChainId, Signature, TypedData } from '@starknet-io/types-js';
+import { KeychainIFrame, ProfileIFrame } from './iframe';
+import { Policy, SessionPolicies } from '@cartridge/presets';
+import { ExternalWallet, ExternalWalletResponse, ExternalWalletType } from './wallets/types';
+export type Session = {
+    chainId: constants.StarknetChainId;
+    policies: Policy[];
+    maxFee: BigNumberish;
+    expiresAt: bigint;
+    credentials: {
+        authorization: string[];
+        privateKey: string;
+    };
+};
+export declare enum ResponseCodes {
+    SUCCESS = "SUCCESS",
+    NOT_CONNECTED = "NOT_CONNECTED",
+    ERROR = "ERROR",
+    CANCELED = "CANCELED",
+    USER_INTERACTION_REQUIRED = "USER_INTERACTION_REQUIRED"
+}
+export type ConnectError = {
+    code: ResponseCodes;
+    message: string;
+    error?: ControllerError;
+};
+export type ControllerError = {
+    code: Number;
+    message: string;
+    data?: any;
+};
+export type ConnectReply = {
+    code: ResponseCodes.SUCCESS;
+    address: string;
+    policies?: SessionPolicies;
+};
+export type ExecuteReply = (AddInvokeTransactionResult & {
+    code: ResponseCodes.SUCCESS;
+}) | {
+    code: ResponseCodes.USER_INTERACTION_REQUIRED;
+};
+export type ProbeReply = {
+    code: ResponseCodes.SUCCESS;
+    address: string;
+    rpcUrl?: string;
+};
+export type DeployReply = {
+    code: ResponseCodes.SUCCESS;
+    transaction_hash: string;
+};
+export type IFrames = {
+    keychain: KeychainIFrame;
+    profile?: ProfileIFrame;
+    version?: number;
+};
+export interface LookupRequest {
+    usernames?: string[];
+    addresses?: string[];
+}
+export interface LookupResult {
+    username: string;
+    addresses: string[];
+}
+export interface LookupResponse {
+    results: LookupResult[];
+}
+type ContractAddress = string;
+type CartridgeID = string;
+export type ControllerAccounts = Record<ContractAddress, CartridgeID>;
+export interface Keychain {
+    probe(rpcUrl: string): Promise<ProbeReply | ConnectError>;
+    connect(policies: SessionPolicies, rpcUrl: string): Promise<ConnectReply | ConnectError>;
+    disconnect(): void;
+    reset(): void;
+    revoke(origin: string): void;
+    deploy(): Promise<DeployReply | ConnectError>;
+    execute(calls: Call | Call[], abis?: Abi[], transactionsDetail?: InvocationsDetails, sync?: boolean, paymaster?: any, error?: ControllerError): Promise<ExecuteReply | ConnectError>;
+    signMessage(typedData: TypedData, account: string, async?: boolean): Promise<Signature | ConnectError>;
+    openSettings(): Promise<void | ConnectError>;
+    session(): Promise<Session>;
+    sessions(): Promise<{
+        [key: string]: Session;
+    }>;
+    delegateAccount(): string;
+    username(): string;
+    openPurchaseCredits(): void;
+    openExecute(calls: Call[]): Promise<void>;
+    switchChain(rpcUrl: string): Promise<void>;
+    externalDetectWallets(): Promise<ExternalWallet[]>;
+    externalConnectWallet(type: ExternalWalletType): Promise<ExternalWalletResponse>;
+    externalSignMessage(type: ExternalWalletType, message: string): Promise<ExternalWalletResponse>;
+    externalSignTypedData(type: ExternalWalletType, data: any): Promise<ExternalWalletResponse>;
+    externalGetBalance(type: ExternalWalletType, tokenAddress?: string): Promise<ExternalWalletResponse>;
+}
+export interface Profile {
+    navigate(path: string): void;
+    switchChain(rpcUrl: string): Promise<void>;
+}
+export interface Modal {
+    open: () => void;
+    close: () => void;
+}
+/**
+ * Options for configuring the controller
+ */
+export type ControllerOptions = ProviderOptions & KeychainOptions & ProfileOptions;
+export type IFrameOptions = {
+    /** The ID of the starter pack to use */
+    starterPackId?: string;
+    /** The preset to use */
+    preset?: string;
+};
+export type Chain = {
+    rpcUrl: string;
+};
+export type ProviderOptions = {
+    defaultChainId: ChainId;
+    chains: Chain[];
+};
+export type KeychainOptions = IFrameOptions & {
+    policies?: SessionPolicies;
+    /** The URL of keychain */
+    url?: string;
+    /** The origin of keychain */
+    origin?: string;
+    /** Propagate transaction errors back to caller instead of showing modal */
+    propagateSessionErrors?: boolean;
+};
+export type ProfileOptions = IFrameOptions & {
+    /** The URL of profile. Mainly for internal development purpose */
+    profileUrl?: string;
+    /** The project name of Slot instance. */
+    slot?: string;
+    /** The namespace to use to fetch trophies data from indexer. Will be mandatory once profile page is in production */
+    namespace?: string;
+    /** The tokens to be listed on Inventory modal */
+    tokens?: Tokens;
+    /** The policies to use for the profile */
+    policies?: SessionPolicies;
+};
+export type ProfileContextTypeVariant = "inventory" | "trophies" | "achievements" | "activity";
+export type Tokens = {
+    erc20?: string[];
+};
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+import { Call } from 'starknet';
+import { default as wasm } from '@cartridge/account-wasm/controller';
+import { Policies, SessionPolicies } from '@cartridge/presets';
+import { ChainId } from '@starknet-io/types-js';
+import { ParsedSessionPolicies } from './policies';
+export declare function normalizeCalls(calls: Call | Call[]): {
+    entrypoint: string;
+    contractAddress: string;
+    calldata: import('starknet').HexCalldata;
+}[];
+export declare function toSessionPolicies(policies: Policies): SessionPolicies;
+export declare function toWasmPolicies(policies: ParsedSessionPolicies): wasm.Policy[];
+export declare function toArray<T>(val: T | T[]): T[];
+export declare function humanizeString(str: string): string;
+export declare function parseChainId(url: URL): Promise<ChainId>;

package/dist/wallets/argent/index.d.ts

@@ -0,0 +1,14 @@
+import { WalletAdapter, ExternalWallet, ExternalWalletResponse, ExternalWalletType, ExternalPlatform } from '../types';
+import { TypedData } from '@starknet-io/types-js';
+export declare class ArgentWallet implements WalletAdapter {
+    readonly type: ExternalWalletType;
+    readonly platform: ExternalPlatform;
+    private wallet;
+    private account;
+    isAvailable(): boolean;
+    getInfo(): ExternalWallet;
+    connect(): Promise<ExternalWalletResponse<any>>;
+    signTypedData(data: TypedData): Promise<ExternalWalletResponse<any>>;
+    switchChain(_chainId: string): Promise<boolean>;
+    getBalance(_tokenAddress?: string): Promise<ExternalWalletResponse<any>>;
+}

package/dist/wallets/bridge.d.ts

@@ -0,0 +1,29 @@
+import { ExternalWalletType, ExternalWallet, ExternalWalletResponse } from './types';
+export declare class WalletBridge {
+    private readonly walletAdapters;
+    private readonly connectedWallets;
+    constructor();
+    getIFrameMethods(): {
+        externalDetectWallets: (_origin: string) => () => Promise<ExternalWallet[]>;
+        externalConnectWallet: (_origin: string) => (type: ExternalWalletType) => Promise<ExternalWalletResponse<unknown>>;
+        externalSignMessage: (_origin: string) => (type: ExternalWalletType, message: string) => Promise<ExternalWalletResponse<unknown>>;
+        externalSignTypedData: (_origin: string) => (type: ExternalWalletType, data: any) => Promise<ExternalWalletResponse<unknown>>;
+        externalGetBalance: (_origin: string) => (type: ExternalWalletType, tokenAddress?: string) => Promise<ExternalWalletResponse<unknown>>;
+    };
+    detectWallets(): Promise<ExternalWallet[]>;
+    private getWalletAdapter;
+    private handleError;
+    connectWallet(type: ExternalWalletType): Promise<ExternalWalletResponse>;
+    signMessage(type: ExternalWalletType, message: string): Promise<ExternalWalletResponse>;
+    signTypedData(type: ExternalWalletType, data: any): Promise<ExternalWalletResponse>;
+    getBalance(type: ExternalWalletType, tokenAddress?: string): Promise<ExternalWalletResponse>;
+}
+declare global {
+    interface Window {
+        ethereum?: any;
+        solana?: any;
+        starknet_argentX?: any;
+        wallet_bridge?: WalletBridge;
+    }
+}
+export type { ExternalWalletType, ExternalWallet, ExternalWalletResponse, WalletAdapter, } from './types';

package/dist/wallets/index.d.ts

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

package/dist/wallets/metamask/index.d.ts

@@ -0,0 +1,16 @@
+import { WalletAdapter, ExternalWallet, ExternalWalletResponse, ExternalWalletType, ExternalPlatform } from '../types';
+export declare class MetaMaskWallet implements WalletAdapter {
+    readonly type: ExternalWalletType;
+    readonly platform: ExternalPlatform;
+    private MMSDK;
+    private account;
+    constructor();
+    isAvailable(): boolean;
+    getInfo(): ExternalWallet;
+    connect(): Promise<ExternalWalletResponse<any>>;
+    signTransaction(transaction: any): Promise<ExternalWalletResponse<any>>;
+    signMessage(message: string): Promise<ExternalWalletResponse<any>>;
+    signTypedData(data: any): Promise<ExternalWalletResponse<any>>;
+    switchChain(chainId: string): Promise<boolean>;
+    getBalance(tokenAddress?: string): Promise<ExternalWalletResponse<any>>;
+}

package/dist/wallets/phantom/index.d.ts

@@ -0,0 +1,13 @@
+import { WalletAdapter, ExternalWallet, ExternalWalletResponse, ExternalWalletType, ExternalPlatform } from '../types';
+export declare class PhantomWallet implements WalletAdapter {
+    readonly type: ExternalWalletType;
+    readonly platform: ExternalPlatform;
+    private account;
+    isAvailable(): boolean;
+    getInfo(): ExternalWallet;
+    connect(): Promise<ExternalWalletResponse<any>>;
+    signTransaction(transaction: any): Promise<ExternalWalletResponse<any>>;
+    signMessage(message: string): Promise<ExternalWalletResponse<any>>;
+    switchChain(_chainId: string): Promise<boolean>;
+    getBalance(_tokenAddress?: string): Promise<ExternalWalletResponse<any>>;
+}

package/dist/wallets/types.d.ts

@@ -0,0 +1,27 @@
+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;
+    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>>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartridge/controller",
-  "version": "0.7.7",
+  "version": "0.7.9-alpha.1",
   "description": "Cartridge Controller",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,75 +8,55 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": "./dist/index.js"
     },
     "./session": {
-      "types": "./dist/session/index.d.ts",
-      "import": "./dist/session/index.js",
-      "require": "./dist/session/index.cjs"
+      "types": "./dist/session.d.ts",
+      "import": "./dist/session.js"
     },
     "./session/node": {
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.js",
       "require": "./dist/node/index.cjs"
-    },
-    "./provider": {
-      "types": "./dist/provider/index.d.ts",
-      "import": "./dist/provider/index.js"
-    },
-    "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js"
     }
   },
-  "tsup": {
-    "entry": [
-      "src/index.ts",
-      "src/controller.ts",
-      "src/lookup.ts",
-      "src/session/index.ts",
-      "src/node/index.ts"
-    ],
-    "format": [
-      "esm",
-      "cjs"
-    ],
-    "splitting": false,
-    "sourcemap": true,
-    "clean": true,
-    "dts": true,
-    "treeshake": {
-      "preset": "recommended"
-    },
-    "exports": "named"
-  },
   "peerDependencies": {
+    "@metamask/sdk": "^0.32.1",
+    "@phantom/wallet-sdk": "^0.0.23",
+    "open": "^10.1.0",
     "starknet": "^6.21.0",
-    "open": "^10.1.0"
+    "starknetkit": "^2.6.1"
   },
   "dependencies": {
     "@cartridge/penpal": "^6.2.4",
+    "@metamask/sdk": "^0.32.1",
     "@starknet-io/types-js": "^0.7.7",
     "@telegram-apps/sdk": "^2.4.0",
-    "base64url": "^3.0.1",
     "cbor-x": "^1.5.0",
     "fast-deep-equal": "^3.1.3",
-    "@cartridge/account-wasm": "0.7.7"
+    "@cartridge/account-wasm": "0.7.9-alpha.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/node": "^18.0.6",
     "jest": "^29.7.0",
     "prettier": "^3.4.2",
+    "rollup-plugin-visualizer": "^5.12.0",
     "ts-jest": "^29.2.5",
     "tsup": "^8.0.1",
     "typescript": "^5.7.3",
-    "@cartridge/tsconfig": "0.7.7"
+    "vite": "^6.0.0",
+    "vite-plugin-dts": "^4.5.3",
+    "vite-plugin-node-polyfills": "^0.22.0",
+    "vite-plugin-top-level-await": "^1.4.4",
+    "vite-plugin-wasm": "^3.4.1",
+    "@cartridge/tsconfig": "0.7.9-alpha.1"
   },
   "scripts": {
-    "build:deps": "tsup",
-    "build": "pnpm build:deps",
+    "build:deps": "pnpm build",
+    "build:browser": "vite build",
+    "build:node": "tsup --config tsup.node.config.ts",
+    "build": "pnpm build:browser && pnpm build:node",
     "format": "prettier --write \"src/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\"",
     "test": "jest",

package/src/iframe/base.ts

@@ -75,7 +75,7 @@ export class IFrame<CallSender extends {}> implements Modal {
 
     connectToChild<CallSender>({
       iframe: this.iframe,
-      methods: { close: () => this.close(), ...methods },
+      methods: { close: (_origin: string) => () => this.close(), ...methods },
     }).promise.then(onConnect);
 
     this.resize();

package/src/iframe/keychain.ts

@@ -1,12 +1,16 @@
 import { KEYCHAIN_URL } from "../constants";
 import { Keychain, KeychainOptions } from "../types";
+import { WalletBridge } from "../wallets/bridge";
 import { IFrame, IFrameOptions } from "./base";
 
 type KeychainIframeOptions = IFrameOptions<Keychain> & KeychainOptions;
 
 export class KeychainIFrame extends IFrame<Keychain> {
+  private walletBridge: WalletBridge;
+
   constructor({ url, policies, ...iframeOptions }: KeychainIframeOptions) {
     const _url = new URL(url ?? KEYCHAIN_URL);
+    const walletBridge = new WalletBridge();
 
     if (policies) {
       _url.searchParams.set(
@@ -19,6 +23,13 @@ export class KeychainIFrame extends IFrame<Keychain> {
       ...iframeOptions,
       id: "controller-keychain",
       url: _url,
+      methods: walletBridge.getIFrameMethods(),
     });
+
+    this.walletBridge = walletBridge;
+  }
+
+  getWalletBridge(): WalletBridge {
+    return this.walletBridge;
   }
 }

package/src/iframe/profile.ts

@@ -26,16 +26,18 @@ export class ProfileIFrame extends IFrame<Profile> {
     const _profileUrl = (profileUrl || PROFILE_URL).replace(/\/$/, "");
     let _url = new URL(
       slot
-        ? namespace
-          ? `${_profileUrl}/account/${username}/slot/${slot}?ps=${encodeURIComponent(
-              slot,
-            )}&ns=${encodeURIComponent(namespace)}`
-          : `${_profileUrl}/account/${username}/slot/${slot}?ps=${encodeURIComponent(
-              slot,
-            )}`
+        ? `${_profileUrl}/account/${username}/slot/${slot}`
         : `${_profileUrl}/account/${username}`,
     );
 
+    if (slot) {
+      _url.searchParams.set("ps", encodeURIComponent(slot));
+    }
+
+    if (namespace) {
+      _url.searchParams.set("ns", encodeURIComponent(namespace));
+    }
+
     if (version) {
       _url.searchParams.set("v", encodeURIComponent(version));
     }

package/src/index.ts

@@ -3,4 +3,5 @@ export * from "./errors";
 export * from "./types";
 export * from "./lookup";
 export * from "./utils";
+export * from "./wallets";
 export * from "@cartridge/presets";

package/src/node/index.ts

@@ -1,4 +1,4 @@
 export { default } from "./provider";
 export * from "./provider";
 export * from "../errors";
-export * from "../types";
+export type { ControllerError } from "../types";

package/src/types.ts

@@ -13,6 +13,11 @@ import {
 } from "@starknet-io/types-js";
 import { KeychainIFrame, ProfileIFrame } from "./iframe";
 import { Policy, SessionPolicies } from "@cartridge/presets";
+import {
+  ExternalWallet,
+  ExternalWalletResponse,
+  ExternalWalletType,
+} from "./wallets/types";
 
 export type Session = {
   chainId: constants.StarknetChainId;
@@ -129,6 +134,25 @@ export interface Keychain {
   openPurchaseCredits(): void;
   openExecute(calls: Call[]): Promise<void>;
   switchChain(rpcUrl: string): Promise<void>;
+
+  // External wallet methods
+  externalDetectWallets(): Promise<ExternalWallet[]>;
+  externalConnectWallet(
+    type: ExternalWalletType,
+  ): Promise<ExternalWalletResponse>;
+  externalSignMessage(
+    type: ExternalWalletType,
+    message: string,
+  ): Promise<ExternalWalletResponse>;
+  externalSignTypedData(
+    type: ExternalWalletType,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data: any,
+  ): Promise<ExternalWalletResponse>;
+  externalGetBalance(
+    type: ExternalWalletType,
+    tokenAddress?: string,
+  ): Promise<ExternalWalletResponse>;
 }
 
 export interface Profile {

package/src/wallets/argent/index.ts

@@ -0,0 +1,122 @@
+import {
+  WalletAdapter,
+  ExternalWallet,
+  ExternalWalletResponse,
+  ExternalWalletType,
+  ExternalPlatform,
+} from "../types";
+import { connect, StarknetWindowObject } from "starknetkit";
+import { InjectedConnector } from "starknetkit/injected";
+import { TypedData } from "@starknet-io/types-js";
+
+export class ArgentWallet implements WalletAdapter {
+  readonly type: ExternalWalletType = "argent";
+  readonly platform: ExternalPlatform = "starknet";
+  private wallet: StarknetWindowObject | undefined = undefined;
+  private account: string | undefined = undefined;
+
+  isAvailable(): boolean {
+    return typeof window !== "undefined" && !!window.starknet_argentX;
+  }
+
+  getInfo(): ExternalWallet {
+    const available = this.isAvailable();
+
+    return {
+      type: this.type,
+      available,
+      version: available
+        ? window.starknet_argentX?.version || "Unknown"
+        : undefined,
+      chainId: available ? window.starknet_argentX?.chainId : undefined,
+      name: "Argent",
+      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("Argent is not available");
+      }
+
+      const { wallet, connectorData } = await connect({
+        connectors: [new InjectedConnector({ options: { id: "argentX" } })],
+      });
+
+      if (!wallet) {
+        throw new Error("No wallet found");
+      }
+
+      this.wallet = wallet;
+      this.account = connectorData?.account;
+      return { success: true, wallet: this.type, account: this.account };
+    } catch (error) {
+      console.error(`Error connecting to Argent:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async signTypedData(data: TypedData): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.wallet) {
+        throw new Error("Argent is not connected");
+      }
+
+      console.log("signTypedData", data);
+
+      const sig = await this.wallet.request({
+        type: "wallet_signTypedData",
+        params: data,
+      });
+
+      return { success: true, wallet: this.type, result: sig };
+    } catch (error) {
+      console.error(`Error signing typed data with Argent:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+
+  async switchChain(_chainId: string): Promise<boolean> {
+    console.warn(
+      "Chain switching for Argent may require custom implementation",
+    );
+    return false;
+  }
+
+  async getBalance(
+    _tokenAddress?: string,
+  ): Promise<ExternalWalletResponse<any>> {
+    try {
+      if (!this.isAvailable() || !this.wallet) {
+        throw new Error("Argent is not connected");
+      }
+
+      // TODO: Implement balance fetching based on Argent's API
+      return {
+        success: true,
+        wallet: this.type,
+        result: "Implement based on Argent API",
+      };
+    } catch (error) {
+      console.error(`Error getting balance from Argent:`, error);
+      return {
+        success: false,
+        wallet: this.type,
+        error: (error as Error).message || "Unknown error",
+      };
+    }
+  }
+}