@swapkit/toolboxes 1.0.0-beta.0 → 1.0.0-beta.10

package/src/cosmos/toolbox/thorchain.ts

@@ -1,49 +1,50 @@
 import type { Pubkey, Secp256k1HdWallet } from "@cosmjs/amino";
-import type { Account } from "@cosmjs/stargate";
 import { base64 } from "@scure/base";
 import {
   BaseDecimal,
   Chain,
-  type ChainId,
   CosmosChainPrefixes,
-  DerivationPath,
   FeeOption,
+  type GenericTransferParams,
+  NetworkDerivationPath,
   RequestClient,
   SKConfig,
-  SwapKitError,
   SwapKitNumber,
+  derivationPathToString,
+  updateDerivationPath,
 } from "@swapkit/helpers";
 
+import { P, match } from "ts-pattern";
 import {
   buildAminoMsg,
-  buildDepositTx,
   buildEncodedTxBody,
-  buildTransferTx,
   convertToSignable,
   createDefaultAminoTypes,
   createDefaultRegistry,
+  getCreateTransaction,
   parseAminoMessageForDirectSigning,
-} from "../thorchainUtils/index";
-import type {
-  DepositParam,
-  ThorchainConstantsResponse,
-} from "../thorchainUtils/types/client-types";
-import type { Signer, TransferParams } from "../types";
+} from "../thorchainUtils";
+import type { ThorchainConstantsResponse } from "../thorchainUtils/types/client-types";
+import type { MultisigTx } from "../types";
+import type { CosmosToolboxParams, MultiSigSigner } from "../types";
 import {
   createOfflineStargateClient,
   createSigningStargateClient,
   createStargateClient,
   getDefaultChainFee,
 } from "../util";
