@swapkit/wallet-keystore 1.0.0-rc.0

package/package.json

@@ -0,0 +1,68 @@
+{
+  "author": "swapkit-oss-team",
+  "dependencies": {
+    "blakejs": "1.2.1",
+    "uuid": "9.0.0",
+    "@swapkit/types": "1.0.0-rc.0"
+  },
+  "description": "SwapKit Lib keystore",
+  "devDependencies": {
+    "@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.0",
+    "@swapkit/toolbox-cosmos": "1.0.0-rc.0",
+    "@swapkit/toolbox-evm": "1.0.0-rc.0",
+    "@swapkit/toolbox-utxo": "1.0.0-rc.0"
+  },
+  "eslintConfig": {
+    "extends": "../../../internal/eslint-config"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "homepage": "https://github.com/thorswap/SwapKit",
+  "license": "Apache-2.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.es.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.0",
+    "@swapkit/toolbox-cosmos": "1.0.0-rc.0",
+    "@swapkit/toolbox-evm": "1.0.0-rc.0",
+    "@swapkit/toolbox-utxo": "1.0.0-rc.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "react-native": "./src/index.ts",
+  "repository": "https://github.com/thorswap/SwapKit.git",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "1.0.0-rc.0",
+  "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'"
+  }
+}

package/src/helpers.ts

