@swapkit/wallets 4.7.0 → 4.8.1

package/src/keystore.ts

@@ -0,0 +1,193 @@
+import {
+  type AssetValue,
+  Chain,
+  CosmosChains,
+  type DerivationPathArray,
+  EVMChains,
+  filterSupportedChains,
+  NetworkDerivationPath,
+  type UTXOChain,
+  UTXOChains,
+  updateDerivationPath,
+  WalletOption,
+} from "@swapkit/helpers";
+import type { DerivedAddress, FullWallet } from "@swapkit/toolboxes";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+
+export {
+  decryptFromKeystore,
+  encryptToKeyStore,
+  generatePhrase,
+  type Keystore,
+  validatePhrase,
+} from "./keystore-helpers";
+
+type UTXOToolboxWithHD = {
+  deriveAddressAtIndex: (params: { index: number; change?: boolean }) => DerivedAddress | undefined;
+  getExtendedPublicKey: () => string | undefined;
+  getBalance: (address: string) => Promise<AssetValue[]>;
+  resolveDerivationIndex?: (params: {
+    address: string;
+    gapLimit?: number;
+  }) => { index: number; change: boolean } | undefined;
+  transferFromMultipleAddresses?: (params: {
+    utxos: Array<{
+      hash: string;
+      index: number;
+      value: number;
+      txHex?: string;
+      derivationIndex: number;
+      isChange: boolean;
+      address: string;
+    }>;
+    recipient: string;
+    assetValue: AssetValue;
+    memo?: string;
+    feeRate?: number;
+  }) => Promise<string>;
+};
+
+function isUTXOToolboxWithHD(toolbox: unknown): toolbox is UTXOToolboxWithHD {
+  return (
+    typeof toolbox === "object" &&
+    toolbox !== null &&
+    "deriveAddressAtIndex" in toolbox &&
+    typeof (toolbox as UTXOToolboxWithHD).deriveAddressAtIndex === "function" &&
+    "getExtendedPublicKey" in toolbox &&
+    typeof (toolbox as UTXOToolboxWithHD).getExtendedPublicKey === "function" &&
+    "getBalance" in toolbox &&
+    typeof (toolbox as UTXOToolboxWithHD).getBalance === "function"
+  );
+}
+
+async function createHDWalletMethods(chain: UTXOChain, toolbox: UTXOToolboxWithHD) {
+  const { createHDWalletHelpers, getUtxoApi } = await import("@swapkit/toolboxes/utxo");
+
+  function deriveAddresses(params: { count: number; startIndex?: number; change?: boolean }) {
+    const { count, startIndex = 0, change = false } = params;
+    if (count < 1 || count > 1000) throw new RangeError(`count must be between 1 and 1000, got ${count}`);
+    if (startIndex < 0) throw new RangeError(`startIndex must be non-negative, got ${startIndex}`);
+
+    const addresses: DerivedAddress[] = [];
+    for (let i = 0; i < count; i++) {
+      const derived = toolbox.deriveAddressAtIndex({ change, index: startIndex + i });
+      if (derived) addresses.push(derived);
+    }
+    return addresses;
+  }
+
+  const { scanForAddresses, getAggregatedBalance, getAggregatedUtxos } = createHDWalletHelpers({
+    chain,
+    deriveAddress: (params) => toolbox.deriveAddressAtIndex(params),
+    getBalance: toolbox.getBalance,
+    getUtxos: (address: string) => getUtxoApi(chain).getUtxos({ address, fetchTxHex: true }),
+  });
+
+  return { deriveAddresses, getAggregatedBalance, getAggregatedUtxos, scanForAddresses };
+}
+
+export const keystoreWallet = createWallet({
+  connect: ({ addChain }) =>
+    async function connectKeystore(
+      chains: Chain[],
+      phrase: string,
+      derivationPathMapOrIndex?: { [chain in Chain]?: DerivationPathArray } | number,
+    ) {
+      const wallets = await createKeystoreWallet({ chains, derivationPathMapOrIndex, phrase });
+
+      for (const wallet of Object.values(wallets)) {
+        addChain({ ...wallet, chain: wallet.chain, walletType: WalletOption.KEYSTORE });
+      }
+
+      return true;
+    },
+  // Keystore holds the private key — direct signing works for every supported chain.
+  directSigningSupport: {
+    ...Object.fromEntries(EVMChains.map((chain) => [chain, true])),
+    ...Object.fromEntries(UTXOChains.map((chain) => [chain, true])),
+    ...Object.fromEntries(CosmosChains.filter((chain) => chain !== Chain.Harbor).map((chain) => [chain, true])),
+    [Chain.Aptos]: true,
+    [Chain.Cardano]: true,
+    [Chain.Near]: true,
+    [Chain.Ripple]: true,
+    [Chain.Solana]: true,
+    [Chain.Stellar]: true,
+    [Chain.Sui]: true,
+    [Chain.Ton]: true,
+    [Chain.Tron]: true,
+  },
+  name: "connectKeystore",
+  supportedChains: [
+    ...EVMChains,
+    ...UTXOChains,
+    ...CosmosChains.filter((chain) => chain !== Chain.Harbor),
+    Chain.Aptos,
+    Chain.Cardano,
+    Chain.Ripple,
+    Chain.Solana,
+    Chain.Stellar,
+    Chain.Sui,
+    Chain.Ton,
+    Chain.Tron,
+    Chain.Near,
+  ],
+  walletType: WalletOption.KEYSTORE,
+});
+
+export const KEYSTORE_SUPPORTED_CHAINS = getWalletSupportedChains(keystoreWallet);
+
+export async function createKeystoreWallet<T extends Chain[]>({
+  chains,
+  phrase,
+  derivationPathMapOrIndex,
+}: {
+  chains: T;
+  phrase: string;
+  derivationPathMapOrIndex?: { [chain in Chain]?: DerivationPathArray } | number;
+}) {
+  const filteredChains = filterSupportedChains({
+    chains,
+    supportedChains: KEYSTORE_SUPPORTED_CHAINS,
+    walletType: WalletOption.KEYSTORE,
+  });
+
+  const wallets = await Promise.all(
+    filteredChains.map(async (chain) => {
+      const { getToolbox } = await import("@swapkit/toolboxes");
+
+      const derivationPathIndex = typeof derivationPathMapOrIndex === "number" ? derivationPathMapOrIndex : 0;
+      const derivationPathFromMap =
+        derivationPathMapOrIndex && typeof derivationPathMapOrIndex === "object"
+          ? derivationPathMapOrIndex[chain]
+          : undefined;
+
+      const derivationArrayToUpdate = NetworkDerivationPath[chain].slice(
+        0,
+        chain === Chain.Solana ? 4 : 5,
+      ) as DerivationPathArray;
+
+      const derivationPath: DerivationPathArray =
+        derivationPathFromMap || updateDerivationPath(derivationArrayToUpdate, { index: derivationPathIndex });
+
+      const toolbox = await getToolbox(chain, { derivationPath, phrase });
+      const address = (await toolbox.getAddress()) || "";
+
+      const hdWalletMethods =
+        UTXOChains.includes(chain as UTXOChain) && isUTXOToolboxWithHD(toolbox)
+          ? await createHDWalletMethods(chain as UTXOChain, toolbox)
+          : {};
+
+      const wallet = { ...toolbox, ...hdWalletMethods, address, chain };
+
+      return wallet;
+    }),
+  );
+
+  return wallets.reduce(
+    (acc, wallet) => {
+      acc[wallet.chain as T[number]] = wallet as FullWallet[T[number]];
+      return acc;
+    },
+    {} as { [key in T[number]]: FullWallet[key] },
+  );
+}

