@reown/appkit-common-react-native 0.0.0-chore-canary-20250722145858 → 0.0.0-chore-bump-builder-20250728195048

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@reown/appkit-common-react-native",
-  "version": "0.0.0-chore-canary-20250722145858",
+  "version": "0.0.0-chore-bump-builder-20250728195048",
   "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"
@@ -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

@@ -0,0 +1,107 @@
+import { EventEmitter } from 'events';
+import type {
+  AdapterEvents,
+  AdapterType,
+  AppKitNetwork,
+  BlockchainAdapterConfig,
+  CaipAddress,
+  ChainNamespace,
+  GetBalanceParams,
+  GetBalanceResponse,
+  Provider,
+  WalletConnector
+} from '../utils/TypeUtil';
+
+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>(
+    event: K,
+    payload: Parameters<AdapterEvents[K]>[0]
+  ): boolean {
+    return super.emit(event, payload);
+  }
+
+  constructor({ projectId, supportedNamespace, adapterType }: BlockchainAdapterConfig) {
+    super();
+    this.projectId = projectId;
+    this.supportedNamespace = supportedNamespace;
+    this.adapterType = adapterType;
+  }
+
+  setConnector(connector: WalletConnector) {
+    this.connector = connector;
+    this.subscribeToEvents();
+  }
+
+  removeConnector() {
+    this.connector = undefined;
+  }
+
+  getProvider(): Provider {
+    if (!this.connector) throw new Error('No active connector');
+
+    return this.connector.getProvider();
+  }
+
+  subscribeToEvents(): void {
+    const provider = this.connector?.getProvider();
+    if (!provider) return;
+
+    provider.on('chainChanged', this.onChainChanged.bind(this));
+    provider.on('accountsChanged', this.onAccountsChanged.bind(this));
+    provider.on('disconnect', this.onDisconnect.bind(this));
+  }
+
+  onChainChanged(chainId: string): void {
+    const _chains = this.getAccounts()?.map(account => account.split(':')[1]);
+    const shouldEmit = _chains?.some(chain => chain === chainId);
+
+    if (shouldEmit) {
+      this.emit('chainChanged', { chainId });
+    }
+  }
+
+  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 });
+    }
+  }
+
+  onDisconnect(): void {
+    this.emit('disconnect', { namespace: this.getSupportedNamespace() });
+
+    const provider = this.connector?.getProvider();
+    if (provider) {
+      provider.off('chainChanged', this.onChainChanged.bind(this));
+      provider.off('accountsChanged', this.onAccountsChanged.bind(this));
+      provider.off('disconnect', this.onDisconnect.bind(this));
+    }
+
+    this.connector = undefined;
+  }
+
+  parseUnits(value: string, decimals: number): bigint {
+    const [whole, fraction = ''] = value.split('.');
+    const paddedFraction = (fraction + '0'.repeat(decimals)).slice(0, decimals);
+
+    return BigInt(whole + paddedFraction);
+  }
+
+  abstract disconnect(): Promise<void>;
+  abstract getSupportedNamespace(): ChainNamespace;
+  abstract getBalance(params: GetBalanceParams): Promise<GetBalanceResponse>;
+  abstract getAccounts(): CaipAddress[] | undefined;
+  abstract switchNetwork(network: AppKitNetwork): Promise<void>;
+}

package/src/adapters/EvmAdapter.ts

