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

package/src/adapters/EvmAdapter.ts

@@ -1,7 +1,105 @@
 import { BlockchainAdapter } from './BlockchainAdapter';
 import { NumberUtil } from '../utils/NumberUtil';
+import type { AppKitNetwork } from '../utils/TypeUtil';
+
+// 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 {
+  override subscribeToEvents(): void {
+    super.subscribeToEvents();
+    const provider = this.getProvider();
+    if (!provider) return;
+
+    // provider.on('reown_updateEmail', (info: any) => {
+    //   // this.emit('updateEmail', email);
+    //   //TODO: check this
+    //   // console.log('reown_updateEmail', info);
+    // });
+  }
+
+  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 +134,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 +145,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');
+    }
+
+    if ((method === 'transferFrom' || method === 'approve') && !spenderAddress) {
+      throw new Error(`EVMAdapter:writeContract - spenderAddress is required for ${method} method`);
     }
 
-    return receipt?.blockHash || null;
+    // 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 '../../utils/TypeUtil';
+
+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({ projectId: 'test', 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/utils/ConstantsUtil.ts

@@ -1,5 +1,5 @@
 export const ConstantsUtil = {
-  VERSION: '2.0.0-alpha.1',
+  VERSION: '2.0.0-alpha.2',
 
   EIP155: 'eip155',
   ADD_CHAIN_METHOD: 'wallet_addEthereumChain',
@@ -11,12 +11,14 @@ export const ConstantsUtil = {
   BLOCKCHAIN_API_RPC_URL_STAGING: 'https://staging.rpc.walletconnect.org',
   PULSE_API_URL: 'https://pulse.walletconnect.org',
   API_URL: 'https://api.web3modal.org',
-
-  WALLET_CONNECT_CONNECTOR_ID: 'walletConnect',
-  COINBASE_CONNECTOR_ID: 'coinbaseWallet',
-  AUTH_CONNECTOR_ID: 'appKitAuth',
+  WEB_WALLET_URL: 'https://web-wallet.walletconnect.org',
+  SECURE_SITE_DASHBOARD: `https://secure.reown.com/dashboard`,
+  SECURE_SITE_ICON: `https://secure.reown.com/images/favicon.png`,
 
   COINBASE_EXPLORER_ID: 'fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa',
+  PHANTOM_EXPLORER_ID: 'a797aa35c0fadbfc1a53e7f675162ed5226968b44a19ee3d24385c64d1d3c393',
+
+  WALLET_CONNECT_IMAGE_ID: 'ef1a1fcf-7fe8-4d69-bd6d-fda1345b4400',
 
   USDT_CONTRACT_ADDRESSES: [
     // Mainnet
@@ -33,5 +35,30 @@ export const ConstantsUtil = {
     '0x55d398326f99059fF775485246999027B3197955',
     // Arbitrum
     '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9'
-  ]
+  ],
+
+  PHANTOM_CUSTOM_WALLET: {
+    id: 'a797aa35c0fadbfc1a53e7f675162ed5226968b44a19ee3d24385c64d1d3c393',
+    name: 'Phantom Wallet',
+    image_id: 'b6ec7b81-bb4f-427d-e290-7631e6e50d00',
+    mobile_link: 'phantom://'
+  },
+
+  // Storage Keys
+  STORAGE_KEYS: {
+    WC_DEEPLINK: 'WALLETCONNECT_DEEPLINK_CHOICE', //dont change this one
+    RECENT_WALLET: '@appkit/recent_wallet',
+    CONNECTED_WALLET_IMAGE_URL: '@appkit/connected_wallet_image_url',
+    CONNECTED_CONNECTORS: '@appkit/connected_connectors',
+    CONNECTED_SOCIAL: '@appkit/connected_social',
+    ONRAMP_PREFERRED_COUNTRY: '@appkit/onramp_preferred_country',
+    ONRAMP_COUNTRIES: '@appkit/onramp_countries',
+    ONRAMP_SERVICE_PROVIDERS: '@appkit/onramp_service_providers',
+    ONRAMP_FIAT_LIMITS: '@appkit/onramp_fiat_limits',
+    ONRAMP_FIAT_CURRENCIES: '@appkit/onramp_fiat_currencies',
+    ONRAMP_PREFERRED_FIAT_CURRENCY: '@appkit/onramp_preferred_fiat_currency',
+    ONRAMP_COUNTRIES_DEFAULTS: '@appkit/onramp_countries_defaults',
+    ACTIVE_NAMESPACE: '@appkit/active_namespace',
+    COINBASE_CONNECTOR_SESSION: '@appkit/coinbase_connector/session'
+  }
 };

package/src/utils/ErrorUtil.ts

@@ -16,12 +16,12 @@ export const ErrorUtil = {
   ALERT_ERRORS: {
     INVALID_APP_CONFIGURATION: {
       shortMessage: 'Invalid App Configuration',
-      longMessage: `Bundle ID not found on Allowlist - Please verify that your bundle ID is allowed at https://cloud.reown.com`
+      longMessage: `Bundle ID not found on Allowlist - Please verify that your bundle ID is allowed at https://dashboard.reown.com`
     },
     SOCIALS_TIMEOUT: {
       shortMessage: 'Invalid App Configuration',
       longMessage:
-        'There was an issue loading the embedded wallet. Please verify that your bundle ID is allowed at https://cloud.reown.com'
+        'There was an issue loading the embedded wallet. Please verify that your bundle ID is allowed at https://dashboard.reown.com'
     },
     JWT_TOKEN_NOT_VALID: {
       shortMessage: 'Session Expired',

package/src/utils/PresetsUtil.ts

@@ -1,12 +1,4 @@
-import type { ConnectorType } from './TypeUtil';
-import { ConstantsUtil } from './ConstantsUtil';
-
 export const PresetsUtil = {
-  ConnectorExplorerIds: {
-    [ConstantsUtil.COINBASE_CONNECTOR_ID]:
-      'fd20dc426fb37566d803205b19bbc1d4096b248ac04548e3cfb6b3a38bd033aa'
-  } as Record<string, string>,
-
   NetworkImageIds: {
     // Ethereum
     1: 'ba0ba0cd-17c6-4806-ad93-f9d174f17900',
@@ -81,23 +73,6 @@ export const PresetsUtil = {
     '000000000933ea01ad0ee984209779ba': '39354064-d79b-420b-065d-f980c4b78200'
   } as Record<string, string>,
 
-  ConnectorNamesMap: {
-    [ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID]: 'WalletConnect',
-    [ConstantsUtil.COINBASE_CONNECTOR_ID]: 'Coinbase Wallet',
-    [ConstantsUtil.AUTH_CONNECTOR_ID]: 'AppKit Universal Wallet'
-  } as Record<string, string>,
-
-  ConnectorImageIds: {
-    [ConstantsUtil.COINBASE_CONNECTOR_ID]: '0c2840c3-5b04-4c44-9661-fbd4b49e1800',
-    [ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID]: 'ef1a1fcf-7fe8-4d69-bd6d-fda1345b4400'
-  } as Record<string, string>,
-
-  ConnectorTypesMap: {
-    [ConstantsUtil.WALLET_CONNECT_CONNECTOR_ID]: 'WALLET_CONNECT',
-    [ConstantsUtil.COINBASE_CONNECTOR_ID]: 'COINBASE',
-    [ConstantsUtil.AUTH_CONNECTOR_ID]: 'AUTH'
-  } as Record<string, ConnectorType>,
-
   RpcChainIds: [
     // Ethereum
     1,

package/src/utils/StringUtil.ts

@@ -5,5 +5,12 @@ export const StringUtil = {
     }
 
     return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+  },
+  hexToString(hexValue: string) {
+    // Remove 0x prefix if present
+    const cleanHex = hexValue.startsWith('0x') ? hexValue.slice(2) : hexValue;
+    // Convert hex to decimal number, then to string
+
+    return parseInt(cleanHex, 16).toString();
   }
 };