package/src/ledger.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-hardware/ledger";

package/src/near-wallet-selector/index.ts

@@ -0,0 +1,116 @@
+import type { Wallet, WalletModuleFactory } from "@near-wallet-selector/core";
+import "@near-wallet-selector/modal-ui-js/styles.css";
+import type { Transaction } from "@near-js/transactions";
+import { Chain, filterSupportedChains, SKConfig, SwapKitError, WalletOption } from "@swapkit/helpers";
+import { getNearToolbox } from "@swapkit/toolboxes/near";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+
+function createNearSigner(wallet: Wallet) {
+  return {
+    getAddress: async () => {
+      const accounts = await wallet.getAccounts();
+      const accountId = accounts[0]?.accountId;
+
+      if (!accountId) {
+        throw new SwapKitError("wallet_connection_rejected_by_user");
+      }
+
+      return accountId;
+    },
+
+    getPublicKey: () => {
+      throw new SwapKitError("wallet_near_method_not_supported");
+    },
+    signAndSendTransactions: async (transactions: { transactions: Transaction[] }) => {
+      const result = await wallet.signAndSendTransactions(transactions);
+      return result?.[0]?.transaction_outcome.id || "";
+    },
+
+    signDelegateAction: () => {
+      throw new SwapKitError("wallet_near_method_not_supported");
+    },
+
+    signNep413Message: () => {
+      throw new SwapKitError("wallet_near_method_not_supported");
+    },
+
+    signTransaction: (params: Transaction) => {
+      if (!wallet.signTransaction) {
+        throw new SwapKitError("wallet_near_method_not_supported");
+      }
+      return wallet.signTransaction(params);
+    },
+  };
+}
+
+function waitForWalletSelection(selector: any, modal: any) {
+  return new Promise<void>((resolve) => {
+    const subscription = selector.store.observable.subscribe((state: any) => {
+      if (state.selectedWalletId) {
+        subscription.unsubscribe();
+        modal.hide();
+        resolve();
+      }
+    });
+
+    modal.show();
+  });
+}
+
+async function getWalletMethods(walletFactories?: WalletModuleFactory[]) {
+  const { setupWalletSelector } = await import("@near-wallet-selector/core");
+  const { setupModal } = await import("@near-wallet-selector/modal-ui-js");
+
+  const contractId = SKConfig.get("integrations")?.nearWalletSelector?.contractId || "";
+  const selector = await setupWalletSelector({ modules: [...(walletFactories || [])], network: "mainnet" });
+
+  const isSignedIn = selector.isSignedIn();
+
+  if (!isSignedIn) {
+    // Only show modal if not already connected
+    const modal = setupModal(selector, { contractId, description: "Connect your NEAR wallet to SwapKit" });
+
+    await waitForWalletSelection(selector, modal);
+  }
+
+  const wallet = await selector.wallet();
+  const signer = createNearSigner(wallet);
+  const toolbox = await getNearToolbox({ signer });
+  const address = await signer.getAddress();
+
+  const disconnect = async () => {
+    try {
+      await wallet.signOut();
+    } catch (error) {
+      throw new SwapKitError("wallet_connection_rejected_by_user", error);
+    }
+  };
+
+  return { ...toolbox, address, disconnect };
+}
+
+export const walletSelectorWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectWalletSelector(chains: Chain[], walletFactories?: WalletModuleFactory[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      if (filteredChains.length === 0) {
+        throw new SwapKitError("wallet_chain_not_supported", {
+          chain: chains[0],
+          wallet: WalletOption.WALLET_SELECTOR,
+        });
+      }
+
+      const walletMethods = await getWalletMethods(walletFactories);
+
+      addChain({ ...walletMethods, balance: [], chain: Chain.Near, walletType });
+
+      return true;
+    },
+  directSigningSupport: { [Chain.Near]: true },
+  name: "connectWalletSelector",
+  supportedChains: [Chain.Near],
+  walletType: WalletOption.WALLET_SELECTOR,
+});
+
+export const WALLET_SELECTOR_SUPPORTED_CHAINS = getWalletSupportedChains(walletSelectorWallet);

