@swapkit/wallets 4.8.0 → 4.8.1

package/package.json

@@ -18,8 +18,8 @@
     "@swapkit/toolboxes": "^4.15.0",
     "@swapkit/utxo-signer": "^2.1.1",
     "@swapkit/wallet-core": "^4.2.0",
-    "@swapkit/wallet-extensions": "^4.5.1",
-    "@swapkit/wallet-hardware": "^4.8.0",
+    "@swapkit/wallet-extensions": "4.5.2",
+    "@swapkit/wallet-hardware": "4.8.2",
     "@walletconnect/modal": "~2.7.0",
     "@walletconnect/sign-client": "~2.23.0",
     "cosmjs-types": "~0.10.1",
@@ -205,20 +205,12 @@
       "types": "./dist/types/xaman/index.d.ts"
     }
   },
-  "files": [
-    "dist/"
-  ],
+  "files": ["dist/", "src/"],
   "homepage": "https://github.com/swapkit/wallets",
   "license": "SEE LICENSE IN LICENSE",
   "name": "@swapkit/wallets",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "directory": "packages/wallets",
-    "type": "git",
-    "url": "git+https://github.com/swapkit/wallets.git"
-  },
+  "publishConfig": { "access": "public" },
+  "repository": { "directory": "packages/wallets", "type": "git", "url": "git+https://github.com/swapkit/wallets.git" },
   "scripts": {
     "build": "bun run ./build.ts",
     "build:clean": "rm -rf dist && bun run ./build.ts",
@@ -227,5 +219,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.8.0"
+  "version": "4.8.1"
 }

package/src/bitget.ts

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

package/src/coinbase/index.ts

@@ -0,0 +1,54 @@
+import { Chain, ChainToChainId, filterSupportedChains, SKConfig, WalletOption } from "@swapkit/helpers";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+
+import { getWalletMethods } from "./signer";
+
+export const coinbaseWallet = createWallet({
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectCoinbaseWallet(chains: Chain[]) {
+      const { createCoinbaseWalletSDK } = await import("@coinbase/wallet-sdk");
+
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      const coinbaseConfig = SKConfig.get("integrations").coinbase || { appName: "Swapkit Playground" };
+
+      const coinbaseSdk = createCoinbaseWalletSDK({
+        ...coinbaseConfig,
+        appChainIds: filteredChains.map((chain) => Number(ChainToChainId[chain])),
+      });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods({ chain, coinbaseSdk });
+
+          addChain({ ...walletMethods, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  directSigningSupport: {
+    [Chain.Arbitrum]: true,
+    [Chain.Avalanche]: true,
+    [Chain.Base]: true,
+    [Chain.BinanceSmartChain]: true,
+    [Chain.Ethereum]: true,
+    [Chain.Optimism]: true,
+    [Chain.Polygon]: true,
+    [Chain.XLayer]: true,
+  },
+  name: "connectCoinbaseWallet",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Ethereum,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.COINBASE_MOBILE,
+});
+
+export const COINBASE_SUPPORTED_CHAINS = getWalletSupportedChains(coinbaseWallet);

package/src/coinbase/signer.ts

@@ -0,0 +1,99 @@
+import type { CoinbaseWalletProvider } from "@coinbase/wallet-sdk";
+import type { createCoinbaseWalletSDK } from "@coinbase/wallet-sdk/dist/createCoinbaseWalletSDK.js";
+import { Chain, SwapKitError } from "@swapkit/helpers";
+import type { Provider, TypedDataDomain, TypedDataField } from "ethers";
+
+async function getCoinbaseMobileSigner(walletProvider: CoinbaseWalletProvider, provider?: Provider) {
+  const { AbstractSigner } = await import("ethers");
+
+  class CoinbaseMobileSigner extends AbstractSigner {
+    #coinbaseProvider: CoinbaseWalletProvider;
+
+    constructor(coinbaseProvider: CoinbaseWalletProvider, provider?: Provider) {
+      super(provider);
+      this.#coinbaseProvider = coinbaseProvider;
+    }
+
+    async getAddress() {
+      const accounts = await this.#coinbaseProvider.request<string[]>({ method: "eth_requestAccounts" });
+
+      if (!accounts[0]) throw new SwapKitError("wallet_coinbase_no_accounts");
+
+      return accounts[0];
+    }
+
+    async signTransaction() {
+      return await this.#coinbaseProvider.request<string>({ method: "eth_signTransaction" });
+    }
+
+    async signMessage(message: string | Uint8Array) {
+      return await this.#coinbaseProvider.request<string>({
+        method: "personal_sign",
+        params: [message, await this.getAddress()],
+      });
+    }
+
+    async signTypedData(
+      domain: TypedDataDomain,
+      types: Record<string, TypedDataField[]>,
+      value: Record<string, unknown>,
+      explicitPrimaryType?: string,
+    ) {
+      const { buildEIP712DomainType } = await import("@swapkit/toolboxes/evm");
+      const { TypedDataEncoder } = await import("ethers");
+      const address = await this.getAddress();
+
+      const { EIP712Domain: _, ...filteredTypes } = types;
+      const primaryType = explicitPrimaryType ?? TypedDataEncoder.from(filteredTypes).primaryType;
+
+      const payload = {
+        domain,
+        message: value,
+        primaryType,
+        types: { EIP712Domain: buildEIP712DomainType(domain), ...filteredTypes },
+      };
+
+      return await this.#coinbaseProvider.request<string>({
+        method: "eth_signTypedData_v4",
+        params: [address, JSON.stringify(payload)],
+      });
+    }
+
+    connect(provider: Provider) {
+      return new CoinbaseMobileSigner(this.#coinbaseProvider, provider);
+    }
+  }
+
+  return new CoinbaseMobileSigner(walletProvider, provider);
+}
+
+export const getWalletMethods = async ({
+  chain,
+  coinbaseSdk,
+}: {
+  chain: Chain;
+  coinbaseSdk: ReturnType<typeof createCoinbaseWalletSDK>;
+}) => {
+  switch (chain) {
+    case Chain.Ethereum:
+    case Chain.Avalanche:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.Base:
+    case Chain.BinanceSmartChain: {
+      const walletProvider = coinbaseSdk.getProvider() as CoinbaseWalletProvider;
+      const { getEvmToolboxAsync, getProvider } = await import("@swapkit/toolboxes/evm");
+
+      const provider = await getProvider(chain);
+      const signer = await getCoinbaseMobileSigner(walletProvider, provider);
+      const toolbox = await getEvmToolboxAsync(chain, { provider, signer });
+      const address = await signer.getAddress();
+
+      return { ...toolbox, address };
+    }
+
+    default:
+      throw new SwapKitError("wallet_coinbase_chain_not_supported", { chain });
+  }
+};

