@swapkit/wallets 4.0.0-beta.54 → 4.0.0-beta.56

package/src/onekey/index.ts

@@ -1,213 +0,0 @@
-import {
-  Chain,
-  type NetworkParams,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-  addEVMWalletNetwork,
-  createWallet,
-  filterSupportedChains,
-  prepareNetworkSwitch,
-} from "@swapkit/helpers";
-import { Psbt } from "bitcoinjs-lib";
-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 { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const {
-        signTransaction: satsSignTransaction,
-        getAddress,
-        AddressPurpose,
-        BitcoinNetworkType,
-      } = await import("sats-connect");
-
-      let address = "";
-
-      const getProvider = () => new Promise<BitcoinProvider>((res) => res(window.$onekey?.btc));
-
-      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: Psbt) {
-        let signedPsbt: Psbt | undefined;
-        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.Aurora:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Gnosis:
-    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.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    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,126 +0,0 @@
-import {
-  type AssetValue,
-  Chain,
-  type GenericTransferParams,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-import { getWalletSupportedChains } from "../utils";
-
-export const phantomWallet = createWallet({
-  name: "connectPhantom",
-  walletType: WalletOption.PHANTOM,
-  supportedChains: [Chain.Bitcoin, Chain.Ethereum, Chain.Solana],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectPhantom(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      try {
-        await Promise.all(
-          filteredChains.map(async (chain) => {
-            const { address, ...methods } = await getWalletMethods(chain);
-
-            addChain({ ...methods, chain, address, walletType });
-          }),
-        );
-
-        return true;
-      } catch (error) {
-        if (error instanceof SwapKitError) throw error;
-
-        throw new SwapKitError("wallet_connection_rejected_by_user", error);
-      }
-    },
-});
-
-export const PHANTOM_SUPPORTED_CHAINS = getWalletSupportedChains(phantomWallet);
-export type PhantomSupportedChain = (typeof PHANTOM_SUPPORTED_CHAINS)[number];
-
-async function getWalletMethods(chain: PhantomSupportedChain) {
-  const phantom: any = window?.phantom;
-
-  switch (chain) {
-    case Chain.Bitcoin: {
-      const provider = phantom?.bitcoin;
-      if (!provider?.isPhantom) {
-        throw new SwapKitError("wallet_phantom_not_found");
-      }
-
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const [{ address }] = await provider.requestAccounts();
-      const toolbox = await getUtxoToolbox(chain);
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Ethereum: {
-      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 = await getEvmToolbox(chain, { signer, provider });
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Solana: {
-      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
-      const provider = phantom?.solana;
-      if (!provider?.isPhantom) {
-        throw new SwapKitError("wallet_phantom_not_found");
-      }
-
-      const providerConnection = await provider.connect();
-      const address: string = providerConnection.publicKey.toString();
-      const toolbox = await getSolanaToolbox();
-
-      const transfer = async ({
-        recipient,
-        assetValue,
-        isProgramDerivedAddress,
-      }: 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 connection = await toolbox.getConnection();
-
-        const transaction = await toolbox.createTransaction({
-          recipient,
-          assetValue,
-          sender: address,
-          isProgramDerivedAddress,
-        });
-
-        if (!transaction) {
-          throw new SwapKitError("core_transaction_invalid_sender_address");
-        }
-
-        const blockHash = await connection.getLatestBlockhash();
-        transaction.recentBlockhash = blockHash.blockhash;
-        transaction.feePayer = fromPubkey;
-
-        const signedTransaction = await provider.signTransaction(transaction);
-
-        const txid = await connection.sendRawTransaction(signedTransaction.serialize());
-
-        return txid;
-      };
-
-      return { ...toolbox, transfer, address };
-    }
-
-    default: {
-      throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.PHANTOM, chain });
-    }
-  }
-}

package/src/polkadotjs/index.ts

@@ -1,67 +0,0 @@
-import {
-  Chain,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-import { getWalletSupportedChains } from "../utils";
-
-export const polkadotWallet = createWallet({
-  name: "connectPolkadotJs",
-  walletType: WalletOption.POLKADOT_JS,
-  supportedChains: [Chain.Polkadot],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectPolkadotJs(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const { address, ...walletMethods } = await getWalletMethods(chain);
-
-          addChain({ ...walletMethods, chain, address, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const POLKADOT_SUPPORTED_CHAINS = getWalletSupportedChains(polkadotWallet);
-
-async function getWalletMethods(chain: Chain) {
-  switch (chain) {
-    case Chain.Polkadot: {
-      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 getSubstrateToolbox(chain, { signer: rawExtension.signer });
-      const [account] = await rawExtension.accounts.get();
-
-      if (!account?.address) {
-        throw new SwapKitError({
-          errorKey: "wallet_missing_params",
-          info: { wallet: WalletOption.POLKADOT_JS, address: account?.address },
-        });
-      }
-
-      const address = toolbox.convertAddress(account.address, 0);
-      return {
-        ...toolbox,
-        getAddress: () => address,
-        address,
-      };
-    }
-
-    default:
-      throw new SwapKitError({
-        errorKey: "wallet_chain_not_supported",
-        info: { chain, wallet: WalletOption.POLKADOT_JS },
-      });
-  }
-}

package/src/radix/index.ts

@@ -1,202 +0,0 @@
-import type {
-  FungibleResourcesCollectionItem,
-  GatewayApiClient,
-  StateEntityDetailsVaultResponseItem,
-  StateEntityFungiblesPageRequest,
-  StateEntityFungiblesPageResponse,
-} from "@radixdlt/babylon-gateway-api-sdk";
-import {
-  AssetValue,
-  Chain,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-import { getWalletSupportedChains } from "../utils";
-
-export const radixWallet = createWallet({
-  name: "connectRadixWallet",
-  walletType: WalletOption.RADIX_WALLET,
-  supportedChains: [Chain.Radix],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectRadixWallet(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const radixConfig = SKConfig.get("integrations").radix;
-
-      if (!radixConfig) {
-        throw new SwapKitError("wallet_radix_not_found");
-      }
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods();
-
-          addChain({ ...walletMethods, chain, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const RADIX_SUPPORTED_CHAINS = getWalletSupportedChains(radixWallet);
-
-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) {
-    const stateEntityFungiblesPageRequest: StateEntityFungiblesPageRequest = {
-      address: address,
-      limit_per_page: 100,
-      cursor: nextCursor,
-      at_ledger_state: { state_version: stateVersion },
-    };
-
-    const stateEntityFungiblesPageResponse: StateEntityFungiblesPageResponse =
-      await networkApi.state.innerClient.entityFungiblesPage({
-        stateEntityFungiblesPageRequest: stateEntityFungiblesPageRequest,
-      });
-
-    fungibleResources = fungibleResources.concat(stateEntityFungiblesPageResponse.items);
-
-    if (stateEntityFungiblesPageResponse.next_cursor) {
-      nextCursor = stateEntityFungiblesPageResponse.next_cursor;
-    } else {
-      hasNextPage = false;
-    }
-  }
-  return fungibleResources;
-}
-
-async function currentStateVersion(networkApi: GatewayApiClient) {
-  return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
-}
-
-// TODO - @Towan: is that still needed with SwapKitApi.getChainBalance()?
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Split into multiple functions
-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;
-
-  // Split resources into batches of up to 50 items
-  const resourceBatches: FungibleResourcesCollectionItem[][] = [];
-  for (let i = 0; i < resources.length; i += BATCH_SIZE) {
-    resourceBatches.push(resources.slice(i, i + BATCH_SIZE));
-  }
-
-  for (const batch of resourceBatches) {
-    const addresses = batch.map((item) => item.resource_address);
-    const response: StateEntityDetailsVaultResponseItem[] =
-      await networkApi.state.getEntityDetailsVaultAggregated(addresses);
-
-    const divisibilities = new Map<string, { decimals: number; symbol: string }>();
-
-    for (const result of response) {
-      if (result.details !== undefined) {
-        const metaDataSymbol = result.metadata?.items.find((item) => item.key === "symbol");
-        const symbol =
-          metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
-
-        if (result.details.type === "FungibleResource") {
-          divisibilities.set(result.address, { decimals: result.details.divisibility, symbol });
-        }
-      }
-    }
-
-    for (const item of batch) {
-      if (item.aggregation_level === "Global") {
-        const assetInfo = divisibilities.get(item.resource_address) || { decimals: 0, symbol: "?" };
-
-        const balance = AssetValue.from({
-          asset:
-            assetInfo.symbol !== Chain.Radix
-              ? `${Chain.Radix}.${assetInfo.symbol}-${item.resource_address}`
-              : "XRD.XRD",
-          value: item.amount,
-        });
-        balances.push(balance);
-      }
-    }
-  }
-
-  return balances;
-}
-
-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));
-  }
-
-  // TODO: @Towan - Wat is dat?
-  await delay(400);
-
-  function getAddress() {
-    const existingWalletData = rdt.walletApi.getWalletData();
-    const account = existingWalletData?.accounts?.[0];
-
-    return account?.address;
-  }
-
-  const getNewAddress = async () => {
-    const { DataRequestBuilder } = await import("@radixdlt/radix-dapp-toolkit");
-    rdt.walletApi.setRequestData(DataRequestBuilder.accounts().exactly(1));
-    const res = await rdt.walletApi.sendRequest();
-
-    if (!res) {
-      throw new SwapKitError("wallet_radix_no_account");
-    }
-
-    const newAddress = res.unwrapOr(null)?.accounts[0]?.address;
-
-    if (!newAddress) {
-      throw new SwapKitError("wallet_radix_no_account");
-    }
-
-    return newAddress;
-  };
-
-  const address = getAddress() || (await getNewAddress());
-
-  return {
-    radixDappToolkit: rdt,
-    address,
-    getAddress,
-    getBalance: () => getBalance(address),
-    transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
-      throw new SwapKitError("wallet_radix_method_not_supported", { method: "transfer" });
-    },
-    signAndBroadcast: async ({ manifest, message }: { manifest: string; message: string }) => {
-      const tx = await rdt.walletApi.sendTransaction({
-        transactionManifest: manifest,
-        message,
-      });
-
-      const txResult = tx.unwrapOr(null)?.transactionIntentHash;
-
-      if (!txResult) {
-        throw new SwapKitError("wallet_radix_transaction_failed");
-      }
-
-      return txResult;
-    },
-  };
-}