package/src/okx.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/okx";

package/src/onekey.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/onekey";

package/src/passkeys/index.ts

@@ -0,0 +1,183 @@
+import type { Wallet } from "@passkeys/core";
+import { base64 } from "@scure/base";
+import {
+  Chain,
+  EVMChains,
+  filterSupportedChains,
+  prepareNetworkSwitch,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+} from "@swapkit/helpers";
+import type { SolanaProvider } from "@swapkit/toolboxes/solana";
+import { Transaction } from "@swapkit/utxo-signer";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import {
+  AddressPurpose,
+  BitcoinNetworkType,
+  type GetAddressOptions,
+  type GetAddressResponse,
+  getAddress,
+  type SignTransactionOptions,
+  signTransaction as satsSignTransaction,
+} from "sats-connect";
+import { match } from "ts-pattern";
+
+async function getPasskeyWallet() {
+  const appId = SKConfig.get("apiKeys").passkeys;
+  const { createWallet } = await import("@passkeys/core");
+
+  return createWallet({
+    appId: appId.length > 0 ? appId : undefined,
+    providers: { bitcoin: true, ethereum: true, solana: true },
+  });
+}
+
+function getWalletMethods({ wallet, chain: paramChain }: { wallet: Wallet; chain: Chain }) {
+  return match(paramChain)
+    .with(Chain.Bitcoin, async (chain) => {
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const provider = await wallet.getProvider("bitcoin");
+
+      if (!provider) {
+        throw new SwapKitError("wallet_passkeys_not_found");
+      }
+
+      let address = "";
+
+      const getProvider = () => Promise.resolve(provider);
+
+      const getAddressOptions: GetAddressOptions = {
+        getProvider,
+        onCancel: () => {
+          throw new SwapKitError("wallet_passkeys_request_canceled");
+        },
+        onFinish: (response: GetAddressResponse) => {
+          if (!response.addresses[0]) throw new SwapKitError("wallet_passkeys_no_address");
+          address = response.addresses[0].address;
+        },
+        payload: {
+          message: "Address for receiving and sending payments",
+          network: { type: BitcoinNetworkType.Mainnet },
+          purposes: [AddressPurpose.Payment],
+        },
+      };
+
+      // TODO: Towan - probably not needed ?
+      await getAddress(getAddressOptions);
+
+      async function signTransaction(tx: InstanceType<typeof Transaction>) {
+        let signedTx: InstanceType<typeof Transaction> | undefined;
+        const psbtBytes = tx.toPSBT(0);
+        const psbtBase64Str = base64.encode(psbtBytes);
+        const inputCount = tx.inputsLength;
+
+        const signPsbtOptions: SignTransactionOptions = {
+          getProvider,
+          onCancel: () => {
+            throw new SwapKitError("wallet_passkeys_signature_canceled");
+          },
+          onFinish: (response) => {
+            signedTx = Transaction.fromPSBT(base64.decode(response.psbtBase64));
+          },
+          payload: {
+            broadcast: false,
+            inputsToSign: [{ address: address, signingIndexes: Array.from({ length: inputCount }, (_, i) => i) }],
+            message: "Sign transaction",
+            network: { type: BitcoinNetworkType.Mainnet },
+            psbtBase64: psbtBase64Str,
+          },
+        };
+
+        await satsSignTransaction(signPsbtOptions);
+        if (!signedTx) throw new SwapKitError("wallet_passkeys_sign_transaction_error");
+        return signedTx;
+      }
+
+      const signer = { getAddress: () => Promise.resolve(address), signTransaction };
+      const toolbox = await getUtxoToolbox(chain, { signer });
+
+      return { ...toolbox, address };
+    })
+    .with(...EVMChains, async (chain) => {
+      const { getProvider, getEvmToolboxAsync } = await import("@swapkit/toolboxes/evm");
+      const { BrowserProvider } = await import("ethers");
+
+      const walletProvider = await wallet.getProvider("ethereum");
+      if (!walletProvider) {
+        throw new SwapKitError("wallet_passkeys_not_found");
+      }
+
+      const jsonRpcProvider = await getProvider(chain);
+      const browserProvider = new BrowserProvider(walletProvider, "any");
+
+      await browserProvider.send("eth_requestAccounts", []);
+
+      const signer = await browserProvider.getSigner();
+      const address = await signer.getAddress();
+      const toolbox = await getEvmToolboxAsync(chain, { provider: jsonRpcProvider, signer });
+
+      return { ...prepareNetworkSwitch({ chain, provider: browserProvider, toolbox }), address };
+    })
+    .with(Chain.Solana, async () => {
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+      const provider = (await wallet.getProvider("solana")) as any as SolanaProvider;
+      const providerConnection = await provider.connect();
+      const address = providerConnection.publicKey.toString();
+      const toolbox = await getSolanaToolbox({ signer: provider });
+
+      const disconnect = async () => {
+        await provider.disconnect();
+      };
+
+      return { ...toolbox, address, disconnect };
+    })
+    .otherwise((chain) => {
+      throw new SwapKitError("wallet_passkeys_chain_not_supported", { chain });
+    });
+}
+
+export const passkeysWallet = createWallet({
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectPasskeys(chains: Chain[], paramWallet?: Wallet) {
+      const wallet = paramWallet || (await getPasskeyWallet());
+
+      if (!wallet) throw new SwapKitError("wallet_passkeys_instance_missing");
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          try {
+            const walletData = await getWalletMethods({ chain, wallet });
+
+            const { address, ...walletMethods } = walletData;
+
+            addChain({
+              ...walletMethods,
+              address,
+              chain,
+              disconnect: wallet.disconnect,
+              walletType: WalletOption.PASSKEYS,
+            });
+          } catch (error) {
+            console.error(`Failed to connect ${chain} wallet:`, error);
+            throw error;
+          }
+        }),
+      );
+
+      return true;
+    },
+  directSigningSupport: {
+    ...Object.fromEntries(EVMChains.map((chain) => [chain, true])),
+    [Chain.Bitcoin]: true,
+    [Chain.Solana]: true,
+  },
+  name: "connectPasskeys",
+  supportedChains: [...EVMChains, Chain.Bitcoin, Chain.Solana],
+  walletType: WalletOption.PASSKEYS,
+});
+
+export const PASSKEYS_SUPPORTED_CHAINS = getWalletSupportedChains(passkeysWallet);
+export * from "@passkeys/core";
+export * from "@passkeys/react";

