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

package/src/cosmos/thorchainUtils/messages.ts

@@ -9,7 +9,7 @@ import {
 } from "../util";
 
 import { createDefaultAminoTypes, createDefaultRegistry } from "./registry";
-import type { ThorchainDepositTxParams, ThorchainTransferTxParams } from "./types/client-types";
+import type { ThorchainCreateTransactionParams } from "./types";
 
 type MsgSend = ReturnType<typeof transferMsgAmino>;
 type MsgDeposit = ReturnType<typeof depositMsgAmino>;
@@ -22,40 +22,40 @@ export const THORCHAIN_GAS_VALUE = getDefaultChainFee(Chain.THORChain).gas;
 export const MAYA_GAS_VALUE = getDefaultChainFee(Chain.Maya).gas;
 
 export const transferMsgAmino = ({
-  from,
+  sender,
   recipient,
   assetValue,
-  chain,
 }: {
-  from: string;
+  sender: string;
   recipient?: string;
   assetValue: AssetValue;
-  chain: Chain.THORChain | Chain.Maya;
-}) => ({
-  type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgSend` as const,
-  value: {
-    from_address: from,
-    to_address: recipient,
-    amount: [
-      {
-        amount: assetValue.getBaseValue("string"),
-        denom: getMsgSendDenom(assetValue.symbol, true),
-      },
-    ],
-  },
-});
+}) => {
+  const chain = assetValue.chain as Chain.THORChain | Chain.Maya;
+  return {
+    type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgSend` as const,
+    value: {
+      from_address: sender,
+      to_address: recipient,
+      amount: [
+        {
+          amount: assetValue.getBaseValue("string"),
+          denom: getMsgSendDenom(assetValue.symbol, true),
+        },
+      ],
+    },
+  };
+};
 
 export const depositMsgAmino = ({
-  from,
+  sender,
   assetValue,
   memo = "",
-  chain,
 }: {
-  from: string;
+  sender: string;
   assetValue: AssetValue;
   memo?: string;
-  chain: Chain.THORChain | Chain.Maya;
 }) => {
+  const chain = assetValue.chain as Chain.THORChain | Chain.Maya;
   return {
     type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgDeposit` as const,
     value: {
@@ -65,36 +65,33 @@ export const depositMsgAmino = ({
           asset: getDenomWithChain(assetValue),
         },
       ],
-      signer: from,
+      signer: sender,
       memo,
     },
   };
 };
 
 export const buildAminoMsg = ({
-  from,
+  sender,
   recipient,
   assetValue,
   memo,
-  chain,
 }: {
-  from: string;
+  sender: string;
   recipient?: string;
   assetValue: AssetValue;
   memo?: string;
-  chain: Chain.THORChain | Chain.Maya;
 }) => {
   const isDeposit = !recipient;
   const msg = isDeposit
-    ? depositMsgAmino({ from, assetValue, memo, chain })
-    : transferMsgAmino({ from, recipient, assetValue, chain });
+    ? depositMsgAmino({ sender, assetValue, memo })
+    : transferMsgAmino({ sender, recipient, assetValue });
 
   return msg;
 };
 
-// TODO I think the msg typing is wrong it should be not prepared for broadcast
 export const convertToSignable = async (
-  msg: DirectMsgDepositForBroadcast | DirectMsgSendForBroadcast | MsgSend | MsgDeposit,
+  msg: MsgSend | MsgDeposit,
   chain: Chain.THORChain | Chain.Maya,
 ) => {
   const aminoTypes = await createDefaultAminoTypes(chain);
@@ -102,16 +99,9 @@ export const convertToSignable = async (
   return aminoTypes.fromAmino(msg);
 };
 
-const getAccount = async ({
-  rpcUrl,
-  from,
-}: {
-  from: string;
-  rpcUrl: string;
-}) => {
+const getAccount = async ({ rpcUrl, sender }: { sender: string; rpcUrl: string }) => {
   const client = await createStargateClient(rpcUrl);
-
-  const account = await client.getAccount(from);
+  const account = await client.getAccount(sender);
 
   if (!account) {
     throw new Error("Account does not exist");
@@ -120,24 +110,50 @@ const getAccount = async ({
   return account;
 };
 
+export function getCreateTransaction(rpcUrl: string) {
+  return function createTransaction(params: ThorchainCreateTransactionParams) {
+    const { assetValue, recipient, memo, sender, asSignable, asAminoMessage } = params;
+
+    if (recipient) {
+      return buildTransferTx(rpcUrl)({
+        sender,
+        recipient,
+        assetValue,
+        memo,
+        asSignable,
+        asAminoMessage,
+      });
+    }
+
+    return buildDepositTx(rpcUrl)({
+      sender,
+      assetValue,
+      memo,
+      asSignable,
+      asAminoMessage,
+    });
+  };
+}
+
 export const buildTransferTx =
   (rpcUrl: string) =>
   async ({
-    from,
+    sender,
     recipient,
     assetValue,
     memo = "",
-    chain,
     asSignable = true,
     asAminoMessage = false,
-  }: ThorchainTransferTxParams) => {
-    const account = await getAccount({ rpcUrl, from });
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as Chain.THORChain | Chain.Maya;
 
     const transferMsg = transferMsgAmino({
-      from,
+      sender,
       recipient,
       assetValue,
-      chain,
     });
 
     const msg = asSignable
@@ -149,8 +165,8 @@ export const buildTransferTx =
 
     const transaction = {
       chainId: ChainToChainId[chain],
-      accountNumber: account.accountNumber,
-      sequence: account.sequence,
+      accountNumber: accountNumber || account.accountNumber,
+      sequence: sequence || account.sequence,
       msgs: [msg],
       fee: getDefaultChainFee(assetValue.chain as Chain.THORChain | Chain.Maya),
       memo,
@@ -162,16 +178,18 @@ export const buildTransferTx =
 export const buildDepositTx =
   (rpcUrl: string) =>
   async ({
-    from,
+    sender,
     assetValue,
     memo = "",
-    chain,
     asSignable = true,
     asAminoMessage = false,
-  }: ThorchainDepositTxParams) => {
-    const account = await getAccount({ rpcUrl, from });
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as Chain.THORChain | Chain.Maya;
 
-    const depositMsg = depositMsgAmino({ from, assetValue, memo, chain });
+    const depositMsg = depositMsgAmino({ sender, assetValue, memo });
 
     const msg = asSignable
       ? await convertToSignable(
@@ -182,8 +200,8 @@ export const buildDepositTx =
 
     const transaction = {
       chainId: ChainToChainId[chain],
-      accountNumber: account.accountNumber,
-      sequence: account.sequence,
+      accountNumber: accountNumber || account.accountNumber,
+      sequence: sequence || account.sequence,
       msgs: [msg],
       fee: getDefaultChainFee(assetValue.chain as Chain.THORChain | Chain.Maya),
       memo,
@@ -214,7 +232,7 @@ export function parseAminoMessageForDirectSigning<T extends MsgDeposit | MsgSend
           asset: {
             chain,
             symbol,
-            ticker: symbol,
+            ticker: assetValue.ticker,
             synth: assetValue.isSynthetic,
           },
         };

package/src/cosmos/thorchainUtils/registry.ts

@@ -1,47 +1,40 @@
 import { Chain } from "@swapkit/helpers";
-import * as types from "../thorchainUtils/types/proto/MsgCompiled";
 import { base64ToBech32, bech32ToBase64 } from "./addressFormat";
 
 export async function createDefaultRegistry() {
-  const { Registry } = await import("@cosmjs/proto-signing");
-  const { defaultRegistryTypes } = await import("@cosmjs/stargate");
+  const { $root } = await import("./types/MsgCompiled");
+  const { Registry } = (await import("@cosmjs/proto-signing")).default;
+  const { defaultRegistryTypes } = (await import("@cosmjs/stargate")).default;
 
   return new Registry([
     ...defaultRegistryTypes,
-    ["/types.MsgSend", { ...types.default.types.MsgSend }],
-    ["/types.MsgDeposit", { ...types.default.types.MsgDeposit }],
+    ["/types.MsgSend", $root.types.MsgSend],
+    ["/types.MsgDeposit", $root.types.MsgDeposit],
   ]);
 }
 
 export async function createDefaultAminoTypes(chain: Chain.THORChain | Chain.Maya) {
-  const { AminoTypes } = await import("@cosmjs/stargate");
+  const { AminoTypes } = (await import("@cosmjs/stargate")).default;
+  const aminoTypePrefix = chain === Chain.THORChain ? "thorchain" : "mayachain";
 
   return new AminoTypes({
     "/types.MsgSend": {
-      aminoType: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgSend`,
-      toAmino: (params: any) => ({
-        from_address: base64ToBech32(params.fromAddress),
-        to_address: base64ToBech32(params.toAddress),
-        amount: [...params.amount],
+      aminoType: `${aminoTypePrefix}/MsgSend`,
+      toAmino: ({ fromAddress, toAddress, ...rest }: any) => ({
+        ...rest,
+        from_address: base64ToBech32(fromAddress),
+        to_address: base64ToBech32(toAddress),
       }),
-      fromAmino: (params: any) => ({
-        fromAddress: bech32ToBase64(params.from_address),
-        toAddress: bech32ToBase64(params.to_address),
-        amount: [...params.amount],
+      fromAmino: ({ from_address, to_address, ...rest }: any) => ({
+        ...rest,
+        fromAddress: bech32ToBase64(from_address),
+        toAddress: bech32ToBase64(to_address),
       }),
     },
     "/types.MsgDeposit": {
-      aminoType: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgDeposit`,
-      toAmino: (params: any) => ({
-        signer: base64ToBech32(params.signer),
-        memo: params.memo,
-        coins: [...params.coins],
-      }),
-      fromAmino: (params: any) => ({
-        signer: bech32ToBase64(params.signer),
-        memo: params.memo,
-        coins: [...params.coins],
-      }),
+      aminoType: `${aminoTypePrefix}/MsgDeposit`,
+      toAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: base64ToBech32(signer) }),
+      fromAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: bech32ToBase64(signer) }),
     },
   });
 }

package/src/cosmos/thorchainUtils/types/{proto/MsgCompiled.ts → MsgCompiled.ts}

@@ -8,7 +8,7 @@ const $util = $protobuf.util;
 
 // Exported root namespace
 
-const $root = ($protobuf.roots["default"] || ($protobuf.roots["default"] = {})) as any;
+export const $root = ($protobuf.roots.default || ($protobuf.roots.default = {})) as any;
 
 $root.common = (() => {
   /**
@@ -2798,5 +2798,3 @@ $root.cosmos = (() => {
 
   return cosmos;
 })();
-
-export default $root;

package/src/cosmos/thorchainUtils/types/client-types.ts

@@ -1,6 +1,10 @@
-import type { OfflineAminoSigner } from "@cosmjs/amino";
-import type { EncodeObject, OfflineDirectSigner } from "@cosmjs/proto-signing";
-import type { Asset, AssetValue, Chain, ChainId } from "@swapkit/helpers";
+import type { EncodeObject } from "@cosmjs/proto-signing";
+import type {
+  Asset,
+  ChainId,
+  GenericCreateTransactionParams,
+  GenericTransferParams,
+} from "@swapkit/helpers";
 
 enum TxType {
   Transfer = "transfer",
@@ -21,13 +25,6 @@ export type NodeUrl = {
   rpc: string;
 };
 
-export type DepositParam = {
-  signer?: OfflineDirectSigner | OfflineAminoSigner;
-  walletIndex?: number;
-  assetValue: AssetValue;
-  memo: string;
-};
-
 export type TxData = Pick<Tx, "from" | "to" | "type">;
 
 /**
@@ -59,22 +56,18 @@ export type TransferTransaction = {
   fee: { amount: { denom: string; amount: string }[]; gas: string };
 };
 
-export type CosmosNativeTransferTxParams = {
-  fromAddress: string;
-  toAddress: string;
-  assetValue: AssetValue;
-  memo?: string;
-  fee?: string;
+export type CosmosCreateTransactionParams = GenericCreateTransactionParams & {
+  accountNumber?: number;
+  sequence?: number;
 };
 
-export type ThorchainTransferTxParams = {
-  from: string;
-  recipient: string;
-  assetValue: AssetValue;
-  memo?: string;
-  chain: Chain.THORChain | Chain.Maya;
+export type ThorchainCreateTransactionParams = Omit<
+  CosmosCreateTransactionParams,
+  "feeRate" | "recipient"
+> & {
+  recipient?: string;
   asSignable?: boolean;
   asAminoMessage?: boolean;
 };
 
-export type ThorchainDepositTxParams = Omit<ThorchainTransferTxParams, "recipient">;
+export type ThorchainDepositParams = Omit<GenericTransferParams, "recipient">;