@reown/appkit-common-react-native 2.0.0-alpha.1 → 2.0.0-alpha.3

package/lib/typescript/types/wallet/wallet-info.d.ts

@@ -0,0 +1,36 @@
+import type { CaipNetworkId } from '../common';
+export interface WalletInfo {
+    name?: string;
+    icon?: string;
+    description?: string;
+    url?: string;
+    icons?: string[];
+    redirect?: {
+        native?: string;
+        universal?: string;
+        linkMode?: boolean;
+    };
+    [key: string]: unknown;
+}
+export type Metadata = {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+    redirect?: {
+        native?: string;
+        universal?: string;
+        linkMode?: boolean;
+    };
+};
+export interface Token {
+    address: string;
+    image?: string;
+}
+export type Tokens = Record<CaipNetworkId, Token>;
+export interface Identity {
+    name: string;
+    avatar?: string;
+}
+export type ConnectedWalletInfo = WalletInfo | undefined;
+//# sourceMappingURL=wallet-info.d.ts.map

package/lib/typescript/types/wallet/wallet-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-info.d.ts","sourceRoot":"","sources":["../../../../src/types/wallet/wallet-info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,SAAS,CAAC"}

package/lib/typescript/utils/ConstantsUtil.d.ts

@@ -8,10 +8,36 @@ export declare const ConstantsUtil: {
     BLOCKCHAIN_API_RPC_URL_STAGING: string;
     PULSE_API_URL: string;
     API_URL: string;
-    WALLET_CONNECT_CONNECTOR_ID: string;
-    COINBASE_CONNECTOR_ID: string;
-    AUTH_CONNECTOR_ID: string;
-    COINBASE_EXPLORER_ID: string;
+    WEB_WALLET_URL: string;
+    SECURE_SITE_DASHBOARD: string;
+    SECURE_SITE_ICON: string;
+    REOWN_URL: string;
     USDT_CONTRACT_ADDRESSES: string[];
+    PHANTOM_CUSTOM_WALLET: {
+        id: string;
+        name: string;
+        image_id: string;
+        mobile_link: string;
+    };
+    COINBASE_CUSTOM_WALLET: {
+        id: string;
+        name: string;
+        image_id: string;
+        mobile_link: string;
+    };
+    STORAGE_KEYS: {
+        WC_DEEPLINK: string;
+        RECENT_WALLET: string;
+        CONNECTED_CONNECTORS: string;
+        ONRAMP_PREFERRED_COUNTRY: string;
+        ONRAMP_COUNTRIES: string;
+        ONRAMP_SERVICE_PROVIDERS: string;
+        ONRAMP_FIAT_LIMITS: string;
+        ONRAMP_FIAT_CURRENCIES: string;
+        ONRAMP_PREFERRED_FIAT_CURRENCY: string;
+        ONRAMP_COUNTRIES_DEFAULTS: string;
+        ACTIVE_NAMESPACE: string;
+        COINBASE_CONNECTOR_SESSION: string;
+    };
 };
 //# sourceMappingURL=ConstantsUtil.d.ts.map

package/lib/typescript/utils/ConstantsUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConstantsUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/ConstantsUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;CAoCzB,CAAC"}
+{"version":3,"file":"ConstantsUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/ConstantsUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEzB,CAAC"}

package/lib/typescript/utils/NetworkUtil.d.ts

@@ -1,4 +1,6 @@
+import type { CaipAddress } from '../types';
 export declare const NetworkUtil: {
     caipNetworkIdToNumber(caipnetworkId?: `${string}:${string}`): number | undefined;
+    getPlainAddress(caipAddress?: CaipAddress): string | undefined;
 };
 //# sourceMappingURL=NetworkUtil.d.ts.map

package/lib/typescript/utils/NetworkUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;0CACgB,GAAG,MAAM,IAAI,MAAM,EAAE;CAG5D,CAAC"}
+{"version":3,"file":"NetworkUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,eAAO,MAAM,WAAW;0CACgB,GAAG,MAAM,IAAI,MAAM,EAAE;kCAG7B,WAAW;CAG1C,CAAC"}