package/src/cosmostation.ts

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

package/src/ctrl.ts

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

package/src/evm-extensions.ts

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

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "@swapkit/wallet-core";
+export * from "./types";
+export * from "./utils";

package/src/keepkey-bex.ts

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

package/src/keepkey.ts

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

package/src/keplr.ts

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

package/src/keystore-helpers.ts

@@ -0,0 +1,93 @@
+import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "node:crypto";
+import { generateMnemonic, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+
+export type Keystore = {
+  version: number;
+  meta: string;
+  crypto: {
+    cipher: string;
+    cipherparams: { iv: string };
+    ciphertext: string;
+    kdf: string;
+    kdfparams: { prf: string; dklen: number; salt: string; c: number };
+    mac: string;
+  };
+};
+
+async function blake256(initData: Buffer | string) {
+  const { blake2b } = await import("@noble/hashes/blake2.js");
+  const data = initData instanceof Buffer ? initData : Buffer.from(initData as string, "hex");
+
+  const hash = blake2b(data, { dkLen: 32 });
+
+  return Array.from(hash as Uint8Array)
+    .map((byte) => (byte < 0x10 ? `0${byte.toString(16)}` : byte.toString(16)))
+    .join("");
+}
+
+export async function encryptToKeyStore(phrase: string, password: string) {
+  const cipher = "aes-128-ctr";
+  const iv = randomBytes(16);
+  const salt = randomBytes(32);
+  const kdfParams = { c: 262144, dklen: 32, prf: "hmac-sha256", salt: salt.toString("hex") };
+
+  const derivedKey = pbkdf2Sync(password, salt, kdfParams.c, kdfParams.dklen, "sha256");
+  const cipherIV = createCipheriv(cipher, derivedKey.subarray(0, 16), iv);
+  const ciphertext = Buffer.concat([cipherIV.update(Buffer.from(phrase, "utf8")), cipherIV.final()]);
+  const initData = Buffer.concat([derivedKey.subarray(16, 32), Buffer.from(ciphertext)]);
+  const mac = await blake256(initData);
+
+  return {
+    crypto: {
+      cipher,
+      cipherparams: { iv: iv.toString("hex") },
+      ciphertext: ciphertext.toString("hex"),
+      kdf: "pbkdf2",
+      kdfparams: kdfParams,
+      mac,
+    },
+    meta: "xchain-keystore",
+    version: 1,
+  };
+}
+
+export function generatePhrase(size: 12 | 24 = 12) {
+  return generateMnemonic(wordlist, size === 12 ? 128 : 256);
+}
+
+export function validatePhrase(phrase: string) {
+  return validateMnemonic(phrase, wordlist);
+}
+
+export async function decryptFromKeystore(keystore: Keystore, password: string) {
+  const { SwapKitError } = await import("@swapkit/helpers");
+
+  switch (keystore.version) {
+    case 1: {
+      const kdfParams = keystore.crypto.kdfparams;
+      const salt = Buffer.from(kdfParams.salt, "hex");
+      const derivedKey = pbkdf2Sync(password, salt, kdfParams.c, kdfParams.dklen, "sha256");
+
+      const ciphertext = Buffer.from(keystore.crypto.ciphertext, "hex");
+      const initData = Buffer.concat([derivedKey.subarray(16, 32), ciphertext]);
+      const mac = await blake256(initData);
+
+      if (mac !== keystore.crypto.mac) {
+        throw new SwapKitError("wallet_keystore_invalid_password");
+      }
+
+      const decipher = createDecipheriv(
+        keystore.crypto.cipher,
+        derivedKey.subarray(0, 16),
+        Buffer.from(keystore.crypto.cipherparams.iv, "hex"),
+      );
+
+      const phrase = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+      return phrase.toString("utf8");
+    }
+
+    default:
+      throw new SwapKitError("wallet_keystore_unsupported_version");
+  }
+}

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";