-import { BaseCosmosToolbox } from "./BaseCosmosToolbox";
+import { createCosmosToolbox } from "./cosmos";
 
 function secp256k1HdWalletFromMnemonic({
   prefix,
   derivationPath,
-}: { prefix: string; derivationPath: string }) {
+}: {
+  prefix: string;
+  derivationPath?: string;
+}) {
   return async function secp256k1HdWalletFromMnemonic(mnemonic: string, index = 0) {
-    const { Secp256k1HdWallet } = await import("@cosmjs/amino");
-    const { stringToPath } = await import("@cosmjs/crypto");
+    const { Secp256k1HdWallet } = (await import("@cosmjs/amino")).default;
+    const { stringToPath } = (await import("@cosmjs/crypto")).default;
 
     return Secp256k1HdWallet.fromMnemonic(mnemonic, {
       hdPaths: [stringToPath(`${derivationPath}/${index}`)],
@@ -56,65 +57,65 @@ function exportSignature(signature: Uint8Array) {
   return base64.encode(signature);
 }
 
-async function signMultisigTx(
-  wallet: Secp256k1HdWallet,
-  tx: string,
-  chain: Chain.THORChain | Chain.Maya,
-) {
-  const {
-    msgs,
-    accountNumber,
-    sequence,
-    chainId,
-    fee,
-    memo,
+function signMultisigTx(chain: Chain.THORChain | Chain.Maya) {
+  return async function signMultisigTx({
+    wallet,
+    tx,
   }: {
-    msgs: ReturnType<typeof buildAminoMsg>[];
-    accountNumber: number;
-    sequence: number;
-    chainId: ChainId;
-    fee: ReturnType<typeof getDefaultChainFee>;
-    memo: string;
-  } = JSON.parse(tx);
-
-  const address = (await wallet.getAccounts())?.[0]?.address || "";
-  const aminoTypes = await createDefaultAminoTypes(chain);
-  const registry = await createDefaultRegistry();
-  const signingClient = await createOfflineStargateClient(wallet, { registry, aminoTypes });
-  const msgForSigning = [];
-
-  for (const msg of msgs) {
-    const signMsg = await convertToSignable(msg, chain);
-    msgForSigning.push(signMsg);
-  }
+    wallet: Secp256k1HdWallet;
+    tx: string | MultisigTx;
+  }) {
+    const { msgs, accountNumber, sequence, chainId, fee, memo } =
+      typeof tx === "string" ? JSON.parse(tx) : tx;
 
-  const {
-    signatures: [signature],
-  } = await signingClient.sign(address, msgForSigning, fee, memo, {
-    accountNumber,
-    sequence,
-    chainId,
-  });
+    const address = (await wallet.getAccounts())?.[0]?.address || "";
+    const aminoTypes = await createDefaultAminoTypes(chain);
+    const registry = await createDefaultRegistry();
+    const signingClient = await createOfflineStargateClient(wallet, {
+      registry,
+      aminoTypes,
+    });
+    const msgForSigning = [];
 
-  const bodyBytes = await buildEncodedTxBody({
-    chain,
-    memo,
-    msgs: msgs.map(parseAminoMessageForDirectSigning),
-  });
+    for (const msg of msgs) {
+      const signMsg = await convertToSignable(msg, chain);
+      msgForSigning.push(signMsg);
+    }
+
+    const {
+      signatures: [signature],
+    } = await signingClient.sign(address, msgForSigning, fee, memo, {
+      accountNumber,
+      sequence,
+      chainId,
+    });
+
+    const bodyBytes = await buildEncodedTxBody({
+      chain,
+      memo,
+      msgs: msgs.map(parseAminoMessageForDirectSigning),
+    });
 
-  return { signature: exportSignature(signature as Uint8Array), bodyBytes };
+    return { signature: exportSignature(signature as Uint8Array), bodyBytes };
+  };
 }
 
-function broadcastMultisigTx({ prefix, rpcUrl }: { prefix: string; rpcUrl: string }) {
+function broadcastMultisigTx({
+  prefix,
+  rpcUrl,
+}: {
+  prefix: string;
+  rpcUrl: string;
+}) {
   return async function broadcastMultisigTx(
     tx: string,
-    signers: Signer[],
+    signers: MultiSigSigner[],
     membersPubKeys: string[],
     threshold: number,
     bodyBytes: Uint8Array,
   ) {
-    const { encodeSecp256k1Pubkey, pubkeyToAddress } = await import("@cosmjs/amino");
-    const { makeMultisignedTxBytes } = await import("@cosmjs/stargate");
+    const { encodeSecp256k1Pubkey, pubkeyToAddress } = (await import("@cosmjs/amino")).default;
+    const { makeMultisignedTxBytes } = (await import("@cosmjs/stargate")).default;
 
     const { sequence, fee } = JSON.parse(tx);
     const multisigPubkey = await createMultisig(membersPubKeys, threshold);
@@ -141,7 +142,8 @@ function broadcastMultisigTx({ prefix, rpcUrl }: { prefix: string; rpcUrl: strin
 }
 
 async function createMultisig(pubKeys: string[], threshold: number, noSortPubKeys = true) {
-  const { createMultisigThresholdPubkey, encodeSecp256k1Pubkey } = await import("@cosmjs/amino");
+  const { createMultisigThresholdPubkey, encodeSecp256k1Pubkey } = (await import("@cosmjs/amino"))
+    .default;
   return createMultisigThresholdPubkey(
     pubKeys.map((pubKey) => encodeSecp256k1Pubkey(base64.decode(pubKey))),
     threshold,
@@ -156,51 +158,46 @@ function importSignature(signature: string) {
 async function signWithPrivateKey({
   privateKey,
   message,
-}: { privateKey: Uint8Array; message: string }) {
-  const { Secp256k1 } = await import("@cosmjs/crypto");
+}: {
+  privateKey: Uint8Array;
+  message: string;
+}) {
+  const { Secp256k1 } = (await import("@cosmjs/crypto")).default;
 
   const signature = await Secp256k1.createSignature(base64.decode(message), privateKey);
   return base64.encode(Buffer.concat([signature.r(32), signature.s(32)]));
 }
 
-function verifySignature(getAccount: (address: string) => Promise<Account | null>) {
-  return async function verifySignature({
-    signature,
-    message,
-    address,
-  }: {
-    signature: string;
-    message: string;
-    address: string;
-  }) {
-    const account = await getAccount(address);
-    if (!account?.pubkey) throw new SwapKitError("toolbox_cosmos_verify_signature_no_pubkey");
-    const { Secp256k1Signature, Secp256k1 } = await import("@cosmjs/crypto");
-
-    const secpSignature = Secp256k1Signature.fromFixedLength(base64.decode(signature));
-    return Secp256k1.verifySignature(secpSignature, base64.decode(message), account.pubkey.value);
-  };
-}
-
-export function BaseThorchainToolbox(chain: Chain.THORChain | Chain.Maya) {
+export async function createThorchainToolbox({
+  chain,
+  ...toolboxParams
+}: CosmosToolboxParams<Chain.THORChain | Chain.Maya>) {
   const nodeUrl = SKConfig.get("nodeUrls")[chain];
   const rpcUrl = SKConfig.get("rpcUrls")[chain];
   const { isStagenet } = SKConfig.get("envs");
-
   const isThorchain = chain === Chain.THORChain;
   const chainPrefix = `${isStagenet ? "s" : ""}${CosmosChainPrefixes[chain]}`;
-  const derivationPath = DerivationPath[chain];
 
-  const cosmosToolbox = BaseCosmosToolbox({ chain, derivationPath, prefix: chainPrefix });
-  const defaultFee = getDefaultChainFee(chain);
+  const index = "index" in toolboxParams ? toolboxParams.index || 0 : 0;
 
-  function loadAddressBalances(address: string) {
-    try {
-      return cosmosToolbox.getBalance(address);
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
+  const derivationPath =
+    "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[chain], { index });
+
+  const cosmosToolbox = await createCosmosToolbox({
+    chain,
+    ...toolboxParams,
+  });
+
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, ({ phrase }) =>
+      cosmosToolbox.getSignerFromPhrase({ phrase, derivationPath }),
+    )
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  const defaultFee = getDefaultChainFee(chain);
 
   async function getFees() {
     let fee: SwapKitNumber;
@@ -218,21 +215,23 @@ export function BaseThorchainToolbox(chain: Chain.THORChain | Chain.Maya) {
 
       fee = new SwapKitNumber(nativeFee);
     } catch {
-      fee = new SwapKitNumber({ value: isThorchain ? 0.02 : 1, decimal: BaseDecimal[chain] });
+      fee = new SwapKitNumber({
+        value: isThorchain ? 0.02 : 1,
+        decimal: BaseDecimal[chain],
+      });
     }
 
     return { [FeeOption.Average]: fee, [FeeOption.Fast]: fee, [FeeOption.Fastest]: fee };
   }
 
   async function transfer({
-    from,
-    recipient,
     assetValue,
     memo = "",
-    signer,
-  }: Omit<TransferParams, "recipient"> & { recipient?: string }) {
+    recipient,
+  }: Omit<GenericTransferParams, "recipient"> & { recipient?: string }) {
     const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx");
-    if (!signer) throw new Error("Signer not defined");
+    const sender = (await signer?.getAccounts())?.[0]?.address;
+    if (!(sender && signer)) throw new Error("Signer not defined");
 
     const isAminoSigner = "signAmino" in signer;
     const registry = await createDefaultRegistry();
@@ -242,13 +241,18 @@ export function BaseThorchainToolbox(chain: Chain.THORChain | Chain.Maya) {
       aminoTypes,
     });
 
-    const aminoMessage = buildAminoMsg({ assetValue, from, recipient, memo, chain });
+    const aminoMessage = buildAminoMsg({
+      assetValue,
+      sender,
+      recipient,
+      memo,
+    });
 
     if (isAminoSigner) {
       const msgSign = await convertToSignable(aminoMessage, chain);
 
       const { signatures, authInfoBytes } = await signingClient.sign(
-        from,
+        sender,
         [msgSign],
         defaultFee,
         memo,
@@ -271,51 +275,35 @@ export function BaseThorchainToolbox(chain: Chain.THORChain | Chain.Maya) {
 
     const preparedMessage = parseAminoMessageForDirectSigning(aminoMessage);
     const msgSign = await convertToSignable(preparedMessage, chain);
-    const txResponse = await signingClient.signAndBroadcast(from, [msgSign], defaultFee, memo);
+    const txResponse = await signingClient.signAndBroadcast(sender, [msgSign], defaultFee, memo);
 
     return txResponse.transactionHash;
   }
 
   return {
     ...cosmosToolbox,
-    deposit: (params: DepositParam & { from: string }) => transfer(params),
-    pubkeyToAddress: async (pubkey: Pubkey) => {
-      const { pubkeyToAddress } = await import("@cosmjs/amino");
-      return pubkeyToAddress(pubkey, chainPrefix);
-    },
-    transfer,
-    getFees,
+    broadcastMultisigTx: broadcastMultisigTx({ prefix: chainPrefix, rpcUrl }),
     buildAminoMsg,
-    convertToSignable,
-    buildDepositTx: buildDepositTx(rpcUrl),
-    buildTransferTx: buildTransferTx(rpcUrl),
     buildEncodedTxBody,
-    parseAminoMessageForDirectSigning,
+    convertToSignable,
     createDefaultAminoTypes: () => createDefaultAminoTypes(chain),
     createDefaultRegistry,
+    createMultisig,
+    createTransaction: getCreateTransaction(rpcUrl),
+    deposit: transfer,
+    getFees,
+    importSignature,
+    parseAminoMessageForDirectSigning,
     secp256k1HdWalletFromMnemonic: secp256k1HdWalletFromMnemonic({
-      derivationPath,
+      derivationPath: derivationPathToString(derivationPath),
       prefix: chainPrefix,
     }),
-    signMultisigTx: (wallet: Secp256k1HdWallet, tx: string) => signMultisigTx(wallet, tx, chain),
-    broadcastMultisigTx: broadcastMultisigTx({ prefix: chainPrefix, rpcUrl }),
-    createMultisig,
-    importSignature,
-    loadAddressBalances,
+    signMultisigTx: signMultisigTx(chain),
     signWithPrivateKey,
-    verifySignature: verifySignature(cosmosToolbox.getAccount),
+    transfer,
+    pubkeyToAddress: async (pubkey: Pubkey) => {
+      const { pubkeyToAddress } = (await import("@cosmjs/amino")).default;
+      return pubkeyToAddress(pubkey, chainPrefix);
+    },
   };
 }
-
-export function ThorchainToolbox() {
-  return BaseThorchainToolbox(Chain.THORChain);
-}
-
-export function MayaToolbox() {
-  return BaseThorchainToolbox(Chain.Maya);
-}
-
-export type ThorchainWallet = Omit<ReturnType<typeof BaseThorchainToolbox>, "signMessage">;
-export type ThorchainWallets = {
-  [chain in Chain.THORChain | Chain.Maya]: ThorchainWallet;
-};

package/src/cosmos/types.ts

@@ -1,6 +1,10 @@
-import type { OfflineAminoSigner, StdFee } from "@cosmjs/amino";
-import type { OfflineDirectSigner } from "@cosmjs/proto-signing";
-import type { AssetValue, ChainId, FeeOption } from "@swapkit/helpers";
+import type { OfflineAminoSigner } from "@cosmjs/amino";
+import type { DirectSecp256k1HdWallet, OfflineDirectSigner } from "@cosmjs/proto-signing";
+import type { Chain, ChainId, CosmosChain, DerivationPathArray } from "@swapkit/helpers";
+import type { buildAminoMsg } from "./thorchainUtils";
+import type { createCosmosToolbox } from "./toolbox/cosmos";
+import type { createThorchainToolbox } from "./toolbox/thorchain";
+import type { getDefaultChainFee } from "./util";
 
 export type CosmosSDKClientParams = {
   server: string;
@@ -9,23 +13,38 @@ export type CosmosSDKClientParams = {
   stagenet?: boolean;
 };
 
-export type TransferParams = {
-  assetValue: AssetValue;
-  fee?: StdFee | number;
-  feeOptionKey?: FeeOption;
-  from: string;
-  memo?: string;
-  privkey?: Uint8Array;
-  recipient: string;
-  signer?: OfflineDirectSigner | OfflineAminoSigner;
+export type MultiSigSigner = {
+  pubKey: string;
+  signature: string;
 };
 
-export type ToolboxParams = {
-  rpcUrl?: string;
-  prefix?: string;
+export type MultisigTx = {
+  msgs: ReturnType<typeof buildAminoMsg>[];
+  accountNumber: number;
+  sequence: number;
+  chainId: ChainId;
+  fee: ReturnType<typeof getDefaultChainFee>;
+  memo: string;
 };
 
-export type Signer = {
-  pubKey: string;
-  signature: string;
+export type CosmosSigner = DirectSecp256k1HdWallet | OfflineDirectSigner | OfflineAminoSigner;
+
+export type CosmosToolboxParams<T = CosmosChain> = {
+  chain: T;
+} & (
+  | { signer?: CosmosSigner }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+);
+
+export type BaseCosmosToolboxType = ReturnType<typeof createCosmosToolbox>;
+export type BaseCosmosWallet = Awaited<ReturnType<typeof createCosmosToolbox>>;
+export type CosmosWallets = {
+  [chain in Chain.Cosmos | Chain.Kujira]: BaseCosmosWallet;
+};
+
+export type ThorchainWallet = Awaited<
+  Omit<ReturnType<typeof createThorchainToolbox>, "signMessage">
+>;
+export type ThorchainWallets = {
+  [chain in Chain.THORChain | Chain.Maya]: ThorchainWallet;
 };

package/src/cosmos/util.ts

@@ -1,16 +1,8 @@
 import type { OfflineSigner } from "@cosmjs/proto-signing";
 import type { SigningStargateClientOptions } from "@cosmjs/stargate";
-import {
-  AssetValue,
-  Chain,
-  ChainId,
-  type CosmosChain,
-  SKConfig,
-  defaultRequestHeaders,
-  getGasAsset,
-} from "@swapkit/helpers";
-
-import type { CosmosNativeTransferTxParams } from "./thorchainUtils";
+import { AssetValue, Chain, ChainId, type CosmosChain, SKConfig } from "@swapkit/helpers";
+
+import type { CosmosCreateTransactionParams } from "./thorchainUtils";
 
 export const USK_KUJIRA_FACTORY_DENOM =
   "FACTORY/KUJIRA1QK00H5ATUTPSV900X202PXX42NPJR9THG58DNQPA72F2P7M2LUASE444A7/UUSK";
@@ -76,55 +68,10 @@ export const getDenomWithChain = ({ symbol, chain }: AssetValue) => {
   return getMsgSendDenom(symbol, false);
 };
 
-// TODO: figure out some better way to initialize from base value
-export const getAssetFromDenom = (denom: string, amount: string) => {
-  switch (denom) {
-    case "rune":
-      return AssetValue.from({
-        chain: Chain.THORChain,
-        value: Number.parseInt(amount) / 1e8,
-      });
-    case "uatom":
-    case "atom":
-      return AssetValue.from({
-        chain: Chain.Cosmos,
-        value: Number.parseInt(amount) / 1e6,
-      });
-    case "cacao":
-      return AssetValue.from({
-        chain: Chain.Maya,
-        value: Number.parseInt(amount) / 1e10,
-      });
-    case "maya":
-      return AssetValue.from({
-        asset: `${Chain.Maya}.${Chain.Maya}`,
-        value: Number.parseInt(amount) / 1e4,
-      });
-    case "ukuji":
-    case "kuji":
-      return AssetValue.from({
-        chain: Chain.Kujira,
-        value: Number.parseInt(amount) / 1e6,
-      });
-    case USK_KUJIRA_FACTORY_DENOM:
-      // USK on Kujira
-      return AssetValue.from({
-        asset: `${Chain.Kujira}.USK`,
-        value: Number.parseInt(amount) / 1e6,
-      });
-
-    default:
-      return AssetValue.from({
-        asset: denom,
-        value: Number.parseInt(amount) / 1e8,
-      });
-  }
-};
-
 export async function createStargateClient(url: string) {
-  const { StargateClient } = await import("@cosmjs/stargate");
+  const { StargateClient } = (await import("@cosmjs/stargate")).default;
 
-  return StargateClient.connect({ url, headers: defaultRequestHeaders });
+  return StargateClient.connect(url);
 }
 
 export async function createSigningStargateClient(
@@ -132,11 +79,11 @@ export async function createSigningStargateClient(
   signer: any,
   optionsOrBaseGas: string | SigningStargateClientOptions = {},
 ) {
-  const { SigningStargateClient, GasPrice } = await import("@cosmjs/stargate");
+  const { SigningStargateClient, GasPrice } = (await import("@cosmjs/stargate")).default;
   const gasPrice = typeof optionsOrBaseGas === "string" ? optionsOrBaseGas : "0.0003uatom";
   const options = typeof optionsOrBaseGas === "string" ? {} : optionsOrBaseGas;
 
-  return SigningStargateClient.connectWithSigner({ url, headers: defaultRequestHeaders }, signer, {
+  return SigningStargateClient.connectWithSigner(url, signer, {
     gasPrice: GasPrice.fromString(gasPrice),
     ...options,
   });
@@ -146,7 +93,7 @@ export async function createOfflineStargateClient(
   wallet: OfflineSigner,
   registry?: SigningStargateClientOptions,
 ) {
-  const { SigningStargateClient } = await import("@cosmjs/stargate");
+  const { SigningStargateClient } = (await import("@cosmjs/stargate")).default;
 
   return SigningStargateClient.offline(wallet, registry);
 }
@@ -186,45 +133,48 @@ const getTransferMsgTypeByChain = (chain: CosmosChain) => {
 /**
  * Used to build tx for Cosmos and Kujira
  */
-export const buildNativeTransferTx = async ({
-  fromAddress,
-  toAddress,
+export const cosmosCreateTransaction = async ({
+  sender,
+  recipient,
   assetValue,
   memo = "",
-  fee,
-}: CosmosNativeTransferTxParams) => {
+  feeRate,
+  sequence,
+  accountNumber,
+}: CosmosCreateTransactionParams) => {
   const { chain, chainId } = assetValue;
 
   const url = getRPC(chainId);
   const client = await createStargateClient(url);
-  const accountOnChain = await client.getAccount(fromAddress);
+  const accountOnChain = await client.getAccount(sender);
 
   if (!accountOnChain) {
     throw new Error("Account does not exist");
   }
 
-  const feeAsset = getMsgSendDenom(getGasAsset({ chain }).symbol);
+  const gasAsset = AssetValue.from({ chain });
+  const feeAsset = getMsgSendDenom(gasAsset.symbol);
   const defaultFee = getDefaultChainFee(chain as CosmosChain);
 
   const txFee =
-    feeAsset && fee
-      ? { amount: [{ denom: feeAsset, amount: fee }], gas: defaultFee.gas }
+    feeAsset && feeRate
+      ? { amount: [{ denom: feeAsset, amount: feeRate.toString() }], gas: defaultFee.gas }
       : defaultFee;
 
   const msgSend = {
-    fromAddress,
-    toAddress,
+    fromAddress: sender,
+    toAddress: recipient,
     amount: [
       { amount: assetValue.getBaseValue("string"), denom: getMsgSendDenom(assetValue.symbol) },
     ],
   };
 
   return {
-    accountNumber: accountOnChain.accountNumber,
+    accountNumber: accountNumber ?? accountOnChain.accountNumber,
     chainId,
     fee: txFee,
     memo,
-    sequence: accountOnChain.sequence,
+    sequence: sequence ?? accountOnChain.sequence,
     msgs: [{ typeUrl: getTransferMsgTypeByChain(chain as CosmosChain), value: msgSend }],
   };
 };