@@ -0,0 +1,156 @@
+import { entropyToMnemonic, 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';
+
+export type Keystore = {
+  crypto: {
+    cipher: string;
+    ciphertext: string;
+    cipherparams: {
+      iv: string;
+    };
+    kdf: string;
+    kdfparams: {
+      prf: string;
+      dklen: number;
+      salt: string;
+      c: number;
+    };
+    mac: string;
+  };
+  id: string;
+  version: number;
+  meta: string;
+};
+
+/**
+ * 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('');
+
+/**
+ * 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');
+  }
+  const context = blake2bInit(32);
+  blake2bUpdate(context, data);
+  return toHex(blake2bFinal(context));
+};
+
+const pbkdf2Async = async (
+  passphrase: string | Buffer | NodeJS.TypedArray | DataView,
+  salt: string | Buffer | NodeJS.TypedArray | DataView,
+  iterations: number,
+  keylen: number,
+  digest: string,
+) => {
+  return new Promise<Buffer>((resolve, reject) => {
+    crypto.pbkdf2(passphrase, salt, iterations, keylen, digest, (err, drived) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(drived);
+      }
+    });
+  });
+};
+
+const _isNode = () => {
+  return typeof window === 'undefined';
+};
+
+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 derivedKey = await pbkdf2Async(
+    Buffer.from(password),
+    salt,
+    kdfParams.c,
+    kdfParams.dklen,
+    hashFunction,
+  );
+  const cipherIV = crypto.createCipheriv(cipher, derivedKey.slice(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,
+    version: 1,
+    meta: meta,
+  };
+
+  return keystore;
+};
+
+export const generatePhrase = (size = 12) => {
+  const entropy = size === 12 ? 128 : 256;
+  if (_isNode()) {
+    return entropyToMnemonic(crypto.randomBytes(entropy / 8), wordlist);
+  } else {
+    return generateMnemonic(wordlist, entropy);
+  }
+};
+
+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,
+  );
+
+  const ciphertext = Buffer.from(keystore.crypto.ciphertext, 'hex');
+  const mac = blake256(Buffer.concat([derivedKey.slice(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'),
+  );
+
+  const phrase = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return phrase.toString('utf8');
+};

package/src/index.ts

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

package/src/keystore.ts

@@ -0,0 +1,249 @@
+import type { DepositParam, TransferParams } from '@swapkit/toolbox-cosmos';
+import type {
+  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';
+
+type KeystoreOptions = {
+  ethplorerApiKey?: string;
+  utxoApiKey?: string;
+  covalentApiKey?: string;
+  stagenet?: boolean;
+};
+
+type Params = KeystoreOptions & {
+  api?: any;
+  rpcUrl?: string;
+  chain: Chain;
+  phrase: string;
+  index: number;
+};
+
+const getWalletMethodsForChain = async ({
+  api,
+  rpcUrl,
+  chain,
+  phrase,
+  ethplorerApiKey,
+  covalentApiKey,
+  utxoApiKey,
+  index,
+  stagenet,
+}: Params) => {
+  const derivationPath = `${DerivationPath[chain]}/${index}`;
+
+  switch (chain) {
+    case Chain.BinanceSmartChain:
+    case Chain.Avalanche:
+    case Chain.Ethereum: {
+      if (chain === Chain.Ethereum && !ethplorerApiKey) {
+        throw new Error('Ethplorer API key not found');
+      } else if (!covalentApiKey) {
+        throw new Error('Covalent API key not found');
+      }
+
+      const { HDNodeWallet } = await import('ethers');
+      const { getProvider, ETHToolbox, AVAXToolbox, BSCToolbox } = 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! });
+
+      return {
+        address: wallet.address,
+        walletMethods: {
+          ...toolbox,
+          getAddress: () => wallet.address,
+        },
+      };
+    }
+
+    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 keys = await toolbox.createKeysForPath({ phrase, derivationPath });
+      const address = toolbox.getAddressFromKeys(keys);
+
+      const signTransaction = async ({
+        builder,
+        utxos,
+      }: Awaited<ReturnType<typeof toolbox.buildBCHTx>>) => {
+        utxos.forEach((utxo, index) => {
+          builder.sign(index, keys, undefined, 0x41, (utxo.witnessUtxo as Witness).value);
+        });
+
+        return builder.build();
+      };
+
+      const walletMethods = {
+        ...toolbox,
+        getAddress: () => address,
+        transfer: (
+          params: UTXOWalletTransferParams<
+            Awaited<ReturnType<typeof toolbox.buildBCHTx>>,
+            TransactionType
+          >,
+        ) => toolbox.transfer({ ...params, from: address, signTransaction }),
+      };
+
+      return { address, walletMethods };
+    }
+
+    case Chain.Bitcoin:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      const params = { rpcUrl, apiKey: utxoApiKey, apiClient: api };
+
+      const { BTCToolbox, LTCToolbox, DOGEToolbox } = await import('@swapkit/toolbox-utxo');
+
+      const toolbox =
+        chain === Chain.Bitcoin
+          ? BTCToolbox(params)
+          : chain === Chain.Litecoin
+          ? LTCToolbox(params)
+          : DOGEToolbox(params);
+
+      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 }),
+        },
+      };
+    }
+
+    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,
+        });
+
+      return {
+        address,
+        walletMethods: { ...toolbox, transfer, getAddress: () => address },
+      };
+    }
+
+    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) =>
+        toolbox.transfer({
+          from: address,
+          recipient,
+          signer,
+          assetValue,
+          memo,
+        });
+
+      return {
+        address,
+        walletMethods: { ...toolbox, transfer, getAddress: () => address },
+      };
+    }
+
+    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,
+        });
+
+      const deposit = async ({ assetValue, memo }: DepositParam) => {
+        return toolbox.deposit({ assetValue, memo, from: address, signer });
+      };
+
+      const walletMethods = { ...toolbox, deposit, transfer, getAddress: () => address };
+
+      return { address, walletMethods };
+    }
+
+    default:
+      throw new Error(`Unsupported chain ${chain}`);
+  }
+};
+
+const connectKeystore =
+  ({
+    addChain,
+    apis,
+    rpcUrls,
+    config: { covalentApiKey, ethplorerApiKey, utxoApiKey, stagenet },
+  }: ConnectWalletParams) =>
+  async (chains: Chain[], phrase: string, index: number = 0) => {
+    const promises = chains.map(async (chain) => {
+      const { address, walletMethods } = await getWalletMethodsForChain({
+        index,
+        chain,
+        api: apis[chain as Chain.Avalanche],
+        rpcUrl: rpcUrls[chain],
+        covalentApiKey,
+        ethplorerApiKey,
+        phrase,
+        utxoApiKey,
+        stagenet,
+      });
+
+      addChain({
+        chain,
+        walletMethods,
+        wallet: { address, balance: [], walletType: WalletOption.KEYSTORE },
+      });
+    });
+
+    await Promise.all(promises);
+
+    return true;
+  };
+
+export const keystoreWallet = {
+  connectMethodName: 'connectKeystore' as const,
+  connect: connectKeystore,
+};