@@ -0,0 +1,259 @@
+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();
+
+    if (!provider) {
+      throw new Error('EVMAdapter:estimateGas - provider is undefined');
+    }
+
+    if (!address) {
+      throw new Error('EVMAdapter:estimateGas - from address is undefined');
+    }
+
+    if (chainNamespace && chainNamespace !== 'eip155') {
+      throw new Error('EVMAdapter:estimateGas - chainNamespace is not eip155');
+    }
+
+    try {
+      const txParams = {
+        from: address,
+        to,
+        data,
+        type: '0x0' // optional, legacy type
+      };
+
+      const estimatedGasHex = await provider.request({
+        method: 'eth_estimateGas',
+        params: [txParams]
+      });
+
+      return BigInt(estimatedGasHex as string);
+    } catch (error) {
+      throw new Error('EVMAdapter:estimateGas - eth_estimateGas RPC failed');
+    }
+  }
+
+  async sendTransaction(data: SendTransactionData): Promise<`0x${string}` | null> {
+    const { address, network } = data || {};
+
+    if (!this.getProvider()) {
+      throw new Error('EVMAdapter:sendTransaction - provider is undefined');
+    }
+
+    if (!address) {
+      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),
+      data: data.data, // hex-encoded bytecode
+      type: '0x0' // optional: legacy transaction type
+    };
+
+    const txHash = await this.getProvider().request(
+      {
+        method: 'eth_sendTransaction',
+        params: [txParams]
+      },
+      network.caipNetworkId
+    );
+
+    return txHash as `0x${string}` | null;
+  }
+
+  async writeContract(data: WriteContractData): Promise<`0x${string}` | null> {
+    const {
+      tokenAddress,
+      receiverAddress,
+      tokenAmount,
+      method,
+      fromAddress,
+      spenderAddress,
+      network
+    } = data;
+
+    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`);
+    }
+
+    // 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

@@ -0,0 +1,6 @@
+import { BlockchainAdapter } from './BlockchainAdapter';
+
+export abstract class SolanaBaseAdapter extends BlockchainAdapter {
+  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/index.ts

@@ -8,4 +8,9 @@ export { PresetsUtil } from './utils/PresetsUtil';
 export { StringUtil } from './utils/StringUtil';
 export { ErrorUtil } from './utils/ErrorUtil';
 export { erc20ABI } from './contracts/erc20';
+export { solana, solanaDevnet, solanaTestnet } from './networks/solana';
+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';

package/src/networks/bitcoin.ts

@@ -0,0 +1,32 @@
+import type { AppKitNetwork } from '../utils/TypeUtil';
+
+export const bitcoin: AppKitNetwork = {
+  id: '000000000019d6689c085ae165831e93',
+  caipNetworkId: 'bip122:000000000019d6689c085ae165831e93',
+  chainNamespace: 'bip122',
+  name: 'Bitcoin',
+  nativeCurrency: {
+    name: 'Bitcoin',
+    symbol: 'BTC',
+    decimals: 8
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc.walletconnect.org/v1'] }
+  }
+};
+
+export const bitcoinTestnet: AppKitNetwork = {
+  id: '000000000933ea01ad0ee984209779ba',
+  caipNetworkId: 'bip122:000000000933ea01ad0ee984209779ba',
+  chainNamespace: 'bip122',
+  name: 'Bitcoin Testnet',
+  nativeCurrency: {
+    name: 'Bitcoin',
+    symbol: 'BTC',
+    decimals: 8
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc.walletconnect.org/v1'] }
+  },
+  testnet: true
+};

package/src/networks/solana.ts

@@ -0,0 +1,44 @@
+import type { AppKitNetwork } from '../utils/TypeUtil';
+
+export const solana: AppKitNetwork = {
+  id: '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+  name: 'Solana',
+  nativeCurrency: { name: 'Solana', symbol: 'SOL', decimals: 9 },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.walletconnect.org/v1']
+    }
+  },
+  blockExplorers: { default: { name: 'Solscan', url: 'https://solscan.io' } },
+  chainNamespace: 'solana',
+  caipNetworkId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+  deprecatedCaipNetworkId: 'solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ',
+  testnet: false
+};
+
+export const solanaDevnet: AppKitNetwork = {
+  id: 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+  name: 'Solana Devnet',
+  nativeCurrency: { name: 'Solana', symbol: 'SOL', decimals: 9 },
+  rpcUrls: {
+    default: { http: ['https://rpc.walletconnect.org/v1'] }
+  },
+  blockExplorers: { default: { name: 'Solscan', url: 'https://solscan.io' } },
+  chainNamespace: 'solana',
+  caipNetworkId: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+  deprecatedCaipNetworkId: 'solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K',
+  testnet: true
+};
+
+export const solanaTestnet: AppKitNetwork = {
+  id: '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z',
+  name: 'Solana Testnet',
+  nativeCurrency: { name: 'Solana', symbol: 'SOL', decimals: 9 },
+  rpcUrls: {
+    default: { http: ['https://rpc.walletconnect.org/v1'] }
+  },
+  blockExplorers: { default: { name: 'Solscan', url: 'https://solscan.io' } },
+  chainNamespace: 'solana',
+  caipNetworkId: 'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z',
+  testnet: true
+};

package/src/utils/ConstantsUtil.ts

@@ -1,5 +1,5 @@
 export const ConstantsUtil = {
-  VERSION: '0.0.0-chore-canary-20250722145858',
+  VERSION: '0.0.0-chore-bump-builder-20250728195048',
 
   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'
+  }
 };