package/lib/typescript/utils/PresetsUtil.d.ts

@@ -1,10 +1,5 @@
-import type { ConnectorType } from './TypeUtil';
 export declare const PresetsUtil: {
-    ConnectorExplorerIds: Record<string, string>;
     NetworkImageIds: Record<string, string>;
-    ConnectorNamesMap: Record<string, string>;
-    ConnectorImageIds: Record<string, string>;
-    ConnectorTypesMap: Record<string, ConnectorType>;
     RpcChainIds: number[];
 };
 //# sourceMappingURL=PresetsUtil.d.ts.map

package/lib/typescript/utils/PresetsUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PresetsUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/PresetsUtil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD,eAAO,MAAM,WAAW;;;;;;;CAiJvB,CAAC"}
+{"version":3,"file":"PresetsUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/PresetsUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;CA2HvB,CAAC"}

package/lib/typescript/utils/StringUtil.d.ts

@@ -1,4 +1,5 @@
 export declare const StringUtil: {
     capitalize(value?: string): string;
+    hexToString(hexValue: string): string;
 };
 //# sourceMappingURL=StringUtil.d.ts.map

package/lib/typescript/utils/StringUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StringUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/StringUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;uBACF,MAAM;CAO1B,CAAC"}
+{"version":3,"file":"StringUtil.d.ts","sourceRoot":"","sources":["../../../src/utils/StringUtil.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;uBACF,MAAM;0BAOH,MAAM;CAO7B,CAAC"}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@reown/appkit-common-react-native",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "main": "lib/commonjs/index.js",
   "types": "lib/typescript/index.d.ts",
   "module": "lib/module/index.js",
+  "react-native": "src/index.ts",
   "source": "src/index.ts",
   "scripts": {
     "build": "bob build",
@@ -15,6 +16,10 @@
     "bignumber.js": "9.1.2",
     "dayjs": "1.11.10"
   },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.72"
+  },
   "files": [
     "src",
     "lib"
@@ -28,7 +33,7 @@
     "react-native"
   ],
   "repository": "https://github.com/reown-com/appkit-react-native",