package/src/phantom.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/phantom";

package/src/polkadotjs.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/polkadotjs";

package/src/radix/index.ts

@@ -0,0 +1,95 @@
+import { type AssetValue, Chain, filterSupportedChains, SKConfig, SwapKitError, WalletOption } from "@swapkit/helpers";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+
+export const radixWallet = createWallet({
+  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;
+    },
+  // Radix is not in V3 swap chain list
+  directSigningSupport: {},
+  name: "connectRadixWallet",
+  supportedChains: [Chain.Radix],
+  walletType: WalletOption.RADIX_WALLET,
+});
+
+export const RADIX_SUPPORTED_CHAINS = getWalletSupportedChains(radixWallet);
+
+async function getWalletMethods() {
+  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
+  const { getRadixToolbox } = await import("@swapkit/toolboxes/radix");
+
+  const dappConfig = SKConfig.get("integrations").radix;
+  const rdt = RadixDappToolkit({ ...dappConfig, networkId: dappConfig.network.networkId });
+  const toolbox = getRadixToolbox({ dappConfig });
+
+  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;
+  }
+
+  async function getNewAddress() {
+    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 {
+    address,
+    getAddress,
+    getBalance: () => toolbox.getBalance(address),
+    radixDappToolkit: rdt,
+    signAndBroadcast: async ({ manifest, message }: { manifest: string; message: string }) => {
+      const tx = await rdt.walletApi.sendTransaction({ message, transactionManifest: manifest });
+
+      const txResult = tx.unwrapOr(null)?.transactionIntentHash;
+
+      if (!txResult) {
+        throw new SwapKitError("wallet_radix_transaction_failed");
+      }
+
+      return txResult;
+    },
+    transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
+      throw new SwapKitError("wallet_radix_method_not_supported", { method: "transfer" });
+    },
+  };
+}

package/src/talisman.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/talisman";

package/src/trezor.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-hardware/trezor";

package/src/tronlink.ts

@@ -0,0 +1 @@
+export * from "@swapkit/wallet-extensions/tronlink";