@okwallet/extension/src/index.js

OKX Wallet provides official SDK packages of multiple chains including [Ethereum](./wallet), [Aptos](./aptos-api), [Tron](./tron-api) and Solana. Developers can interact with different on-chain projects through OKX Wallet SDK.

import { arrayToMap, check, getProvider, isOkxApp } from './utils';
import { getAllEvmChainAddress } from './utils/chains';
import { deeplinkToApp } from './utils/deeplink';
import { CHAINS, chainsTypeMap } from './constant';
import Evm from './chain/Evm';
import Solana from './chain/Solana';
import Aptos from './chain/Aptos';

export default {
  CHAINS,
  aptos: {
    registerAptosCoin: Aptos.registerAptosCoin,
    getAptosBalance: Aptos.getAptosBalance,
    getAptosTransaction: Aptos.getAptosTransaction,
    checkAndRegAptosCoin: Aptos.checkAndRegAptosCoin,
  },

  setSolanaNetwork: (url) =>  {
    Solana.network = url;
  },

  init: (param) => {
    deeplinkToApp();

    return new Promise((resolve, reject) => {
      const {
        success,
        changed,
        error,
        uninstall,
      } = param || {};
      if (!check(uninstall)) {
        error && error();
        reject();
      }
      const provider = getProvider();

      if (isOkxApp()) {
        provider
        .request({ method: 'eth_requestAccounts' })
        .then((wallet) => {
          const result = {
            walletName: '',
            accountName: '',
            addresses: arrayToMap(getAllEvmChainAddress(wallet[0])),
          };
          resolve(result);
          success && success(result);
          changed &&
            provider.on('accountsChanged', (changedWallet) => {
              if (changedWallet.length < 1) {
                changed(null);
              } else {
                changed({
                  walletName: '',
                  accountName: '',
                  addresses: arrayToMap(getAllEvmChainAddress(changedWallet[0])),
                });
              }
            });
        })
        .catch((err) => {
          error && error(err);
          reject(err);
        });
      } else {
        provider
        .requestWallets(true)
        .then((wallet) => {
          const { address, name, keyringName } = wallet[0];
          const result = {
            walletName: keyringName,
            accountName: name,
            addresses: arrayToMap(address),
          };
          resolve(result);
          success && success(result);
          changed &&
            provider.on('walletChanged', (changedWallet) => {
              if (changedWallet.length < 1) {
                changed(null);
              } else {
                changed({
                  walletName: changedWallet[0].keyringName,
                  accountName: changedWallet[0].name,
                  addresses: arrayToMap(changedWallet[0].address),
                });
              }
            });
        })
        .catch((err) => {
          console.log(err);
          error && error(err);
          reject(err);
        });
      }
    });
  },

  disconnect: async () => {
    if (!check()) {
      return;
    }
    const provider = getProvider();
    await provider.disconnect && provider.disconnect();
  },

  addListener: (event, fn = () => {}) => {
    if (!check()) {
      return;
    }
    const provider = getProvider();
    provider.on && provider.on(event, fn);
  },

  removeListener: (event, fn = () => {}) => {
    if (!check()) {
      return;
    }
    const provider = getProvider();
    provider.removeListener && provider.removeListener(event, fn);
  },

  getAddress: (chainName) => {
    return new Promise((resolve, reject) => {
      if (!check()) {
        reject();
      }
      const provider = getProvider();
      if (isOkxApp()) {
        provider
        .request({ method: 'eth_accounts' })
        .then((wallet) => {
          if (!wallet || !wallet.length) {
            resolve({});
          }
          chainName ? resolve(
            {
              address: wallet[0],
              coinType: 60,
              chainName: chainName
            }
          ) : resolve(arrayToMap(getAllEvmChainAddress(wallet[0])));
        })
        .catch((err) => {
          reject(err);
        });
      } else{
        provider
          .requestWallets()
          .then((wallet) => {
            if (!wallet || !wallet.length) {
              resolve({});
            }
            const { address } = wallet[0];
            const resultMap = arrayToMap(address);
            resolve(chainName ? resultMap[chainName] : resultMap);
          })
          .catch((err) => {
            reject(err);
          });
      }
    });
  },

  sendTransaction: (param) => {
    return new Promise((resolve, reject) => {
      if (!check()) {
        reject();
      }
      const { chainName, payload } = param;
      if (!chainName) {
        throw new Error('chainName is necessary');
      }
      const provider = getProvider();
      if (chainsTypeMap.EVM[chainName]) {
        Evm.sendTransaction({ ...param, provider })
          .then((res) => {
            resolve(res);
          })
          .catch((err) => {
            reject(err);
          });
      } else if (chainsTypeMap.Solana[chainName]) {
        Solana.sendTransaction({ payload, provider })
          .then((res) => {
            resolve(res);
          })
          .catch((err) => {
            reject(err);
          });
      } else if (chainsTypeMap.Aptos[chainName]) {
        Aptos.sendTransaction({ payload, provider })
          .then((res) => {
            resolve(res);
          })
          .catch((err) => {
            reject(err);
          });
      } else {
        throw new Error('Unsupport chain!');
      }
    });
  },

  signMessage: (param) => {
    return new Promise((resolve, reject) => {
      if (!check()) {
        reject();
      }
      const { chainName } = param;
      if (!chainName) {
        throw new Error('chainName is necessary');
      }
      const provider = getProvider();
      if (chainsTypeMap.EVM[chainName]) {
        Evm.signMessage({ ...param, provider })
          .then((res) => {
            resolve(res);
          })
          .catch((err) => {
            reject(err);
          });
      } else if (chainsTypeMap.Solana[chainName]) {
        Solana.signMessage({ ...param, provider })
          .then(resolve)
          .catch(reject);
      } else if (chainsTypeMap.Aptos[chainName]) {
        Aptos.signMessage({ ...param, provider })
          .then(resolve)
          .catch(reject);
      } else {
        throw new Error('Unsupport chain!');
      }
    });
  },
};