@swapkit/wallets 3.0.0-beta.0 → 3.0.0-beta.2

package/src/onekey/index.ts

@@ -0,0 +1,213 @@
+import {
+  Chain,
+  type NetworkParams,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+  addEVMWalletNetwork,
+  createWallet,
+  filterSupportedChains,
+  prepareNetworkSwitch,
+} from "@swapkit/helpers";
+import type {
+  BitcoinProvider,
+  GetAddressOptions,
+  GetAddressResponse,
+  SignTransactionOptions,
+} from "sats-connect";
+import { getWalletSupportedChains } from "../utils";
+
+async function getWalletMethodsForExtension(chain: Chain) {
+  switch (chain) {
+    case Chain.Bitcoin: {
+      if (!window.$onekey?.btc) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain },
+        });
+      }
+
+      const { Psbt } = await import("bitcoinjs-lib");
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const {
+        signTransaction: satsSignTransaction,
+        getAddress,
+        AddressPurpose,
+        BitcoinNetworkType,
+      } = await import("sats-connect");
+
+      let address = "";
+
+      const getProvider: () => Promise<BitcoinProvider | undefined> = () =>
+        new Promise((res) => res(window.$onekey?.btc as BitcoinProvider));
+
+      const getAddressOptions: GetAddressOptions = {
+        getProvider,
+        payload: {
+          purposes: [AddressPurpose.Payment],
+          message: "Address for receiving and sending payments",
+          network: { type: BitcoinNetworkType.Mainnet },
+        },
+        onFinish: (response: GetAddressResponse) => {
+          if (response.addresses[0]?.address) {
+            address = response.addresses[0].address;
+          }
+        },
+        onCancel: () => {
+          throw new SwapKitError("wallet_connection_rejected_by_user");
+        },
+      };
+
+      await getAddress(getAddressOptions);
+
+      async function signTransaction(psbt: any) {
+        let signedPsbt: any;
+        const signPsbtOptions: SignTransactionOptions = {
+          getProvider,
+          payload: {
+            message: "Sign transaction",
+            network: {
+              type: BitcoinNetworkType.Mainnet,
+            },
+            psbtBase64: psbt.toBase64(),
+            broadcast: false,
+            inputsToSign: [
+              {
+                address,
+                signingIndexes: psbt.txInputs.map((_: any, index: number) => index),
+              },
+            ],
+          },
+          onFinish: (response) => {
+            signedPsbt = Psbt.fromBase64(response.psbtBase64);
+          },
+          onCancel: () => {
+            throw new SwapKitError("wallet_connection_rejected_by_user");
+          },
+        };
+
+        await satsSignTransaction(signPsbtOptions);
+        if (!signedPsbt) throw new SwapKitError("wallet_onekey_sign_transaction_error");
+        return signedPsbt;
+      }
+
+      const signer = {
+        signTransaction,
+        getAddress: () => Promise.resolve(address),
+      };
+
+      const toolbox = await getUtxoToolbox(chain, { signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Solana: {
+      if (!window.$onekey?.sol) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain },
+        });
+      }
+
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+
+      const signer = window.$onekey.sol;
+      const address = await signer.getAddress();
+      const toolbox = getSolanaToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Arbitrum:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Optimism:
+    case Chain.Polygon: {
+      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+      if (!window.$onekey?.ethereum) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain },
+        });
+      }
+
+      const { BrowserProvider } = await import("ethers");
+      const provider = new BrowserProvider(window.$onekey.ethereum, "any");
+
+      const rpcUrl = SKConfig.get("rpcUrls")[chain];
+
+      await provider.send("eth_requestAccounts", []);
+      const jsonRpcProvider = await getProvider(chain, rpcUrl);
+      const signer = await provider.getSigner();
+      const address = await signer.getAddress();
+
+      const toolbox = await getEvmToolbox(chain, { provider: jsonRpcProvider, signer });
+      try {
+        if (chain !== Chain.Ethereum) {
+          const networkParams = toolbox.getNetworkParams() as NetworkParams;
+
+          await addEVMWalletNetwork(provider, networkParams);
+        }
+      } catch (error) {
+        throw new SwapKitError({
+          errorKey: "wallet_failed_to_add_or_switch_network",
+          info: { chain, error },
+        });
+      }
+
+      return {
+        address,
+        ...prepareNetworkSwitch({ toolbox, chain, provider }),
+      };
+    }
+
+    default:
+      throw new SwapKitError({
+        errorKey: "wallet_chain_not_supported",
+        info: { chain, wallet: WalletOption.ONEKEY },
+      });
+  }
+}
+
+export const onekeyWallet = createWallet({
+  name: "connectOnekeyWallet",
+  walletType: WalletOption.ONEKEY,
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.Ethereum,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Solana,
+  ],
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectOnekeyWallet(chains: Chain[]) {
+      if (!window.$onekey) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { wallet: WalletOption.ONEKEY },
+        });
+      }
+
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethodsForExtension(chain);
+
+          const address = (await walletMethods.getAddress()) || "F";
+
+          addChain({ ...walletMethods, chain, address, walletType });
+        }),
+      );
+
+      return true;
+    },
+});
+
+export const ONEKEY_WALLET_SUPPORTED_CHAINS = getWalletSupportedChains(onekeyWallet);

