@swapkit/wallets 3.0.0-beta.0 → 3.0.0-beta.2

package/src/ledger/clients/evm.ts

@@ -5,13 +5,7 @@ import {
   NetworkDerivationPath,
   derivationPathToString,
 } from "@swapkit/helpers";
-import {
-  AbstractSigner,
-  type Provider,
-  Signature,
-  Transaction,
-  type TransactionRequest,
-} from "ethers";
+import { AbstractSigner, type Provider, type TransactionRequest } from "ethers";
 
 import { getLedgerTransport } from "../helpers/getLedgerTransport";
 
@@ -79,6 +73,7 @@ class EVMLedgerInterface extends AbstractSigner {
   };
 
   signMessage = async (messageHex: string) => {
+    const { Signature } = await import("ethers");
     await this.createTransportAndLedger();
 
     const sig = await this.ledgerApp?.signPersonalMessage(this.derivationPath, messageHex);
@@ -103,6 +98,7 @@ class EVMLedgerInterface extends AbstractSigner {
   }
 
   signTransaction = async (tx: TransactionRequest) => {
+    const { Transaction } = await import("ethers");
     await this.createTransportAndLedger();
 
     const transactionCount = await this.provider?.getTransactionCount(

package/src/ledger/clients/thorchain/lib.ts

@@ -1,4 +1,3 @@
-import crypto from "crypto";
 import type Transport from "@ledgerhq/hw-transport";
 /** ******************************************************************************
  *  (c) 2019 ZondaX GmbH
@@ -16,8 +15,6 @@ import type Transport from "@ledgerhq/hw-transport";
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  ******************************************************************************* */
-import { bech32 } from "@scure/base";
-import Ripemd160 from "ripemd160";
 
 import {
   CHUNK_SIZE,
@@ -61,22 +58,6 @@ export class THORChainApp {
     return buf;
   }
 
-  static getBech32FromPK(hrp: string, pk: Buffer) {
-    if (pk.length !== 33) {
-      throw new Error("expected compressed public key [31 bytes]");
-    }
-    // @ts-ignore
-    const hashSha256 = crypto.createHash("sha256").update(pk).digest();
-    // @ts-ignore
-    const hashRip = new Ripemd160().update(hashSha256).digest();
-    // @ts-ignore
-    const encode = bech32.encode || bech32.bech32.encode;
-    // @ts-ignore
-    const toWords = bech32.toWords || bech32.bech32.toWords;
-    // @ts-ignore
-    return encode(hrp, toWords(hashRip));
-  }
-
   async serializePath(path: number[]) {
     this.versionResponse = await getVersion(this.transport);
 

package/src/ledger/clients/utxo.ts

@@ -6,7 +6,8 @@ import {
   derivationPathToString,
   getWalletFormatFor,
 } from "@swapkit/helpers";
-import type { Psbt, UTXOType } from "@swapkit/toolboxes/utxo";
+import type { UTXOType } from "@swapkit/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
 
 import { getLedgerTransport } from "../helpers/getLedgerTransport";
 
@@ -21,7 +22,7 @@ const signUTXOTransaction = async (
   { psbt, inputUtxos, btcApp, derivationPath }: Params,
   options?: Partial<CreateTransactionArg>,
 ) => {
-  const { Transaction } = await import("@swapkit/toolboxes/utxo");
+  const { Transaction } = await import("bitcoinjs-lib");
 
   const inputs = inputUtxos.map((item) => {
     const utxoTx = Transaction.fromHex(item.txHex || "");

package/src/ledger/helpers/getLedgerClient.ts

@@ -10,7 +10,7 @@ import {
   OptimismLedger,
   PolygonLedger,
 } from "../clients/evm";
-import { THORChainLedger } from "../clients/thorchain/index";
+import { THORChainLedger } from "../clients/thorchain";
 import {
   BitcoinCashLedger,
   BitcoinLedger,
@@ -69,7 +69,7 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
     case Chain.Polygon:
     case Chain.Base: {
       const { getProvider } = await import("@swapkit/toolboxes/evm");
-      const params = { provider: getProvider(chain), derivationPath };
+      const params = { provider: await getProvider(chain), derivationPath };
 
       switch (chain) {
         case Chain.BinanceSmartChain:

package/src/ledger/index.ts

@@ -3,17 +3,18 @@ import {
   ChainId,
   type DerivationPathArray,
   FeeOption,
+  type GenericTransferParams,
   SKConfig,
   StagenetChain,
   WalletOption,
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { DepositParam, TransferParams } from "@swapkit/toolboxes/cosmos";
+import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
 import type { UTXOBuildTxParams } from "@swapkit/toolboxes/utxo";
 
-import { getWalletSupportedChains } from "../helpers";
-import { getLedgerAddress, getLedgerClient } from "./helpers/index";
+import { getWalletSupportedChains } from "../utils";
+import { getLedgerAddress, getLedgerClient } from "./helpers";
 
 export const ledgerWallet = createWallet({
   name: "connectLedger",
@@ -42,7 +43,7 @@ export const ledgerWallet = createWallet({
 
       const walletMethods = await getWalletMethods({ chain, derivationPath });
 
-      addChain({ ...walletMethods, chain, balance: [], walletType: WalletOption.LEDGER });
+      addChain({ ...walletMethods, chain, walletType: WalletOption.LEDGER });
 
       return true;
     },
@@ -97,9 +98,8 @@ async function getWalletMethods({
     case Chain.Dash:
     case Chain.Dogecoin:
     case Chain.Litecoin: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-
-      const toolbox = getToolboxByChain(chain)();
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const toolbox = await getUtxoToolbox(chain as Chain.Bitcoin);
 
       const signer = await getLedgerClient({ chain, derivationPath });
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
@@ -108,12 +108,12 @@ async function getWalletMethods({
         const feeRate = params.feeRate || (await toolbox.getFeeRates())[FeeOption.Average];
         const memo = [Chain.Bitcoin].includes(chain) ? params.memo : reduceMemo(params.memo);
 
-        const { psbt, inputs } = await toolbox.buildTx({
+        const { psbt, inputs } = await toolbox.createTransaction({
           ...params,
           feeRate,
-          fetchTxHex: true,
           memo,
           sender: address,
+          fetchTxHex: true,
         });
         const txHex = await signer.signTransaction(psbt, inputs);
         const tx = await toolbox.broadcastTx(txHex);
@@ -131,24 +131,23 @@ async function getWalletMethods({
     case Chain.Polygon:
     case Chain.BinanceSmartChain:
     case Chain.Base: {
-      const { getToolboxByChain, getProvider } = await import("@swapkit/toolboxes/evm");
+      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
       const signer = await getLedgerClient({ chain, derivationPath });
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
-      const provider = getProvider(chain);
-      const toolbox = getToolboxByChain(chain)({ signer, provider });
+      const toolbox = await getEvmToolbox(chain, { signer });
 
       return { ...toolbox, address };
     }
 
     case Chain.Cosmos: {
-      const { createSigningStargateClient, getMsgSendDenom, GaiaToolbox } = await import(
+      const { createSigningStargateClient, getMsgSendDenom, getCosmosToolbox } = await import(
         "@swapkit/toolboxes/cosmos"
       );
-      const toolbox = GaiaToolbox();
+      const toolbox = await getCosmosToolbox(Chain.Cosmos);
       const signer = await getLedgerClient({ chain, derivationPath });
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
 
-      const transfer = async ({ assetValue, recipient, memo }: TransferParams) => {
+      const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
         if (!assetValue) throw new Error("invalid asset");
 
         const sendCoinsMessage = {
@@ -188,13 +187,13 @@ async function getWalletMethods({
       const {
         createStargateClient,
         buildEncodedTxBody,
-        ThorchainToolbox,
+        getCosmosToolbox,
         buildAminoMsg,
         getDefaultChainFee,
         fromBase64,
         parseAminoMessageForDirectSigning,
       } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = ThorchainToolbox();
+      const toolbox = await getCosmosToolbox(chain);
       const signer = await getLedgerClient({ chain, derivationPath });
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
 
@@ -207,7 +206,7 @@ async function getWalletMethods({
         assetValue,
         ...rest
         // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Refactor to reduce complexity
-      }: TransferParams | DepositParam) => {
+      }: GenericTransferParams | ThorchainDepositParams) => {
         const account = await toolbox.getAccount(address);
         if (!account) throw new Error("invalid account");
         if (!assetValue) throw new Error("invalid asset");
@@ -217,7 +216,7 @@ async function getWalletMethods({
         const sequence = (sequenceNumber || 0).toString();
 
         const orderedMessages = recursivelyOrderKeys([
-          buildAminoMsg({ chain, from: address, assetValue, memo, ...rest }),
+          buildAminoMsg({ sender: address, assetValue, memo, ...rest }),
         ]);
 
         // get tx signing msg
@@ -262,8 +261,8 @@ async function getWalletMethods({
         return transactionHash;
       };
 
-      const transfer = (params: TransferParams) => thorchainTransfer(params);
-      const deposit = (params: DepositParam) => thorchainTransfer(params);
+      const transfer = (params: GenericTransferParams) => thorchainTransfer(params);
+      const deposit = (params: ThorchainDepositParams) => thorchainTransfer(params);
 
       return { ...toolbox, address, deposit, transfer, signMessage };
     }

package/src/ledger/types.ts

@@ -8,7 +8,7 @@ import type {
   OptimismLedger,
   PolygonLedger,
 } from "./clients/evm";
-import type { THORChainLedger } from "./clients/thorchain/index";
+import type { THORChainLedger } from "./clients/thorchain";
 import type {
   BitcoinCashLedger,
   BitcoinLedger,

package/src/okx/helpers.ts

@@ -6,8 +6,6 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { GaiaToolbox } from "@swapkit/toolboxes/cosmos";
-import type { BTCToolbox, Psbt, UTXOTransferParams } from "@swapkit/toolboxes/utxo";
 import type { Eip1193Provider } from "ethers";
 
 const cosmosTransfer =
@@ -24,7 +22,10 @@ const cosmosTransfer =
     const cosmJS = await createSigningStargateClient(SKConfig.get("rpcUrls").GAIA, offlineSigner);
 
     const coins = [
-      { denom: asset?.symbol === "MUON" ? "umuon" : "uatom", amount: amount.amount().toString() },
+      {
+        denom: asset?.symbol === "MUON" ? "umuon" : "uatom",
+        amount: amount.amount().toString(),
+      },
     ];
 
     const { transactionHash } = await cosmJS.sendTokens(from, recipient, coins, 1.6, memo);
@@ -35,14 +36,13 @@ async function getWeb3WalletMethods({
   walletProvider,
   chain,
 }: { walletProvider: Eip1193Provider | undefined; chain: EVMChain }) {
-  const { getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
   const { BrowserProvider } = await import("ethers");
   if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
 
   const provider = new BrowserProvider(walletProvider, "any");
   const signer = await provider.getSigner();
-
-  const toolbox = getToolboxByChain(chain)({ provider, signer });
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
 
   try {
     if (chain !== Chain.Ethereum && "getNetworkParams" in toolbox) {
@@ -55,15 +55,7 @@ async function getWeb3WalletMethods({
   return prepareNetworkSwitch({ toolbox, provider, chain });
 }
 
-export async function getWalletMethods(
-  chain: Chain,
-): Promise<
-  (
-    | ReturnType<typeof GaiaToolbox>
-    | Awaited<ReturnType<typeof getWeb3WalletMethods>>
-    | ReturnType<typeof BTCToolbox>
-  ) & { address: string }
-> {
+export async function getWalletMethods(chain: Chain) {
   switch (chain) {
     case Chain.Ethereum:
     case Chain.Base:
@@ -76,42 +68,40 @@ export async function getWalletMethods(
         throw new Error("No okxwallet found");
       }
 
-      const { getProvider } = await import("@swapkit/toolboxes/evm");
-
       const evmWallet = await getWeb3WalletMethods({
         chain,
         walletProvider: window.okxwallet,
       });
-
       const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
 
-      const getBalance = async (addressOverwrite?: string, potentialScamFilter = true) =>
-        evmWallet.getBalance(addressOverwrite || address, potentialScamFilter, getProvider(chain));
-
-      return { ...evmWallet, getBalance, address };
+      return { ...evmWallet, address };
     }
 
     case Chain.Bitcoin: {
       if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
         throw new Error("No bitcoin okxwallet found");
       }
-      const { Psbt, BTCToolbox } = await import("@swapkit/toolboxes/utxo");
+      const { Psbt } = await import("bitcoinjs-lib");
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
       const { bitcoin: wallet } = window.okxwallet;
       const address = (await wallet.connect()).address;
-      const toolbox = BTCToolbox();
 
-      const signTransaction = async (psbt: Psbt) => {
-        const signedPsbt = await wallet.signPsbt(psbt.toHex(), { from: address, type: "list" });
+      const signer = {
+        signTransaction: async (psbt: InstanceType<typeof Psbt>) => {
+          const signedPsbt = await wallet.signPsbt(psbt.toHex(), {
+            from: address,
+            type: "list",
+          });
 
-        return Psbt.fromHex(signedPsbt);
+          return Psbt.fromHex(signedPsbt);
+        },
+        getAddress: async () => Promise.resolve(address),
       };
 
-      const transfer = (transferParams: UTXOTransferParams) => {
-        return toolbox.transfer({ ...transferParams, signTransaction });
-      };
+      const toolbox = await getUtxoToolbox(chain, { signer });
 
-      return { ...toolbox, transfer, address };
+      return { ...toolbox, address };
     }
 
     case Chain.Cosmos: {
@@ -124,9 +114,9 @@ export async function getWalletMethods(
       const accounts = await wallet.getOfflineSignerOnlyAmino(ChainId.Cosmos).getAccounts();
       if (!accounts?.[0]) throw new Error("No cosmos account found");
 
-      const { GaiaToolbox } = await import("@swapkit/toolboxes/cosmos");
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
       const [{ address }] = accounts;
-      const toolbox = GaiaToolbox();
+      const toolbox = getCosmosToolbox(Chain.Cosmos);
 
       return { ...toolbox, address, transfer: cosmosTransfer() };
     }

package/src/okx/index.ts

@@ -1,10 +1,7 @@
-import type { StdSignDoc, StdSignature } from "@cosmjs/amino";
-import type { EthereumWindowProvider } from "@swapkit/helpers";
 import { Chain, WalletOption, createWallet, filterSupportedChains } from "@swapkit/helpers";
 
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 import { getWalletMethods } from "./helpers";
-import type { AminoSignResponse, OfflineAminoSigner } from "./types";
 
 export const okxWallet = createWallet({
   name: "connectOkx",
@@ -28,7 +25,9 @@ export const okxWallet = createWallet({
         filteredChains.map(async (chain) => {
           const walletMethods = await getWalletMethods(chain);
 
-          addChain({ ...walletMethods, chain, balance: [], walletType });
+          const address = (await walletMethods.getAddress()) || "";
+
+          addChain({ ...walletMethods, address, chain, walletType });
         }),
       );
 
@@ -37,45 +36,3 @@ export const okxWallet = createWallet({
 });
 
 export const OKX_SUPPORTED_CHAINS = getWalletSupportedChains(okxWallet);
-
-declare global {
-  interface Window {
-    okxwallet?:
-      | {
-          bitcoin: {
-            connect: () => Promise<{
-              address: string;
-              publicKey: string;
-            }>;
-            disconnect: () => Promise<void>;
-            signMessage: (message: string, { from }: { from: string }) => Promise<string>;
-            signPsbt: (
-              psbtHex: string,
-              { from, type }: { from: string; type: string },
-            ) => Promise<string>;
-          };
-          keplr: {
-            enable: (chainId: string | string[]) => Promise<void>;
-            signAmino: (
-              chainId: string,
-              signer: string,
-              signDoc: StdSignDoc,
-              signOptions: any,
-            ) => Promise<AminoSignResponse>;
-            signArbitrary: (
-              chainId: string,
-              signer: string,
-              data: string | Uint8Array,
-            ) => Promise<StdSignature>;
-            verifyArbitrary: (
-              chainId: string,
-              signer: string,
-              data: string | Uint8Array,
-              signature: StdSignature,
-            ) => Promise<boolean>;
-            getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
-          };
-        }
-      | EthereumWindowProvider;
-  }
-}

package/src/onekey/evmSigner.ts

@@ -0,0 +1,133 @@
+import type { Chain, DerivationPathArray } from "@swapkit/helpers";
+import { SwapKitError, WalletOption } from "@swapkit/helpers";
+import type { JsonRpcProvider, Provider, Signer, TypedDataDomain, TypedDataField } from "ethers";
+
+type OneKeyEVMSignerParams = {
+  chain: Chain;
+  derivationPath: DerivationPathArray;
+  provider: Provider | JsonRpcProvider;
+};
+
+export async function getEVMSigner({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
+  const { AbstractSigner, BrowserProvider } = await import("ethers");
+
+  class OneKeySigner extends AbstractSigner {
+    address: string;
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    readonly provider: Provider | JsonRpcProvider;
+
+    constructor({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
+      super(provider);
+
+      this.address = "";
+      this.chain = chain;
+      this.derivationPath = derivationPath;
+      this.provider = provider;
+    }
+
+    connect(provider: null | Provider): Signer {
+      if (!provider) {
+        throw new SwapKitError({
+          errorKey: "wallet_provider_not_found",
+          info: { wallet: WalletOption.ONEKEY, chain: this.chain },
+        });
+      }
+
+      return new OneKeySigner({
+        chain: this.chain,
+        derivationPath: this.derivationPath,
+        provider,
+      });
+    }
+
+    signTypedData(
+      domain: TypedDataDomain,
+      types: Record<string, TypedDataField[]>,
+      value: Record<string, any>,
+    ): Promise<string> {
+      if (!window.$onekey?.ethereum) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain: this.chain },
+        });
+      }
+
+      return this.getAddress().then(async (_address) => {
+        try {
+          const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+          return signer.signTypedData(domain, types, value);
+        } catch (error) {
+          throw new SwapKitError({
+            errorKey: "core_wallet_sign_message_not_supported",
+            info: { wallet: WalletOption.ONEKEY, error },
+          });
+        }
+      });
+    }
+
+    getAddress = async () => {
+      if (this.address) return this.address;
+
+      if (!window.$onekey?.ethereum) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain: this.chain },
+        });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      this.address = await signer.getAddress();
+      return this.address;
+    };
+
+    signMessage = async (message: string) => {
+      if (!window.$onekey?.ethereum) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain: this.chain },
+        });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      return signer.signMessage(message);
+    };
+
+    signTransaction = async (transaction: any) => {
+      if (!window.$onekey?.ethereum) {
+        throw new SwapKitError({
+          errorKey: "wallet_onekey_not_found",
+          info: { chain: this.chain },
+        });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      const { to, value, gasLimit, gasPrice, data, maxFeePerGas, maxPriorityFeePerGas } =
+        transaction;
+
+      if (!to) throw new SwapKitError("toolbox_evm_no_to_address");
+      if (!gasLimit) throw new SwapKitError("toolbox_evm_no_gas_price");
+
+      const tx: any = {
+        to,
+        data,
+        gasLimit,
+      };
+
+      if (value) {
+        tx.value = value;
+      }
+
+      if (maxFeePerGas && maxPriorityFeePerGas) {
+        tx.maxFeePerGas = maxFeePerGas;
+        tx.maxPriorityFeePerGas = maxPriorityFeePerGas;
+      } else if (gasPrice) {
+        tx.gasPrice = gasPrice;
+      }
+
+      return signer.signTransaction(tx);
+    };
+  }
+
+  return new OneKeySigner({ chain, derivationPath, provider });
+}