@swapkit/toolboxes 1.0.0-beta.2 → 1.0.0-beta.20

package/src/cosmos/thorchainUtils/addressFormat.ts

@@ -1,4 +1,5 @@
 import { base64, bech32 } from "@scure/base";
+import { SwapKitError } from "@swapkit/helpers";
 import { fromByteArray, toByteArray } from "base64-js";
 
 export function bech32ToBase64(address: string) {
@@ -17,7 +18,9 @@ export function toBase64(data: Uint8Array) {
 
 export function fromBase64(base64String: string) {
   if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
-    throw new Error("Invalid base64 string format");
+    throw new SwapKitError("toolbox_cosmos_invalid_params", {
+      error: "Invalid base64 string format",
+    });
   }
   return toByteArray(base64String);
 }

package/src/cosmos/thorchainUtils/messages.ts

@@ -1,5 +1,5 @@
 import type { TxBodyEncodeObject } from "@cosmjs/proto-signing";
-import { AssetValue, Chain, ChainToChainId } from "@swapkit/helpers";
+import { AssetValue, Chain, ChainToChainId, SwapKitError } from "@swapkit/helpers";
 
 import {
   createStargateClient,
@@ -104,7 +104,7 @@ const getAccount = async ({ rpcUrl, sender }: { sender: string; rpcUrl: string }
   const account = await client.getAccount(sender);
 
   if (!account) {
-    throw new Error("Account does not exist");
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
   }
 
   return account;

package/src/cosmos/thorchainUtils/registry.ts

@@ -3,8 +3,8 @@ import { base64ToBech32, bech32ToBase64 } from "./addressFormat";
 
 export async function createDefaultRegistry() {
   const { $root } = await import("./types/MsgCompiled");
-  const { Registry } = await import("@cosmjs/proto-signing");
-  const { defaultRegistryTypes } = await import("@cosmjs/stargate");
+  const { Registry } = (await import("@cosmjs/proto-signing")).default;
+  const { defaultRegistryTypes } = (await import("@cosmjs/stargate")).default;
 
   return new Registry([
     ...defaultRegistryTypes,
@@ -14,7 +14,7 @@ export async function createDefaultRegistry() {
 }
 
 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({

package/src/cosmos/toolbox/cosmos.ts

@@ -17,6 +17,7 @@ import {
   SKConfig,
   SwapKitError,
   SwapKitNumber,
+  applyFeeMultiplier,
   derivationPathToString,
   updateDerivationPath,
 } from "@swapkit/helpers";
@@ -38,8 +39,7 @@ export async function fetchFeeRateFromSwapKit(chainId: ChainId, safeDefault: num
     const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
 
     return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
-  } catch (e) {
-    console.error(e);
+  } catch (_e) {
     return safeDefault;
   }
 }
@@ -52,8 +52,8 @@ export async function getSignerFromPhrase({
   | { chain: Chain; index?: number }
   | { derivationPath: string }
 )) {
-  const { DirectSecp256k1HdWallet } = await import("@cosmjs/proto-signing");
-  const { stringToPath } = await import("@cosmjs/crypto");
+  const { DirectSecp256k1HdWallet } = (await import("@cosmjs/proto-signing")).default;
+  const { stringToPath } = (await import("@cosmjs/crypto")).default;
 
   const derivationPath =
     "derivationPath" in derivationParams
@@ -73,7 +73,7 @@ export async function getSignerFromPrivateKey({
   privateKey: Uint8Array;
   prefix: string;
 }) {
-  const { DirectSecp256k1Wallet } = await import("@cosmjs/proto-signing");
+  const { DirectSecp256k1Wallet } = (await import("@cosmjs/proto-signing")).default;
 
   return DirectSecp256k1Wallet.fromKey(privateKey, prefix);
 }
@@ -97,7 +97,7 @@ export function verifySignature(getAccount: (address: string) => Promise<Account
   }) {
     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 { Secp256k1Signature, Secp256k1 } = (await import("@cosmjs/crypto")).default;
 
     const secpSignature = Secp256k1Signature.fromFixedLength(base64.decode(signature));
     return Secp256k1.verifySignature(secpSignature, base64.decode(message), account.pubkey.value);
@@ -197,7 +197,7 @@ export async function createCosmosToolbox({ chain, ...toolboxParams }: CosmosToo
         index,
       }),
     getSignerFromPrivateKey: async (privateKey: Uint8Array) => {
-      const { DirectSecp256k1Wallet } = await import("@cosmjs/proto-signing");
+      const { DirectSecp256k1Wallet } = (await import("@cosmjs/proto-signing")).default;
       return DirectSecp256k1Wallet.fromKey(privateKey, chainPrefix);
     },
     createPrivateKeyFromPhrase: createPrivateKeyFromPhrase(derivationPath),
@@ -217,8 +217,7 @@ export async function getFeeRateFromThorswap(chainId: ChainId, safeDefault: numb
     const responseGasRate = response.find((gas) => gas.chainId === chainId)?.value;
 
     return responseGasRate ? Number.parseFloat(responseGasRate) : safeDefault;
-  } catch (e) {
-    console.error(e);
+  } catch (_e) {
     return safeDefault;
   }
 }
@@ -262,8 +261,14 @@ async function getFees(chain: Chain, safeDefault: number) {
   const baseFee = await fetchFeeRateFromSwapKit(ChainToChainId[chain], safeDefault);
   return {
     average: SwapKitNumber.fromBigInt(BigInt(baseFee), BaseDecimal[chain]),
-    fast: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 1.5)), BaseDecimal[chain]),
-    fastest: SwapKitNumber.fromBigInt(BigInt(Math.floor(baseFee * 2)), BaseDecimal[chain]),
+    fast: SwapKitNumber.fromBigInt(
+      BigInt(applyFeeMultiplier(baseFee, FeeOption.Fast, true)),
+      BaseDecimal[chain],
+    ),
+    fastest: SwapKitNumber.fromBigInt(
+      BigInt(applyFeeMultiplier(baseFee, FeeOption.Fastest, true)),
+      BaseDecimal[chain],
+    ),
   } as { [key in FeeOption]: SwapKitNumber };
 }
 

package/src/cosmos/toolbox/index.ts

@@ -1,4 +1,4 @@
-import { Chain, type CosmosChain } from "@swapkit/helpers";
+import { Chain, type CosmosChain, SwapKitError } from "@swapkit/helpers";
 
 import type { CosmosToolboxParams } from "../types";
 import { createCosmosToolbox } from "./cosmos";
@@ -25,7 +25,7 @@ export const getCosmosToolbox = <T extends CosmosChain>(
       return createThorchainToolbox({ chain, ...params }) as CosmosToolboxes[T];
 
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
   }
 };
 

package/src/cosmos/toolbox/thorchain.ts

@@ -9,6 +9,7 @@ import {
   NetworkDerivationPath,
   RequestClient,
   SKConfig,
+  SwapKitError,
   SwapKitNumber,
   derivationPathToString,
   updateDerivationPath,
@@ -43,8 +44,8 @@ function secp256k1HdWalletFromMnemonic({
   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}`)],
@@ -114,8 +115,8 @@ function broadcastMultisigTx({
     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);
@@ -142,7 +143,8 @@ function broadcastMultisigTx({
 }
 
 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,
@@ -161,7 +163,7 @@ async function signWithPrivateKey({
   privateKey: Uint8Array;
   message: string;
 }) {
-  const { Secp256k1 } = await import("@cosmjs/crypto");
+  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)]));
@@ -209,7 +211,7 @@ export async function createThorchainToolbox({
       } = await RequestClient.get<ThorchainConstantsResponse>(constantsUrl);
 
       if (!nativeFee || Number.isNaN(nativeFee) || nativeFee < 0) {
-        throw new Error(`Invalid nativeFee: ${nativeFee.toString()}`);
+        throw new SwapKitError("toolbox_cosmos_invalid_fee", { nativeFee: nativeFee.toString() });
       }
 
       fee = new SwapKitNumber(nativeFee);
@@ -230,7 +232,7 @@ export async function createThorchainToolbox({
   }: Omit<GenericTransferParams, "recipient"> & { recipient?: string }) {
     const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx");
     const sender = (await signer?.getAccounts())?.[0]?.address;
-    if (!(sender && signer)) throw new Error("Signer not defined");
+    if (!(sender && signer)) throw new SwapKitError("toolbox_cosmos_no_signer");
 
     const isAminoSigner = "signAmino" in signer;
     const registry = await createDefaultRegistry();
@@ -301,7 +303,7 @@ export async function createThorchainToolbox({
     signWithPrivateKey,
     transfer,
     pubkeyToAddress: async (pubkey: Pubkey) => {
-      const { pubkeyToAddress } = await import("@cosmjs/amino");
+      const { pubkeyToAddress } = (await import("@cosmjs/amino")).default;
       return pubkeyToAddress(pubkey, chainPrefix);
     },
   };

package/src/cosmos/util.ts

@@ -1,6 +1,13 @@
 import type { OfflineSigner } from "@cosmjs/proto-signing";
 import type { SigningStargateClientOptions } from "@cosmjs/stargate";
-import { AssetValue, Chain, ChainId, type CosmosChain, SKConfig } from "@swapkit/helpers";
+import {
+  AssetValue,
+  Chain,
+  ChainId,
+  type CosmosChain,
+  SKConfig,
+  SwapKitError,
+} from "@swapkit/helpers";
 
 import type { CosmosCreateTransactionParams } from "./thorchainUtils";
 
@@ -69,7 +76,7 @@ export const getDenomWithChain = ({ symbol, chain }: AssetValue) => {
 };
 
 export async function createStargateClient(url: string) {
-  const { StargateClient } = await import("@cosmjs/stargate");
+  const { StargateClient } = (await import("@cosmjs/stargate")).default;
 
   return StargateClient.connect(url);
 }
@@ -79,7 +86,7 @@ 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;
 
@@ -93,7 +100,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);
 }
@@ -126,7 +133,7 @@ const getTransferMsgTypeByChain = (chain: CosmosChain) => {
     case Chain.Kujira:
       return "/cosmos.bank.v1beta1.MsgSend";
     default:
-      throw new Error("Unsupported chain");
+      throw new SwapKitError("toolbox_cosmos_not_supported", { chain });
   }
 };
 
@@ -149,7 +156,7 @@ export const cosmosCreateTransaction = async ({
   const accountOnChain = await client.getAccount(sender);
 
   if (!accountOnChain) {
-    throw new Error("Account does not exist");
+    throw new SwapKitError("toolbox_cosmos_account_not_found", { sender });
   }
 
   const gasAsset = AssetValue.from({ chain });

package/src/evm/__tests__/ethereum.test.ts

@@ -35,7 +35,7 @@ beforeEach(async () => {
     },
   });
   context.provider = provider;
-  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer });
+  context.toolbox = await getEvmToolbox(Chain.Ethereum, { provider, signer: signer as any });
 });
 
 afterEach(async () => {

package/src/evm/helpers.ts

@@ -8,6 +8,7 @@ import {
   FeeOption,
   type NetworkParams,
   SKConfig,
+  SwapKitError,
   SwapKitNumber,
 } from "@swapkit/helpers";
 import type { BrowserProvider, Provider } from "ethers";
@@ -71,7 +72,7 @@ export const estimateMaxSendableAmount = async ({
   const isFeeEVMLegacyCompatible = "gasPrice" in gasRate && gasRate.gasPrice !== undefined;
 
   if (!(gasRate && (isFeeEVMLegacyCompatible || isFeeEIP1559Compatible))) {
-    throw new Error("Could not fetch fee data");
+    throw new SwapKitError("toolbox_evm_no_fee_data");
   }
 
   const gasPrice = isFeeEIP1559Compatible
@@ -116,7 +117,7 @@ export function getEstimateTransactionFee({
       return assetValue.set(SwapKitNumber.fromBigInt(fee, assetValue.decimal));
     }
 
-    throw new Error("No gas price found");
+    throw new SwapKitError("toolbox_evm_no_gas_price");
   };
 }
 
@@ -168,6 +169,6 @@ function getNetworkInfo<C extends EVMChain>({ chain }: { chain: C }) {
         nativeCurrency: { name: "Polygon", symbol: Chain.Polygon, decimals },
       };
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_evm_not_supported", { chain });
   }
 }

package/src/evm/toolbox/baseEVMToolbox.ts

@@ -8,6 +8,7 @@ import {
   FeeOption,
   SwapKitError,
   SwapKitNumber,
+  applyFeeMultiplierToBigInt,
   isGasAsset,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
@@ -208,7 +209,7 @@ export function getEstimateGasPrices({
       try {
         const { gasPrice } = await provider.getFeeData();
 
-        if (!gasPrice) throw new Error("No fee data available");
+        if (!gasPrice) throw new SwapKitError("toolbox_evm_no_fee_data");
 
         return {
           [FeeOption.Average]: { gasPrice },
@@ -216,9 +217,9 @@ export function getEstimateGasPrices({
           [FeeOption.Fastest]: { gasPrice },
         };
       } catch (error) {
-        throw new Error(
-          `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-        );
+        throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+          error: (error as any).msg ?? (error as any).toString(),
+        });
       }
     };
   }