package/src/phantom/index.ts

@@ -1,14 +1,13 @@
 import {
   type AssetValue,
   Chain,
+  type GenericTransferParams,
   SwapKitError,
   WalletOption,
-  type WalletTxParams,
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { SolanaProvider } from "@swapkit/toolboxes/solana";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 
 export const phantomWallet = createWallet({
   name: "connectPhantom",
@@ -23,7 +22,7 @@ export const phantomWallet = createWallet({
           filteredChains.map(async (chain) => {
             const { address, ...methods } = await getWalletMethods(chain);
 
-            addChain({ ...methods, chain, address, walletType, balance: [] });
+            addChain({ ...methods, chain, address, walletType });
           }),
         );
 
@@ -39,14 +38,6 @@ export const phantomWallet = createWallet({
 export const PHANTOM_SUPPORTED_CHAINS = getWalletSupportedChains(phantomWallet);
 export type PhantomSupportedChain = (typeof PHANTOM_SUPPORTED_CHAINS)[number];
 
-declare global {
-  interface Window {
-    phantom: {
-      solana: SolanaProvider;
-    };
-  }
-}
-
 async function getWalletMethods(chain: PhantomSupportedChain) {
   const phantom: any = window?.phantom;
 
@@ -57,31 +48,28 @@ async function getWalletMethods(chain: PhantomSupportedChain) {
         throw new SwapKitError("wallet_phantom_not_found");
       }
 
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
       const [{ address }] = await provider.requestAccounts();
-
-      const toolbox = getToolboxByChain(chain)();
+      const toolbox = await getUtxoToolbox(chain);
 
       return { ...toolbox, address };
     }
 
     case Chain.Ethereum: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
       const { BrowserProvider } = await import("ethers");
 
       const provider = new BrowserProvider(phantom?.ethereum, "any");
       const [address] = await provider.send("eth_requestAccounts", []);
 
       const signer = await provider.getSigner();
-      const toolbox = getToolboxByChain(chain)({ signer, provider });
+      const toolbox = await getEvmToolbox(chain, { signer, provider });
 
       return { ...toolbox, address };
     }
 
     case Chain.Solana: {
-      const { createSolanaTokenTransaction, SOLToolbox } = await import(
-        "@swapkit/toolboxes/solana"
-      );
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
       const provider = phantom?.solana;
       if (!provider?.isPhantom) {
         throw new SwapKitError("wallet_phantom_not_found");
@@ -89,41 +77,29 @@ async function getWalletMethods(chain: PhantomSupportedChain) {
 
       const providerConnection = await provider.connect();
       const address: string = providerConnection.publicKey.toString();
-      const toolbox = SOLToolbox();
+      const toolbox = await getSolanaToolbox();
 
       const transfer = async ({
         recipient,
         assetValue,
         isProgramDerivedAddress,
-      }: WalletTxParams & { assetValue: AssetValue; isProgramDerivedAddress?: boolean }) => {
-        const { PublicKey, Transaction, SystemProgram } = await import("@solana/web3.js");
+      }: GenericTransferParams & { assetValue: AssetValue; isProgramDerivedAddress?: boolean }) => {
+        const { PublicKey } = await import("@solana/web3.js");
         const validateAddress = await toolbox.getAddressValidator();
+
         if (!(isProgramDerivedAddress || validateAddress(recipient))) {
           throw new SwapKitError("core_transaction_invalid_recipient_address");
         }
 
         const fromPubkey = new PublicKey(address);
-        const amount = assetValue.getBaseValue("number");
         const connection = await toolbox.getConnection();
 
-        const transaction = assetValue.isGasAsset
-          ? new Transaction().add(
-              SystemProgram.transfer({
-                fromPubkey,
-                lamports: amount,
-                toPubkey: new PublicKey(recipient),
-              }),
-            )
-          : assetValue.address
-            ? await createSolanaTokenTransaction({
-                amount,
-                connection,
-                decimals: assetValue.decimal as number,
-                from: fromPubkey,
-                recipient,
-                tokenAddress: assetValue.address,
-              })
-            : undefined;
+        const transaction = await toolbox.createTransaction({
+          recipient,
+          assetValue,
+          sender: address,
+          isProgramDerivedAddress,
+        });
 
         if (!transaction) {
           throw new SwapKitError("core_transaction_invalid_sender_address");

package/src/polkadotjs/index.ts

@@ -5,8 +5,7 @@ import {
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { InjectedWindow } from "@swapkit/toolboxes/substrate";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 
 export const polkadotWallet = createWallet({
   name: "connectPolkadotJs",
@@ -20,7 +19,7 @@ export const polkadotWallet = createWallet({
         filteredChains.map(async (chain) => {
           const { address, ...walletMethods } = await getWalletMethods(chain);
 
-          addChain({ ...walletMethods, chain, address, walletType, balance: [] });
+          addChain({ ...walletMethods, chain, address, walletType });
         }),
       );
 
@@ -33,16 +32,15 @@ export const POLKADOT_SUPPORTED_CHAINS = getWalletSupportedChains(polkadotWallet
 async function getWalletMethods(chain: Chain) {
   switch (chain) {
     case Chain.Polkadot: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/substrate");
-      const injectedWindow = window as Window & InjectedWindow;
-      const injectedExtension = injectedWindow?.injectedWeb3?.["polkadot-js"];
+      const { getSubstrateToolbox } = await import("@swapkit/toolboxes/substrate");
+      const injectedExtension = window?.injectedWeb3?.["polkadot-js"];
 
       const rawExtension = await injectedExtension?.enable?.("polkadot-js");
       if (!rawExtension) {
         throw new SwapKitError({ errorKey: "wallet_polkadot_not_found", info: { chain } });
       }
 
-      const toolbox = await getToolboxByChain(chain, { signer: rawExtension.signer });
+      const toolbox = await getSubstrateToolbox(chain, { signer: rawExtension.signer });
       const [account] = await rawExtension.accounts.get();
 
       if (!account?.address) {

package/src/radix/index.ts

@@ -1,22 +1,20 @@
-import {
-  type FungibleResourcesCollectionItem,
+import type {
+  FungibleResourcesCollectionItem,
   GatewayApiClient,
-  type StateEntityDetailsVaultResponseItem,
-  type StateEntityFungiblesPageRequest,
-  type StateEntityFungiblesPageResponse,
+  StateEntityDetailsVaultResponseItem,
+  StateEntityFungiblesPageRequest,
+  StateEntityFungiblesPageResponse,
 } from "@radixdlt/babylon-gateway-api-sdk";
-import { DataRequestBuilder, RadixDappToolkit } from "@radixdlt/radix-dapp-toolkit";
 import {
   AssetValue,
   Chain,
   SKConfig,
-  type SKConfigIntegrations,
   SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 
 export const radixWallet = createWallet({
   name: "connectRadixWallet",
@@ -33,9 +31,9 @@ export const radixWallet = createWallet({
 
       await Promise.all(
         filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods(radixConfig);
+          const walletMethods = await getWalletMethods();
 
-          addChain({ ...walletMethods, chain, balance: [], walletType });
+          addChain({ ...walletMethods, chain, walletType });
         }),
       );
 
@@ -45,13 +43,15 @@ export const radixWallet = createWallet({
 
 export const RADIX_SUPPORTED_CHAINS = getWalletSupportedChains(radixWallet);
 
-async function fetchFungibleResources({
-  address,
-  networkApi,
-}: { address: string; networkApi: GatewayApiClient }): Promise<FungibleResourcesCollectionItem[]> {
+async function fetchFungibleResources(address: string): Promise<FungibleResourcesCollectionItem[]> {
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+  const { applicationName } = SKConfig.get("integrations").radix;
+  const networkApi = GatewayApiClient.initialize({ networkId: 1, applicationName });
+
   let hasNextPage = true;
   let nextCursor: string | undefined;
   let fungibleResources: FungibleResourcesCollectionItem[] = [];
+
   const stateVersion = await currentStateVersion(networkApi);
 
   while (hasNextPage) {
@@ -82,25 +82,14 @@ async function currentStateVersion(networkApi: GatewayApiClient) {
   return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
 }
 
-function getBalance({ networkApi }: { networkApi: GatewayApiClient }) {
-  return async function getBalance(address: string) {
-    const fungibleResources = await fetchFungibleResources({ address, networkApi });
-    const fungibleBalances = convertResourcesToBalances({
-      resources: fungibleResources,
-      networkApi,
-    });
-    return fungibleBalances;
-  };
-}
-
+// TODO - @Towan: is that still needed with SwapKitApi.getChainBalance()?
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Split into multiple functions
-async function convertResourcesToBalances({
-  resources,
-  networkApi,
-}: {
-  resources: FungibleResourcesCollectionItem[]; //| NonFungibleResourcesCollectionItem[];
-  networkApi: GatewayApiClient;
-}): Promise<AssetValue[]> {
+async function getBalance(address: string): Promise<AssetValue[]> {
+  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
+  const resources = await fetchFungibleResources(address);
+  const { applicationName } = SKConfig.get("integrations").radix;
+  const networkApi = GatewayApiClient.initialize({ networkId: 1, applicationName });
+
   const balances: AssetValue[] = [];
   const BATCH_SIZE = 50;
 
@@ -124,10 +113,7 @@ async function convertResourcesToBalances({
           metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
 
         if (result.details.type === "FungibleResource") {
-          divisibilities.set(result.address, {
-            decimals: result.details.divisibility,
-            symbol,
-          });
+          divisibilities.set(result.address, { decimals: result.details.divisibility, symbol });
         }
       }
     }
@@ -147,18 +133,20 @@ async function convertResourcesToBalances({
       }
     }
   }
-  // Iterate through resources
+
   return balances;
 }
 
-const getWalletMethods = async (dappConfig: SKConfigIntegrations["radix"]) => {
+async function getWalletMethods() {
+  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
+  const dappConfig = SKConfig.get("integrations").radix;
   const rdt = RadixDappToolkit({ ...dappConfig, networkId: dappConfig.network.networkId });
 
   function delay(ms: number) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
-  // Wat is dat
+  // TODO: @Towan - Wat is dat?
   await delay(400);
 
   function getAddress() {
@@ -169,6 +157,7 @@ const getWalletMethods = async (dappConfig: SKConfigIntegrations["radix"]) => {
   }
 
   const getNewAddress = async () => {
+    const { DataRequestBuilder } = await import("@radixdlt/radix-dapp-toolkit");
     rdt.walletApi.setRequestData(DataRequestBuilder.accounts().exactly(1));
     const res = await rdt.walletApi.sendRequest();
 
@@ -187,15 +176,11 @@ const getWalletMethods = async (dappConfig: SKConfigIntegrations["radix"]) => {
 
   const address = getAddress() || (await getNewAddress());
 
-  const networkApi = GatewayApiClient.initialize({
-    networkId: 1,
-    applicationName: dappConfig.applicationName,
-  });
-
   return {
     radixDappToolkit: rdt,
     address,
-    getBalance: () => getBalance({ networkApi })(address),
+    getAddress,
+    getBalance: () => getBalance(address),
     transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
       throw new Error("Not implemented");
     },
@@ -213,6 +198,5 @@ const getWalletMethods = async (dappConfig: SKConfigIntegrations["radix"]) => {
 
       return txResult;
     },
-    getAddress: getAddress,
   };
-};
+}

package/src/talisman/index.ts

@@ -1,7 +1,6 @@
 import {
   Chain,
   type EVMChain,
-  type EthereumWindowProvider,
   SwapKitError,
   WalletOption,
   createWallet,
@@ -9,10 +8,8 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { NonETHToolbox } from "@swapkit/toolboxes/evm";
-import { type InjectedWindow, Network } from "@swapkit/toolboxes/substrate";
 import type { Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 
 export const talismanWallet = createWallet({
   name: "connectTalisman",
@@ -34,9 +31,9 @@ export const talismanWallet = createWallet({
 
       await Promise.all(
         filteredChains.map(async (chain) => {
-          const { address, ...walletMethods } = await getWalletMethods(chain);
+          const walletMethods = await getWalletMethods(chain);
 
-          addChain({ ...walletMethods, address, balance: [], chain, walletType });
+          addChain({ ...walletMethods, chain, walletType });
         }),
       );
 
@@ -46,16 +43,11 @@ export const talismanWallet = createWallet({
 
 export const TALISMAN_SUPPORTED_CHAINS = getWalletSupportedChains(talismanWallet);
 
-declare const window: {
-  talismanEth: EthereumWindowProvider;
-} & Window &
-  InjectedWindow;
-
 async function getWeb3WalletMethods({
   walletProvider,
   chain,
 }: { walletProvider: Eip1193Provider | undefined; chain: EVMChain }) {
-  const { getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
   const { BrowserProvider } = await import("ethers");
 
   if (!walletProvider) {
@@ -67,13 +59,11 @@ async function getWeb3WalletMethods({
 
   const provider = new BrowserProvider(walletProvider, "any");
   const signer = await provider.getSigner();
-
-  const toolbox = getToolboxByChain(chain)({ provider, signer });
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
 
   try {
     if (chain !== Chain.Ethereum) {
-      const networkParams = (toolbox as NonETHToolbox).getNetworkParams();
-      await switchEVMWalletNetwork(provider, chain, networkParams);
+      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
     }
   } catch (_error) {
     throw new SwapKitError({
@@ -82,7 +72,7 @@ async function getWeb3WalletMethods({
     });
   }
 
-  return prepareNetworkSwitch<typeof toolbox>({ toolbox, chain, provider });
+  return prepareNetworkSwitch({ toolbox, chain, provider });
 }
 
 async function getWalletMethods(chain: Chain) {
@@ -97,30 +87,27 @@ async function getWalletMethods(chain: Chain) {
       if (!(window.talismanEth && "send" in window.talismanEth)) {
         throw new SwapKitError({ errorKey: "wallet_talisman_not_found", info: { chain } });
       }
-      const { getProvider } = await import("@swapkit/toolboxes/evm");
 
       const evmWallet = await getWeb3WalletMethods({ chain, walletProvider: window.talismanEth });
       const address: string = (await window.talismanEth.send("eth_requestAccounts", []))[0];
 
-      const getBalance = async (addressOverwrite?: string, potentialScamFilter = true) =>
-        evmWallet.getBalance(addressOverwrite || address, potentialScamFilter, getProvider(chain));
-
-      return { walletMethods: { ...evmWallet, getBalance }, address };
+      return { ...evmWallet, address };
     }
 
     case Chain.Polkadot:
     case Chain.Chainflip: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/substrate");
+      const { getSubstrateToolbox, SubstrateNetwork } = await import(
+        "@swapkit/toolboxes/substrate"
+      );
 
-      const injectedWindow = window as Window & InjectedWindow;
-      const injectedExtension = injectedWindow?.injectedWeb3?.talisman;
+      const injectedExtension = window?.injectedWeb3?.talisman;
       const rawExtension = await injectedExtension?.enable?.("talisman");
 
       if (!rawExtension) {
         throw new SwapKitError({ errorKey: "wallet_talisman_not_enabled", info: { chain } });
       }
 
-      const toolbox = await getToolboxByChain(chain, { signer: rawExtension.signer });
+      const toolbox = await getSubstrateToolbox(chain, { signer: rawExtension.signer });
       const accounts = await rawExtension.accounts.get();
 
       if (!accounts[0]?.address) {
@@ -129,13 +116,9 @@ async function getWalletMethods(chain: Chain) {
           info: { wallet: WalletOption.TALISMAN, accounts, address: accounts[0]?.address },
         });
       }
-      const address = toolbox.convertAddress(accounts[0].address, Network[chain].prefix);
+      const address = toolbox.convertAddress(accounts[0].address, SubstrateNetwork[chain].prefix);
 
-      return {
-        ...toolbox,
-        getAddress: () => address,
-        address,
-      };
+      return { ...toolbox, address };
     }
 
     default: