@swapkit/wallet-keystore 1.0.0-rc.13 → 1.0.0-rc.131

package/package.json

@@ -1,38 +1,17 @@
 {
-  "author": "swapkit-oss-team",
   "dependencies": {
-    "crypto-js": "4.2.0",
-    "blakejs": "1.2.1",
-    "uuid": "9.0.0",
-    "@swapkit/types": "1.0.0-rc.5"
+    "@scure/bip39": "1.3.0",
+    "@swapkit/helpers": "1.0.0-rc.96",
+    "blakejs": "1.2.1"
   },
-  "description": "SwapKit Lib keystore",
+  "description": "SwapKit Wallet - Keystore",
   "devDependencies": {
     "@rollup/plugin-node-resolve": "15.2.3",
-    "@scure/bip39": "1.2.1",
-    "@types/long": "4.0.2",
-    "@types/uniqid": "5.3.2",
-    "@types/uuid": "9.0.3",
-    "@vitest/coverage-istanbul": "0.34.4",
-    "bitcoinjs-lib": "5.2.0",
-    "ethers": "6.7.1",
-    "vite": "4.4.9",
-    "vitest": "0.34.4",
-    "@internal/config": "0.0.0-internal.0",
-    "@swapkit/helpers": "1.0.0-rc.7",
-    "@swapkit/toolbox-cosmos": "1.0.0-rc.9",
-    "@swapkit/toolbox-evm": "1.0.0-rc.8",
-    "@swapkit/toolbox-utxo": "1.0.0-rc.8"
-  },
-  "eslintConfig": {
-    "extends": "../../../internal/eslint-config"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.es.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
-    }
+    "@swapkit/toolbox-cosmos": "1.0.0-rc.117",
+    "@swapkit/toolbox-evm": "1.0.0-rc.102",
+    "@swapkit/toolbox-substrate": "1.0.0-rc.31",
+    "@swapkit/toolbox-utxo": "1.0.0-rc.105",
+    "bun-types": "1.1.2"
   },
   "files": [
     "src/",
@@ -40,31 +19,31 @@
   ],
   "homepage": "https://github.com/thorswap/SwapKit",
   "license": "Apache-2.0",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.es.js",
+  "main": "./dist/index.js",
   "name": "@swapkit/wallet-keystore",
   "peerDependencies": {
-    "@scure/bip39": "1.2.1",
-    "ethers": "^6.7.1",
-    "bitcoinjs-lib": "^5.2.0",
-    "@swapkit/helpers": "1.0.0-rc.7",
-    "@swapkit/toolbox-cosmos": "1.0.0-rc.9",
-    "@swapkit/toolbox-evm": "1.0.0-rc.8",
-    "@swapkit/toolbox-utxo": "1.0.0-rc.8"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@scure/bip39": "1.3.0",
+    "@swapkit/helpers": "1.0.0-rc.96",
+    "@swapkit/toolbox-cosmos": "1.0.0-rc.117",
+    "@swapkit/toolbox-evm": "1.0.0-rc.102",
+    "@swapkit/toolbox-substrate": "1.0.0-rc.31",
+    "@swapkit/toolbox-utxo": "1.0.0-rc.105",
+    "blakejs": "1.2.1"
   },
   "react-native": "./src/index.ts",
-  "repository": "https://github.com/thorswap/SwapKit.git",
-  "type": "module",
-  "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.13",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thorswap/SwapKit.git"
+  },
   "scripts": {
-    "build": "vite build",
-    "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",
-    "lint": "eslint ./ --ext .ts,.tsx --fix; tsc --noEmit",
-    "test": "echo 'vitest --run'",
-    "test:coverage": "echo 'vitest run --coverage'"
-  }
-}
+    "build": "bun run ./build.ts",
+    "clean": "rm -rf .turbo dist node_modules *.tsbuildinfo",
+    "lint": "biome check --apply ./src",
+    "test": "echo 'bun test'",
+    "test:coverage": "echo 'bun test --coverage'",
+    "type-check": "tsc --noEmit"
+  },
+  "type": "module",
+  "types": "./src/index.ts",
+  "version": "1.0.0-rc.131"
+}

package/src/helpers.ts

@@ -1,16 +1,7 @@
-import { generateMnemonic } from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { blake2bFinal, blake2bInit, blake2bUpdate } from 'blakejs';
-import crypto from 'crypto';
-import { v4 as uuidv4 } from 'uuid';
-
-const cipher = 'aes-128-ctr';
-const kdf = 'pbkdf2';
-const prf = 'hmac-sha256';
-const dklen = 32;
-const c = 262144;
-const hashFunction = 'sha256';
-const meta = 'xchain-keystore';
+import crypto from "node:crypto";
+import { generateMnemonic, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { blake2bFinal, blake2bInit, blake2bUpdate } from "blakejs";
 
 export type Keystore = {
   crypto: {
@@ -28,7 +19,6 @@ export type Keystore = {
     };
     mac: string;
   };
-  id: string;
   version: number;
   meta: string;
 };
@@ -36,114 +26,106 @@ export type Keystore = {
 /**
  * taken from `foundry-primitives` and modified
  */
-const toHexByte = (byte: number) => (byte < 0x10 ? `0${byte.toString(16)}` : byte.toString(16));
-const toHex = (buffer: Buffer | Uint8Array) => Array.from(buffer).map(toHexByte).join('');
-const _isNode = () => typeof window === 'undefined';
+const blake256 = (initData: Buffer | string): string => {
+  let data = initData;
 
-/**
- * Gets data's 256 bit blake hash.
- * @param data buffer or hexadecimal string
- * @returns 32 byte hexadecimal string
- */
-export const blake256 = (data: Buffer | string): string => {
   if (!(data instanceof Buffer)) {
-    data = Buffer.from(data, 'hex');
+    data = Buffer.from(data, "hex");
   }
+
   const context = blake2bInit(32);
   blake2bUpdate(context, data);
-  return toHex(blake2bFinal(context));
+
+  return Array.from(blake2bFinal(context))
+    .map((byte) => (byte < 0x10 ? `0${byte.toString(16)}` : byte.toString(16)))
+    .join("");
 };
 
-const pbkdf2Async = async (
-  passphrase: string | Buffer | NodeJS.TypedArray | DataView,
-  salt: string | Buffer | NodeJS.TypedArray | DataView,
+const pbkdf2Async = (
+  passphrase: string | Buffer,
+  salt: string | Buffer,
   iterations: number,
   keylen: number,
   digest: string,
-) => {
-  return new Promise<Buffer>((resolve, reject) => {
-    crypto.pbkdf2(passphrase, salt, iterations, keylen, digest, (err: any, drived: any) => {
-      if (err) {
-        reject(err);
+) =>
+  new Promise<Buffer>((resolve, reject) => {
+    crypto.pbkdf2(passphrase, salt, iterations, keylen, digest, (error, drived) => {
+      if (error) {
+        reject(error);
       } else {
         resolve(drived);
       }
     });
   });
-};
 
 export const encryptToKeyStore = async (phrase: string, password: string) => {
-  const ID = _isNode() ? require('uuid').v4() : uuidv4();
   const salt = crypto.randomBytes(32);
   const iv = crypto.randomBytes(16);
-  const kdfParams = {
-    prf,
-    dklen,
-    salt: salt.toString('hex'),
-    c,
-  };
-  const cipherParams = {
-    iv: iv.toString('hex'),
-  };
+  const kdfParams = { c: 262144, prf: "hmac-sha256", dklen: 32, salt: salt.toString("hex") };
+  const cipher = "aes-128-ctr";
 
   const derivedKey = await pbkdf2Async(
     Buffer.from(password),
     salt,
     kdfParams.c,
     kdfParams.dklen,
-    hashFunction,
+    "sha256",
   );
-  const cipherIV = crypto.createCipheriv(cipher, derivedKey.slice(0, 16), iv);
-  const cipherText = Buffer.concat([
-    cipherIV.update(Buffer.from(phrase, 'utf8')),
+  const cipherIV = crypto.createCipheriv(cipher, derivedKey.subarray(0, 16), iv);
+  const ciphertext = Buffer.concat([
+    cipherIV.update(Buffer.from(phrase, "utf8")),
     cipherIV.final(),
   ]);
-  const mac = blake256(Buffer.concat([derivedKey.slice(16, 32), Buffer.from(cipherText)]));
-
-  const cryptoStruct = {
-    cipher: cipher,
-    ciphertext: cipherText.toString('hex'),
-    cipherparams: cipherParams,
-    kdf: kdf,
-    kdfparams: kdfParams,
-    mac: mac,
-  };
 
-  const keystore = {
-    crypto: cryptoStruct,
-    id: ID,
+  return {
+    meta: "xchain-keystore",
     version: 1,
-    meta: meta,
+    crypto: {
+      cipher,
+      cipherparams: { iv: iv.toString("hex") },
+      ciphertext: ciphertext.toString("hex"),
+      kdf: "pbkdf2",
+      kdfparams: kdfParams,
+      mac: blake256(Buffer.concat([derivedKey.subarray(16, 32), Buffer.from(ciphertext)])),
+    },
   };
+};
 
-  return keystore;
+export const generatePhrase = (size: 12 | 24 = 12) => {
+  return generateMnemonic(wordlist, size === 12 ? 128 : 256);
 };
 
-export const generatePhrase = (size = 12) => {
-  const entropy = size === 12 ? 128 : 256;
-  return generateMnemonic(wordlist, entropy);
+export const validatePhrase = (phrase: string) => {
+  return validateMnemonic(phrase, wordlist);
 };
 
 export const decryptFromKeystore = async (keystore: Keystore, password: string) => {
-  const kdfparams = keystore.crypto.kdfparams;
-  const derivedKey = await pbkdf2Async(
-    Buffer.from(password),
-    Buffer.from(kdfparams.salt, 'hex'),
-    kdfparams.c,
-    kdfparams.dklen,
-    hashFunction,
-  );
+  switch (keystore.version) {
+    case 1: {
+      const kdfparams = keystore.crypto.kdfparams;
+      const derivedKey = await pbkdf2Async(
+        Buffer.from(password),
+        Buffer.from(kdfparams.salt, "hex"),
+        kdfparams.c,
+        kdfparams.dklen,
+        "sha256",
+      );
 
-  const ciphertext = Buffer.from(keystore.crypto.ciphertext, 'hex');
-  const mac = blake256(Buffer.concat([derivedKey.slice(16, 32), ciphertext]));
+      const ciphertext = Buffer.from(keystore.crypto.ciphertext, "hex");
+      const mac = blake256(Buffer.concat([derivedKey.subarray(16, 32), ciphertext]));
 
-  if (mac !== keystore.crypto.mac) throw new Error('Invalid password');
-  const decipher = crypto.createDecipheriv(
-    keystore.crypto.cipher,
-    derivedKey.slice(0, 16),
-    Buffer.from(keystore.crypto.cipherparams.iv, 'hex'),
-  );
+      if (mac !== keystore.crypto.mac) throw new Error("Invalid password");
+      const decipher = crypto.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");
+    }
 
-  const phrase = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  return phrase.toString('utf8');
+    default:
+      throw new Error("Unsupported keystore version");
+  }
 };

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from './helpers.ts';
-export { keystoreWallet } from './keystore.ts';
+export * from "./helpers.ts";
+export { keystoreWallet } from "./keystore.ts";

package/src/keystore.ts

@@ -1,22 +1,33 @@
-import type { DepositParam, TransferParams } from '@swapkit/toolbox-cosmos';
+import {
+  Chain,
+  type ConnectWalletParams,
+  DerivationPath,
+  WalletOption,
+  type Witness,
+  setRequestClientConfig,
+} from "@swapkit/helpers";
 import type {
+  BinanceToolboxType,
+  DepositParam,
+  ThorchainToolboxType,
+  TransferParams,
+} from "@swapkit/toolbox-cosmos";
+import type {
+  Psbt,
   TransactionType,
   UTXOTransferParams,
   UTXOWalletTransferParams,
-} from '@swapkit/toolbox-utxo';
-import type { ConnectWalletParams, Witness } from '@swapkit/types';
-import { Chain, DerivationPath, WalletOption } from '@swapkit/types';
-import type { Psbt } from 'bitcoinjs-lib';
+} from "@swapkit/toolbox-utxo";
 
 type KeystoreOptions = {
   ethplorerApiKey?: string;
-  utxoApiKey?: string;
+  blockchairApiKey?: string;
   covalentApiKey?: string;
   stagenet?: boolean;
 };
 
 type Params = KeystoreOptions & {
-  api?: any;
+  api?: Todo;
   rpcUrl?: string;
   chain: Chain;
   phrase: string;
@@ -30,51 +41,51 @@ const getWalletMethodsForChain = async ({
   phrase,
   ethplorerApiKey,
   covalentApiKey,
-  utxoApiKey,
+  blockchairApiKey,
   index,
   stagenet,
 }: Params) => {
-  const derivationPath = `${DerivationPath[chain]}/${index}`;
+  const derivationPath = `${DerivationPath[chain] as string}/${index}`;
 
   switch (chain) {
     case Chain.BinanceSmartChain:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
     case Chain.Avalanche:
     case Chain.Ethereum: {
       if (chain === Chain.Ethereum && !ethplorerApiKey) {
-        throw new Error('Ethplorer API key not found');
+        throw new Error("Ethplorer API key not found");
+        // biome-ignore lint/style/noUselessElse: This is a valid use case
       } else if (!covalentApiKey) {
-        throw new Error('Covalent API key not found');
+        throw new Error("Covalent API key not found");
       }
 
-      const { HDNodeWallet } = await import('ethers');
-      const { getProvider, ETHToolbox, AVAXToolbox, BSCToolbox } = await import(
-        '@swapkit/toolbox-evm'
-      );
+      const { HDNodeWallet, getProvider, getToolboxByChain } = await import("@swapkit/toolbox-evm");
 
       const provider = getProvider(chain, rpcUrl);
       const wallet = HDNodeWallet.fromPhrase(phrase).connect(provider);
       const params = { api, provider, signer: wallet };
 
-      const toolbox =
-        chain === Chain.Ethereum
-          ? ETHToolbox({ ...params, ethplorerApiKey: ethplorerApiKey! })
-          : chain === Chain.Avalanche
-          ? AVAXToolbox({ ...params, covalentApiKey: covalentApiKey! })
-          : BSCToolbox({ ...params, covalentApiKey: covalentApiKey! });
+      const toolbox = getToolboxByChain(chain)({
+        ...params,
+        covalentApiKey,
+        ethplorerApiKey: ethplorerApiKey as string,
+      });
 
       return {
         address: wallet.address,
-        walletMethods: {
-          ...toolbox,
-          getAddress: () => wallet.address,
-        },
+        walletMethods: { ...toolbox },
       };
     }
 
     case Chain.BitcoinCash: {
-      if (!utxoApiKey) throw new Error('UTXO API key not found');
-      const { BCHToolbox } = await import('@swapkit/toolbox-utxo');
-      const toolbox = BCHToolbox({ rpcUrl, apiKey: utxoApiKey, apiClient: api });
+      const { BCHToolbox } = await import("@swapkit/toolbox-utxo");
+      const toolbox = BCHToolbox({
+        rpcUrl,
+        apiKey: blockchairApiKey,
+        apiClient: api,
+      });
       const keys = await toolbox.createKeysForPath({ phrase, derivationPath });
       const address = toolbox.getAddressFromKeys(keys);
 
@@ -91,7 +102,6 @@ const getWalletMethodsForChain = async ({
 
       const walletMethods = {
         ...toolbox,
-        getAddress: () => address,
         transfer: (
           params: UTXOWalletTransferParams<
             Awaited<ReturnType<typeof toolbox.buildBCHTx>>,
@@ -104,126 +114,100 @@ const getWalletMethodsForChain = async ({
     }
 
     case Chain.Bitcoin:
+    case Chain.Dash:
     case Chain.Dogecoin:
     case Chain.Litecoin: {
-      const params = { rpcUrl, apiKey: utxoApiKey, apiClient: api };
+      const { getToolboxByChain } = await import("@swapkit/toolbox-utxo");
 
-      const { BTCToolbox, LTCToolbox, DOGEToolbox } = await import('@swapkit/toolbox-utxo');
-
-      const toolbox =
-        chain === Chain.Bitcoin
-          ? BTCToolbox(params)
-          : chain === Chain.Litecoin
-          ? LTCToolbox(params)
-          : DOGEToolbox(params);
+      const toolbox = getToolboxByChain(chain)({
+        rpcUrl,
+        apiKey: blockchairApiKey,
+        apiClient: api,
+      });
 
       const keys = await toolbox.createKeysForPath({ phrase, derivationPath });
       const address = toolbox.getAddressFromKeys(keys);
 
-      const signTransaction = async (psbt: Psbt) => {
-        psbt.signAllInputs(keys);
-
-        return psbt;
-      };
-
       return {
         address,
         walletMethods: {
           ...toolbox,
-          getAddress: () => address,
           transfer: (params: UTXOTransferParams) =>
-            toolbox.transfer({ ...params, from: address, signTransaction }),
+            toolbox.transfer({
+              ...params,
+              from: address,
+              signTransaction: (psbt: Psbt) => {
+                psbt.signAllInputs(keys);
+                return psbt;
+              },
+            }),
         },
       };
     }
 
-    case Chain.Binance: {
-      const { BinanceToolbox } = await import('@swapkit/toolbox-cosmos');
-      const toolbox = BinanceToolbox();
-      const privkey = await toolbox.createKeyPair(phrase);
-      const address = await toolbox.getAddressFromMnemonic(phrase);
-
-      const transfer = ({ assetValue, recipient, memo }: TransferParams) =>
-        toolbox.transfer({
-          from: address,
-          recipient,
-          assetValue,
-          privkey,
-          memo,
-        });
+    case Chain.Binance:
+    case Chain.Cosmos:
+    case Chain.Kujira:
+    case Chain.Maya:
+    case Chain.THORChain: {
+      const { getToolboxByChain } = await import("@swapkit/toolbox-cosmos");
 
-      return {
-        address,
-        walletMethods: { ...toolbox, transfer, getAddress: () => address },
-      };
-    }
+      const toolbox = getToolboxByChain(chain)({ server: api, stagenet });
+      const additionalParams =
+        chain === Chain.Binance
+          ? {
+              privkey: await (toolbox as BinanceToolboxType).createPrivateKeyFromPhrase(phrase),
+            }
+          : { signer: await toolbox.getSigner(phrase) };
 
-    case Chain.Cosmos: {
-      const { GaiaToolbox } = await import('@swapkit/toolbox-cosmos');
-      const toolbox = GaiaToolbox({ server: api });
-      const signer = await toolbox.getSigner(phrase);
       const address = await toolbox.getAddressFromMnemonic(phrase);
 
-      const transfer = ({ assetValue, recipient, memo }: TransferParams) =>
+      const transfer = async ({ assetValue, recipient, memo }: TransferParams) =>
         toolbox.transfer({
           from: address,
           recipient,
-          signer,
           assetValue,
           memo,
+          ...additionalParams,
         });
 
-      return {
-        address,
-        walletMethods: { ...toolbox, transfer, getAddress: () => address },
+      const deposit =
+        "deposit" in toolbox
+          ? ({ assetValue, memo }: DepositParam) => {
+              return (toolbox as ThorchainToolboxType).deposit({
+                assetValue,
+                memo,
+                from: address,
+                ...additionalParams,
+              });
+            }
+          : undefined;
+
+      const signMessage = async (message: string) => {
+        const privateKey = await toolbox.createPrivateKeyFromPhrase(phrase);
+        return (toolbox as ThorchainToolboxType).signMessage(privateKey, message);
       };
-    }
-
-    case Chain.Kujira: {
-      const { KujiraToolbox } = await import('@swapkit/toolbox-cosmos');
-      const toolbox = KujiraToolbox({ server: api });
-      const signer = await toolbox.getSigner(phrase);
-      const address = await toolbox.getAddressFromMnemonic(phrase);
-
-      const transfer = ({ assetValue, recipient, memo }: TransferParams) =>
-        toolbox.transfer({
-          from: address,
-          recipient,
-          signer,
-          assetValue,
-          memo,
-        });
 
-      return {
-        address,
-        walletMethods: { ...toolbox, transfer, getAddress: () => address },
+      const walletMethods = {
+        ...toolbox,
+        deposit,
+        transfer,
+        signMessage,
       };
-    }
-
-    case Chain.Maya:
-    case Chain.THORChain: {
-      const { MayaToolbox, ThorchainToolbox } = await import('@swapkit/toolbox-cosmos');
-      const toolbox =
-        chain === Chain.THORChain ? ThorchainToolbox({ stagenet }) : MayaToolbox({ stagenet });
-      const address = await toolbox.getAddressFromMnemonic(phrase);
-      const signer = await toolbox.getSigner(phrase);
 
-      const transfer = async ({ assetValue, recipient, memo }: TransferParams) =>
-        toolbox.transfer({
-          from: address,
-          recipient,
-          signer,
-          assetValue,
-          memo,
-        });
+      return { address, walletMethods };
+    }
 
-      const deposit = async ({ assetValue, memo }: DepositParam) => {
-        return toolbox.deposit({ assetValue, memo, from: address, signer });
-      };
+    case Chain.Polkadot:
+    case Chain.Chainflip: {
+      const { Network, getToolboxByChain, createKeyring } = await import(
+        "@swapkit/toolbox-substrate"
+      );
 
-      const walletMethods = { ...toolbox, deposit, transfer, getAddress: () => address };
+      const signer = await createKeyring(phrase, Network[chain].prefix);
+      const toolbox = await getToolboxByChain(chain, { signer });
 
-      return { address, walletMethods };
+      return { address: signer.address, walletMethods: toolbox };
     }
 
     default:
@@ -231,14 +215,15 @@ const getWalletMethodsForChain = async ({
   }
 };
 
-const connectKeystore =
-  ({
-    addChain,
-    apis,
-    rpcUrls,
-    config: { covalentApiKey, ethplorerApiKey, utxoApiKey, stagenet },
-  }: ConnectWalletParams) =>
-  async (chains: Chain[], phrase: string, index: number = 0) => {
+function connectKeystore({
+  addChain,
+  apis,
+  rpcUrls,
+  config: { thorswapApiKey, covalentApiKey, ethplorerApiKey, blockchairApiKey, stagenet },
+}: ConnectWalletParams) {
+  return async function connectKeystore(chains: Chain[], phrase: string, index = 0) {
+    setRequestClientConfig({ apiKey: thorswapApiKey });
+
     const promises = chains.map(async (chain) => {
       const { address, walletMethods } = await getWalletMethodsForChain({
         index,
@@ -248,14 +233,16 @@ const connectKeystore =
         covalentApiKey,
         ethplorerApiKey,
         phrase,
-        utxoApiKey,
+        blockchairApiKey,
         stagenet,
       });
 
       addChain({
         chain,
-        walletMethods,
-        wallet: { address, balance: [], walletType: WalletOption.KEYSTORE },
+        address,
+        balance: [],
+        walletType: WalletOption.KEYSTORE,
+        ...walletMethods,
       });
     });
 
@@ -263,8 +250,6 @@ const connectKeystore =
 
     return true;
   };
+}
 
-export const keystoreWallet = {
-  connectMethodName: 'connectKeystore' as const,
-  connect: connectKeystore,
-};
+export const keystoreWallet = { connectKeystore } as const;