@@ -231,7 +232,7 @@ export function getEstimateGasPrices({
         const price = gasPrice as bigint;
 
         if (!(maxFeePerGas && maxPriorityFeePerGas)) {
-          throw new Error("No fee data available");
+          throw new SwapKitError("toolbox_evm_no_fee_data");
         }
 
         return {
@@ -242,22 +243,25 @@ export function getEstimateGasPrices({
             maxPriorityFeePerGas,
           },
           [FeeOption.Fast]: {
-            l1GasPrice: ((l1GasPrice || 0n) * 15n) / 10n,
-            gasPrice: (price * 15n) / 10n,
+            l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fast),
+            gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fast),
             maxFeePerGas,
-            maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fast),
           },
           [FeeOption.Fastest]: {
-            l1GasPrice: (l1GasPrice || 0n) * 2n,
-            gasPrice: price * 2n,
+            l1GasPrice: applyFeeMultiplierToBigInt(l1GasPrice || 0n, FeeOption.Fastest),
+            gasPrice: applyFeeMultiplierToBigInt(price, FeeOption.Fastest),
             maxFeePerGas,
-            maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(
+              maxPriorityFeePerGas,
+              FeeOption.Fastest,
+            ),
           },
         };
       } catch (error) {
-        throw new Error(
-          `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-        );
+        throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+          error: (error as any).msg ?? (error as any).toString(),
+        });
       }
     };
   }
@@ -273,12 +277,15 @@ export function getEstimateGasPrices({
         return {
           [FeeOption.Average]: { maxFeePerGas, maxPriorityFeePerGas },
           [FeeOption.Fast]: {
-            maxFeePerGas: (maxFeePerGas * 15n) / 10n,
-            maxPriorityFeePerGas: (maxPriorityFeePerGas * 15n) / 10n,
+            maxFeePerGas: applyFeeMultiplierToBigInt(maxFeePerGas, FeeOption.Fast),
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(maxPriorityFeePerGas, FeeOption.Fast),
           },
           [FeeOption.Fastest]: {
-            maxFeePerGas: maxFeePerGas * 2n,
-            maxPriorityFeePerGas: maxPriorityFeePerGas * 2n,
+            maxFeePerGas: applyFeeMultiplierToBigInt(maxFeePerGas, FeeOption.Fastest),
+            maxPriorityFeePerGas: applyFeeMultiplierToBigInt(
+              maxPriorityFeePerGas,
+              FeeOption.Fastest,
+            ),
           },
         };
       }
@@ -286,13 +293,13 @@ export function getEstimateGasPrices({
 
       return {
         [FeeOption.Average]: { gasPrice },
-        [FeeOption.Fast]: { gasPrice: (gasPrice * 15n) / 10n },
-        [FeeOption.Fastest]: { gasPrice: gasPrice * 2n },
+        [FeeOption.Fast]: { gasPrice: applyFeeMultiplierToBigInt(gasPrice, FeeOption.Fast) },
+        [FeeOption.Fastest]: { gasPrice: applyFeeMultiplierToBigInt(gasPrice, FeeOption.Fastest) },
       };
     } catch (error) {
-      throw new Error(
-        `Failed to estimate gas price: ${(error as any).msg ?? (error as any).toString()}`,
-      );
+      throw new SwapKitError("toolbox_evm_gas_estimation_error", {
+        error: (error as any).msg ?? (error as any).toString(),
+      });
     }
   };
 }
@@ -314,7 +321,10 @@ function getCall({ provider, isEIP1559Compatible, signer, chain }: ToolboxWrapPa
     feeOption = FeeOption.Fast,
   }: CallParams): Promise<T> {
     const contractProvider = callProvider || provider;
-    if (!contractAddress) throw new Error("contractAddress must be provided");
+    if (!contractAddress)
+      throw new SwapKitError("toolbox_evm_invalid_params", {
+        error: "contractAddress must be provided",
+      });
 
     const isStateChanging = isStateChangingCall({ abi, funcName });
 
@@ -538,6 +548,7 @@ function getEstimateGasLimit({ provider, signer }: ToolboxWrapParams) {
     assetValue,
     recipient,
     memo,
+    data,
     sender,
     funcName,
     funcParams,
@@ -547,6 +558,7 @@ function getEstimateGasLimit({ provider, signer }: ToolboxWrapParams) {
     funcName?: string;
     funcParams?: unknown[];
     txOverrides?: EVMTxParams;
+    data?: string;
   }) {
     // const value = assetValue.getBaseValue("bigint");
     const value = assetValue.bigIntValue;
@@ -573,7 +585,7 @@ function getEstimateGasLimit({ provider, signer }: ToolboxWrapParams) {
       from: sender,
       to: recipient,
       value,
-      data: memo ? hexlify(toUtf8Bytes(memo)) : undefined,
+      data: data ? data : memo ? hexlify(toUtf8Bytes(memo)) : undefined,
     });
   };
 }

package/src/evm/toolbox/index.ts

@@ -1,4 +1,4 @@
-import { Chain, type EVMChain } from "@swapkit/helpers";
+import { Chain, type EVMChain, SwapKitError } from "@swapkit/helpers";
 
 import { getProvider } from "../helpers";
 import type { EVMToolboxParams } from "../types";
@@ -27,7 +27,7 @@ export async function getEvmToolbox<T extends EVMChain>(chain: T, params?: EVMTo
     case Chain.Ethereum:
       return ETHToolbox(toolboxParams);
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_evm_not_supported", { chain });
   }
 }
 

package/src/evm/toolbox/op.ts

@@ -1,5 +1,18 @@
-import { BaseDecimal, Chain, ChainId, ChainToExplorerUrl, SKConfig } from "@swapkit/helpers";
-import type { BrowserProvider, JsonRpcProvider, Provider, TransactionRequest } from "ethers";
+import {
+  BaseDecimal,
+  Chain,
+  ChainId,
+  ChainToExplorerUrl,
+  SKConfig,
+  SwapKitError,
+} from "@swapkit/helpers";
+import type {
+  Authorization,
+  BrowserProvider,
+  JsonRpcProvider,
+  Provider,
+  TransactionRequest,
+} from "ethers";
 import { Contract, HDNodeWallet } from "ethers";
 
 import { P } from "ts-pattern";
@@ -32,14 +45,15 @@ function serializeTx<P extends JsonRpcProvider | BrowserProvider>(provider: P) {
   return async function serializeTx({ from, to, nonce, ...tx }: TransactionRequest) {
     const { Transaction } = await import("ethers");
 
-    if (!to) throw new Error("Missing to address");
-    const txParams = {
+    if (!to)
+      throw new SwapKitError("toolbox_evm_invalid_transaction", { error: "Missing to address" });
+
+    return Transaction.from({
       ...tx,
+      authorizationList: tx.authorizationList as Authorization[],
       to: to as string,
       nonce: nonce ? nonce : from ? await provider.getTransactionCount(from) : 0,
-    };
-
-    return Transaction.from(txParams).serialized;
+    }).serialized;
   };
 }