-  "author": "Reown <support@reown.com> (https://reown.com)",
+  "author": "Reown (https://discord.gg/reown)",
   "homepage": "https://reown.com/appkit",
   "license": "Apache-2.0",
   "bugs": {
@@ -38,21 +43,6 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "react-native": "src/index.ts",
-  "react-native-builder-bob": {
-    "source": "src",
-    "output": "lib",
-    "targets": [
-      "commonjs",
-      "module",
-      [
-        "typescript",
-        {
-          "tsc": "../../node_modules/.bin/tsc"
-        }
-      ]
-    ]
-  },
   "eslintIgnore": [
     "node_modules/",
     "lib/"

package/src/adapters/BlockchainAdapter.ts

@@ -1,19 +1,23 @@
 import { EventEmitter } from 'events';
 import type {
   AdapterEvents,
+  AdapterType,
   AppKitNetwork,
+  BlockchainAdapterConfig,
+  BlockchainAdapterInitParams,
   CaipAddress,
   ChainNamespace,
   GetBalanceParams,
   GetBalanceResponse,
   Provider,
   WalletConnector
-} from '../utils/TypeUtil';
+} from '../types';
+import { NetworkUtil } from '../utils/NetworkUtil';
 
 export abstract class BlockchainAdapter extends EventEmitter {
-  public projectId: string;
   public connector?: WalletConnector;
   public supportedNamespace: ChainNamespace;
+  public adapterType: AdapterType;
 
   // Typed emit method
   override emit<K extends keyof AdapterEvents>(
@@ -23,20 +27,25 @@ export abstract class BlockchainAdapter extends EventEmitter {
     return super.emit(event, payload);
   }
 
-  constructor({
-    projectId,
-    supportedNamespace
-  }: {
-    projectId: string;
-    supportedNamespace: ChainNamespace;
-  }) {
+  // Typed on method
+  override on<K extends keyof AdapterEvents>(event: K, listener: AdapterEvents[K]): this {
+    return super.on(event, listener);
+  }
+
+  // Typed off method for consistency
+  override off<K extends keyof AdapterEvents>(event: K, listener: AdapterEvents[K]): this {
+    return super.off(event, listener);
+  }
+
+  constructor({ supportedNamespace, adapterType }: BlockchainAdapterConfig) {
     super();
-    this.projectId = projectId;
     this.supportedNamespace = supportedNamespace;
+    this.adapterType = adapterType;
   }
 
-  setConnector(connector: WalletConnector) {
+  init({ connector }: BlockchainAdapterInitParams) {
     this.connector = connector;
+
     this.subscribeToEvents();
   }
 
@@ -47,7 +56,7 @@ export abstract class BlockchainAdapter extends EventEmitter {
   getProvider(): Provider {
     if (!this.connector) throw new Error('No active connector');
 
-    return this.connector.getProvider();
+    return this.connector.getProvider(this.getSupportedNamespace());
   }
 
   subscribeToEvents(): void {
@@ -70,19 +79,27 @@ export abstract class BlockchainAdapter extends EventEmitter {
 
   onAccountsChanged(accounts: string[]): void {
     const _accounts = this.getAccounts();
-    const shouldEmit = _accounts?.some(account => {
-      const accountAddress = account.split(':')[2];
-
-      return accountAddress !== undefined && accounts.includes(accountAddress);
-    });
-
-    if (shouldEmit) {
-      this.emit('accountsChanged', { accounts });
+    const updatedAccounts =
+      _accounts
+        ?.filter(account => {
+          const accountAddress = NetworkUtil.getPlainAddress(account);
+
+          return accountAddress !== undefined && accounts.includes(accountAddress);
+        })
+        ?.sort((a, b) => {
+          const aIndex = accounts.indexOf(NetworkUtil.getPlainAddress(a) ?? '');
+          const bIndex = accounts.indexOf(NetworkUtil.getPlainAddress(b) ?? '');
+
+          return aIndex - bIndex;
+        }) ?? [];
+
+    if (updatedAccounts.length > 0) {
+      this.emit('accountsChanged', { accounts: updatedAccounts });
     }
   }
 
   onDisconnect(): void {
-    this.emit('disconnect', { namespace: this.getSupportedNamespace() });
+    this.emit('disconnect', undefined);
 
     const provider = this.connector?.getProvider();
     if (provider) {

package/src/adapters/EvmAdapter.ts

@@ -1,7 +1,93 @@
 import { BlockchainAdapter } from './BlockchainAdapter';
 import { NumberUtil } from '../utils/NumberUtil';
+import type { AppKitNetwork } from '../types';
+
+// Type definitions for writeContract
+export interface WriteContractData {
+  tokenAddress: `0x${string}`;
+  receiverAddress: `0x${string}`;
+  tokenAmount: bigint;
+  fromAddress: `0x${string}`;
+  method: 'transfer' | 'transferFrom' | 'approve';
+  abi?: any; // Optional ABI for future extensibility
+  spenderAddress?: `0x${string}`; // Required for transferFrom and approve
+  network: AppKitNetwork;
+}
+
+export interface SendTransactionData {
+  address: `0x${string}`;
+  network: AppKitNetwork;
+  to: `0x${string}`;
+  value: string;
+  data: string;
+}
+
+// Simple ABI encoder for ERC20 functions
+function encodeERC20Function(method: string, params: any[]): string {
+  const functionSelectors = {
+    transfer: '0xa9059cbb', // transfer(address,uint256)
+    transferFrom: '0x23b872dd', // transferFrom(address,address,uint256)
+    approve: '0x095ea7b3' // approve(address,uint256)
+  };
+
+  const selector = functionSelectors[method as keyof typeof functionSelectors];
+  if (!selector) {
+    throw new Error(`EVMAdapter:encodeERC20Function - unsupported method: ${method}`);
+  }
+
+  let encodedParams = '';
+
+  switch (method) {
+    case 'transfer':
+      if (params.length !== 2) throw new Error('transfer requires 2 parameters: to, amount');
+      const [to, amount] = params;
+      encodedParams =
+        to.toLowerCase().slice(2).padStart(64, '0') + amount.toString(16).padStart(64, '0');
+      break;
+
+    case 'transferFrom':
+      if (params.length !== 3)
+        throw new Error('transferFrom requires 3 parameters: from, to, amount');
+      const [from, toTransferFrom, amountTransferFrom] = params;
+      encodedParams =
+        from.toLowerCase().slice(2).padStart(64, '0') +
+        toTransferFrom.toLowerCase().slice(2).padStart(64, '0') +
+        amountTransferFrom.toString(16).padStart(64, '0');
+      break;
+
+    case 'approve':
+      if (params.length !== 2) throw new Error('approve requires 2 parameters: spender, amount');
+      const [spender, amountApprove] = params;
+      encodedParams =
+        spender.toLowerCase().slice(2).padStart(64, '0') +
+        amountApprove.toString(16).padStart(64, '0');
+      break;
+
+    default:
+      throw new Error(`EVMAdapter:encodeERC20Function - unsupported method: ${method}`);
+  }
+
+  return selector + encodedParams;
+}
 
 export abstract class EVMAdapter extends BlockchainAdapter {
+  async signMessage(address: string, message: string, chain?: string): Promise<string> {
+    const provider = this.getProvider();
+
+    if (!provider) {
+      throw new Error('EVMAdapter:signMessage - provider is undefined');
+    }
+
+    const signature = await provider.request(
+      {
+        method: 'personal_sign',
+        params: [message, address]
+      },
+      `eip155:${chain}`
+    );
+
+    return signature as string;
+  }
   async estimateGas({ address, to, data, chainNamespace }: any): Promise<bigint> {
     const provider = this.getProvider();
 
@@ -36,8 +122,8 @@ export abstract class EVMAdapter extends BlockchainAdapter {
     }
   }
 
-  async sendTransaction(data: any) {
-    const { address } = data || {};
+  async sendTransaction(data: SendTransactionData): Promise<`0x${string}` | null> {
+    const { address, network } = data || {};
 
     if (!this.getProvider()) {
       throw new Error('EVMAdapter:sendTransaction - provider is undefined');
@@ -47,33 +133,115 @@ export abstract class EVMAdapter extends BlockchainAdapter {
       throw new Error('EVMAdapter:sendTransaction - address is undefined');
     }
 
+    if (!network) {
+      throw new Error('EVMAdapter:sendTransaction - network is undefined');
+    }
+
     const txParams = {
       from: address,
       to: data.to,
       value: NumberUtil.convertNumericToHexString(data.value),
-      gas: NumberUtil.convertNumericToHexString(data.gas),
-      gasPrice: NumberUtil.convertNumericToHexString(data.gasPrice),
       data: data.data, // hex-encoded bytecode
       type: '0x0' // optional: legacy transaction type
     };
 
-    const txHash = await this.getProvider().request({
-      method: 'eth_sendTransaction',
-      params: [txParams]
-    });
+    const txHash = await this.getProvider().request(
+      {
+        method: 'eth_sendTransaction',
+        params: [txParams]
+      },
+      network.caipNetworkId
+    );
+
+    return txHash as `0x${string}` | null;
+  }
 
-    let receipt = null;
-    while (!receipt) {
-      receipt = (await this.getProvider().request({
-        method: 'eth_getTransactionReceipt',
-        params: [txHash]
-      })) as { blockHash?: `0x${string}` };
+  async writeContract(data: WriteContractData): Promise<`0x${string}` | null> {
+    const {
+      tokenAddress,
+      receiverAddress,
+      tokenAmount,
+      method,
+      fromAddress,
+      spenderAddress,
+      network
+    } = data;
 
-      if (!receipt) {
-        await new Promise(r => setTimeout(r, 1000)); // wait 1s
-      }
+    if (!this.getProvider()) {
+      throw new Error('EVMAdapter:writeContract - provider is undefined');
+    }
+
+    if (!fromAddress) {
+      throw new Error('EVMAdapter:writeContract - fromAddress is undefined');
+    }
+
+    if (!tokenAddress) {
+      throw new Error('EVMAdapter:writeContract - tokenAddress is undefined');
+    }
+
+    if (!tokenAmount) {
+      throw new Error('EVMAdapter:writeContract - tokenAmount is undefined');
+    }
+
+    if (!method) {
+      throw new Error('EVMAdapter:writeContract - method is undefined');
+    }
+
+    // Validate method-specific parameters
+    if (method === 'transfer' && !receiverAddress) {
+      throw new Error('EVMAdapter:writeContract - receiverAddress is required for transfer method');
     }
 
-    return receipt?.blockHash || null;
+    if ((method === 'transferFrom' || method === 'approve') && !spenderAddress) {
+      throw new Error(`EVMAdapter:writeContract - spenderAddress is required for ${method} method`);
+    }
+
+    // Encode the function call data based on method
+    let encodedData: string;
+
+    switch (method) {
+      case 'transfer':
+        encodedData = encodeERC20Function('transfer', [receiverAddress, tokenAmount]);
+        break;
+      case 'transferFrom':
+        encodedData = encodeERC20Function('transferFrom', [
+          fromAddress,
+          receiverAddress,
+          tokenAmount
+        ]);
+        break;
+      case 'approve':
+        encodedData = encodeERC20Function('approve', [spenderAddress, tokenAmount]);
+        break;
+      default:
+        throw new Error(`EVMAdapter:writeContract - method '${method}' is not supported`);
+    }
+
+    // Create transaction parameters
+    const txParams = {
+      from: fromAddress,
+      to: tokenAddress,
+      data: encodedData,
+      value: '0x0', // No ETH value for token operations
+      type: '0x0' // legacy transaction type
+    };
+
+    try {
+      // Send the transaction
+      const txHash = await this.getProvider().request(
+        {
+          method: 'eth_sendTransaction',
+          params: [txParams]
+        },
+        network.caipNetworkId
+      );
+
+      return txHash as `0x${string}` | null;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`EVMAdapter:writeContract - ${error.message}`);
+      }
+      throw new Error('EVMAdapter:writeContract - unknown error occurred');
+    }
   }
 }

package/src/adapters/SolanaBaseAdapter.ts

@@ -1,5 +1,6 @@
 import { BlockchainAdapter } from './BlockchainAdapter';
 
 export abstract class SolanaBaseAdapter extends BlockchainAdapter {
-  // solana logic
+  abstract signTransaction(data: any): Promise<string | null>;
+  abstract sendTransaction(data: any): Promise<string | null>;
 }

package/src/adapters/__tests__/EvmAdapter.test.ts

@@ -0,0 +1,126 @@
+import { EVMAdapter } from '../EvmAdapter';
+import type { AppKitNetwork, CaipAddress } from '../../types';
+
+const network: AppKitNetwork = {
+  id: 1,
+  name: 'Ethereum',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://eth.merkle.io']
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: 'Etherscan',
+      url: 'https://etherscan.io'
+    }
+  },
+  chainNamespace: 'eip155',
+  caipNetworkId: 'eip155:1'
+};
+
+// Mock implementation for testing
+class MockEVMAdapter extends EVMAdapter {
+  private mockProvider: any;
+
+  constructor() {
+    super({ supportedNamespace: 'eip155', adapterType: 'ethers' });
+    this.mockProvider = {
+      request: jest.fn(),
+      on: jest.fn(),
+      off: jest.fn()
+    };
+  }
+
+  setMockProvider(provider: any) {
+    this.mockProvider = provider;
+  }
+
+  override getProvider() {
+    return this.mockProvider;
+  }
+
+  async disconnect(): Promise<void> {}
+  getSupportedNamespace() {
+    return 'eip155' as const;
+  }
+  async getBalance() {
+    return { amount: '0', symbol: 'ETH' };
+  }
+  getAccounts(): CaipAddress[] | undefined {
+    return ['eip155:1:0x1234567890123456789012345678901234567890'];
+  }
+  async switchNetwork() {}
+}
+
+describe('EVMAdapter', () => {
+  let adapter: MockEVMAdapter;
+
+  beforeEach(() => {
+    adapter = new MockEVMAdapter();
+  });
+
+  describe('writeContract', () => {
+    it('should encode transfer function correctly', async () => {
+      const mockProvider = {
+        request: jest.fn().mockResolvedValueOnce('0x1234567890abcdef') // eth_sendTransaction
+      };
+      adapter.setMockProvider(mockProvider);
+
+      const result = await adapter.writeContract({
+        tokenAddress: '0x1234567890123456789012345678901234567890',
+        receiverAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        tokenAmount: BigInt(1000000000000000000), // 1 token with 18 decimals
+        fromAddress: '0x1234567890123456789012345678901234567890',
+        method: 'transfer',
+        network
+      });
+
+      expect(result).toBe('0x1234567890abcdef');
+      expect(mockProvider.request).toHaveBeenCalledWith(
+        {
+          method: 'eth_sendTransaction',
+          params: [
+            {
+              from: '0x1234567890123456789012345678901234567890',
+              to: '0x1234567890123456789012345678901234567890',
+              data: '0xa9059cbb000000000000000000000000abcdefabcdefabcdefabcdefabcdefabcdefabcd0000000000000000000000000000000000000000000000000de0b6b3a7640000',
+              value: '0x0',
+              type: '0x0'
+            }
+          ]
+        },
+        'eip155:1'
+      );
+    });
+
+    it('should throw error for unsupported method', async () => {
+      await expect(
+        adapter.writeContract({
+          tokenAddress: '0x1234567890123456789012345678901234567890',
+          receiverAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+          tokenAmount: BigInt(1000000000000000000),
+          fromAddress: '0x1234567890123456789012345678901234567890',
+          method: 'unsupported' as any,
+          network
+        })
+      ).rejects.toThrow("method 'unsupported' is not supported");
+    });
+
+    it('should throw error when provider is undefined', async () => {
+      adapter.setMockProvider(undefined);
+
+      await expect(
+        adapter.writeContract({
+          tokenAddress: '0x1234567890123456789012345678901234567890',
+          receiverAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+          tokenAmount: BigInt(1000000000000000000),
+          fromAddress: '0x1234567890123456789012345678901234567890',
+          method: 'transfer',
+          network
+        })
+      ).rejects.toThrow('provider is undefined');
+    });
+  });
+});

package/src/index.ts

@@ -13,4 +13,5 @@ export { bitcoin, bitcoinTestnet } from './networks/bitcoin';
 export { BlockchainAdapter } from './adapters/BlockchainAdapter';
 export { EVMAdapter } from './adapters/EvmAdapter';
 export { SolanaBaseAdapter } from './adapters/SolanaBaseAdapter';
-export * from './utils/TypeUtil';
+
+export * from './types';

package/src/networks/bitcoin.ts

@@ -1,4 +1,4 @@
-import type { AppKitNetwork } from '../utils/TypeUtil';
+import type { AppKitNetwork } from '../types';
 
 export const bitcoin: AppKitNetwork = {
   id: '000000000019d6689c085ae165831e93',