@uswap/toolboxes 4.3.6

package/src/cosmos/thorchainUtils/messages.ts

@@ -0,0 +1,212 @@
+import type { TxBodyEncodeObject } from "@cosmjs/proto-signing";
+import { AssetValue, Chain, getChainConfig, SwapKitError, type TCLikeChain } from "@uswap/helpers";
+
+import { createStargateClient, getDefaultChainFee, getDenomWithChain, getMsgSendDenom } from "../util";
+
+import { createDefaultAminoTypes, createDefaultRegistry } from "./registry";
+import type { ThorchainCreateTransactionParams } from "./types";
+
+type MsgSend = ReturnType<typeof transferMsgAmino>;
+type MsgDeposit = ReturnType<typeof depositMsgAmino>;
+type DirectMsgSendForBroadcast = ReturnType<typeof parseAminoMessageForDirectSigning<MsgSend>>;
+type DirectMsgDepositForBroadcast = ReturnType<typeof parseAminoMessageForDirectSigning<MsgDeposit>>;
+
+export const THORCHAIN_GAS_VALUE = getDefaultChainFee(Chain.THORChain).gas;
+export const MAYA_GAS_VALUE = getDefaultChainFee(Chain.Maya).gas;
+
+export const transferMsgAmino = ({
+  sender,
+  recipient,
+  assetValue,
+}: {
+  sender: string;
+  recipient?: string;
+  assetValue: AssetValue;
+}) => {
+  const chain = assetValue.chain as typeof Chain.THORChain | typeof Chain.Maya;
+  return {
+    type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgSend` as const,
+    value: {
+      amount: [{ amount: assetValue.getBaseValue("string"), denom: getMsgSendDenom(assetValue.symbol, true) }],
+      from_address: sender,
+      to_address: recipient,
+    },
+  };
+};
+
+export const depositMsgAmino = ({
+  sender,
+  assetValue,
+  memo = "",
+}: {
+  sender: string;
+  assetValue: AssetValue;
+  memo?: string;
+}) => {
+  const chain = assetValue.chain as TCLikeChain;
+  return {
+    type: `${chain === Chain.Maya ? "mayachain" : "thorchain"}/MsgDeposit` as const,
+    value: {
+      coins: [{ amount: assetValue.getBaseValue("string"), asset: getDenomWithChain(assetValue) }],
+      memo,
+      signer: sender,
+    },
+  };
+};
+
+export const buildAminoMsg = ({
+  sender,
+  recipient,
+  assetValue,
+  memo,
+}: {
+  sender: string;
+  recipient?: string;
+  assetValue: AssetValue;
+  memo?: string;
+}) => {
+  const isDeposit = !recipient;
+  const msg = isDeposit
+    ? depositMsgAmino({ assetValue, memo, sender })
+    : transferMsgAmino({ assetValue, recipient, sender });
+
+  return msg;
+};
+
+export const convertToSignable = async (msg: MsgSend | MsgDeposit, chain: TCLikeChain) => {
+  const aminoTypes = await createDefaultAminoTypes(chain);
+
+  return aminoTypes.fromAmino(msg);
+};
+
+const getAccount = async ({ rpcUrl, sender }: { sender: string; rpcUrl: string }) => {
+  const client = await createStargateClient(rpcUrl);
+  const account = await client.getAccount(sender);
+
+  if (!account) {
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
+  }
+
+  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)({ asAminoMessage, asSignable, assetValue, memo, recipient, sender });
+    }
+
+    return buildDepositTx(rpcUrl)({ asAminoMessage, asSignable, assetValue, memo, sender });
+  };
+}
+
+export const buildTransferTx =
+  (rpcUrl: string) =>
+  async ({
+    sender,
+    recipient,
+    assetValue,
+    memo = "",
+    asSignable = true,
+    asAminoMessage = false,
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as TCLikeChain;
+    const { chainId } = getChainConfig(chain);
+
+    const transferMsg = transferMsgAmino({ assetValue, recipient, sender });
+
+    const msg = asSignable
+      ? await convertToSignable(asAminoMessage ? transferMsg : parseAminoMessageForDirectSigning(transferMsg), chain)
+      : transferMsg;
+
+    const transaction = {
+      accountNumber: accountNumber || account.accountNumber,
+      chainId,
+      fee: getDefaultChainFee(chain),
+      memo,
+      msgs: [msg],
+      sequence: sequence || account.sequence,
+    };
+
+    return transaction;
+  };
+
+export const buildDepositTx =
+  (rpcUrl: string) =>
+  async ({
+    sender,
+    assetValue,
+    memo = "",
+    asSignable = true,
+    asAminoMessage = false,
+    sequence,
+    accountNumber,
+  }: ThorchainCreateTransactionParams) => {
+    const account = await getAccount({ rpcUrl, sender });
+    const chain = assetValue.chain as TCLikeChain;
+    const { chainId } = getChainConfig(chain);
+
+    const depositMsg = depositMsgAmino({ assetValue, memo, sender });
+
+    const msg = asSignable
+      ? await convertToSignable(
+          asAminoMessage ? depositMsg : parseAminoMessageForDirectSigning<MsgDeposit>(depositMsg),
+          chain,
+        )
+      : depositMsg;
+
+    const transaction = {
+      accountNumber: accountNumber || account.accountNumber,
+      chainId,
+      fee: getDefaultChainFee(chain),
+      memo,
+      msgs: [msg],
+      sequence: sequence || account.sequence,
+    };
+
+    return transaction;
+  };
+
+export function parseAminoMessageForDirectSigning<T extends MsgDeposit | MsgSend>(msg: T) {
+  if (msg.type === "thorchain/MsgSend" || msg.type === "mayachain/MsgSend") return msg as MsgSend;
+
+  return {
+    ...msg,
+    value: {
+      ...msg.value,
+      coins: (msg as MsgDeposit).value.coins.map((coin: { asset: string; amount: string }) => {
+        const assetValue = AssetValue.from({ asset: coin.asset });
+
+        const symbol = (assetValue.isSynthetic ? assetValue.symbol.split("/")?.[1] : assetValue.symbol)?.toUpperCase();
+        const chain = (assetValue.isSynthetic ? assetValue.symbol.split("/")?.[0] : assetValue.chain)?.toUpperCase();
+
+        return { ...coin, asset: { chain, symbol, synth: assetValue.isSynthetic, ticker: assetValue.ticker } };
+      }),
+    },
+  };
+}
+
+export async function buildEncodedTxBody({
+  chain,
+  memo,
+  msgs,
+}: {
+  msgs: DirectMsgDepositForBroadcast[] | DirectMsgSendForBroadcast[];
+  memo: string;
+  chain: TCLikeChain;
+}) {
+  const registry = await createDefaultRegistry();
+  const aminoTypes = await createDefaultAminoTypes(chain);
+
+  const signedTxBody: TxBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: { memo, messages: msgs.map((msg) => aminoTypes.fromAmino(msg)) },
+  };
+
+  return registry.encode(signedTxBody);
+}

package/src/cosmos/thorchainUtils/registry.ts

@@ -0,0 +1,43 @@
+import { Chain, type TCLikeChain } from "@uswap/helpers";
+import { base64ToBech32, bech32ToBase64 } from "./addressFormat";
+
+export async function createDefaultRegistry() {
+  const { $root } = await import("./types/MsgCompiled");
+  const importedProtoSigning = await import("@cosmjs/proto-signing");
+  const Registry = importedProtoSigning.Registry ?? importedProtoSigning.default?.Registry;
+  const importedStargate = await import("@cosmjs/stargate");
+  const defaultRegistryTypes = importedStargate.defaultRegistryTypes ?? importedStargate.default?.defaultRegistryTypes;
+
+  return new Registry([
+    ...defaultRegistryTypes,
+    ["/types.MsgSend", $root.types.MsgSend],
+    ["/types.MsgDeposit", $root.types.MsgDeposit],
+  ]);
+}
+
+export async function createDefaultAminoTypes(chain: TCLikeChain) {
+  const imported = await import("@cosmjs/stargate");
+  const AminoTypes = imported.AminoTypes ?? imported.default?.AminoTypes;
+  const aminoTypePrefix = chain === Chain.THORChain ? "thorchain" : ("mayachain" as const);
+
+  return new AminoTypes({
+    "/types.MsgDeposit": {
+      aminoType: `${aminoTypePrefix}/MsgDeposit`,
+      fromAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: bech32ToBase64(signer) }),
+      toAmino: ({ signer, ...rest }: any) => ({ ...rest, signer: base64ToBech32(signer) }),
+    },
+    "/types.MsgSend": {
+      aminoType: `${aminoTypePrefix}/MsgSend`,
+      fromAmino: ({ from_address, to_address, ...rest }: any) => ({
+        ...rest,
+        fromAddress: bech32ToBase64(from_address),
+        toAddress: bech32ToBase64(to_address),
+      }),
+      toAmino: ({ fromAddress, toAddress, ...rest }: any) => ({
+        ...rest,
+        from_address: base64ToBech32(fromAddress),
+        to_address: base64ToBech32(toAddress),
+      }),
+    },
+  });
+}