@uswap/toolboxes 4.3.6

package/src/substrate/substrate.ts

@@ -0,0 +1,281 @@
+import type { ApiPromise } from "@polkadot/api";
+import type { SubmittableExtrinsic } from "@polkadot/api/types";
+import type { KeyringPair } from "@polkadot/keyring/types";
+import type { Callback, IKeyringPair, ISubmittableResult, Signer } from "@polkadot/types/types";
+import { hexToU8a, isHex, u8aToHex } from "@polkadot/util";
+import { decodeAddress as decodePolkadotAddress, encodeAddress as encodePolkadotAddress } from "@polkadot/util-crypto";
+import {
+  AssetValue,
+  Chain,
+  type DerivationPathArray,
+  type GenericCreateTransactionParams,
+  getRPCUrl,
+  type SubstrateChain,
+  SwapKitError,
+  SwapKitNumber,
+} from "@uswap/helpers";
+
+import { match, P } from "ts-pattern";
+import { createBalanceGetter } from "./balance";
+import { SubstrateNetwork, type SubstrateTransferParams } from "./types";
+
+export const PolkadotToolbox = ({ generic = false, ...signerParams }: ToolboxParams = {}) => {
+  return createSubstrateToolbox({ chain: Chain.Polkadot, generic, ...signerParams });
+};
+
+export const ChainflipToolbox = async ({ generic = false, ...signerParams }: ToolboxParams = {}) => {
+  const toolbox = await createSubstrateToolbox({ chain: Chain.Chainflip, generic, ...signerParams });
+
+  return { ...toolbox };
+};
+
+export type SubstrateToolboxes = {
+  DOT: Awaited<ReturnType<typeof PolkadotToolbox>>;
+  FLIP: Awaited<ReturnType<typeof ChainflipToolbox>>;
+};
+
+export function getSubstrateToolbox<T extends SubstrateChain>(chain: T, params?: ToolboxParams) {
+  switch (chain) {
+    case Chain.Chainflip: {
+      return ChainflipToolbox(params);
+    }
+    case Chain.Polkadot: {
+      return PolkadotToolbox(params);
+    }
+    default:
+      throw new SwapKitError("toolbox_substrate_not_supported", { chain });
+  }
+}
+
+export function isKeyringPair(account: IKeyringPair | Signer): account is IKeyringPair {
+  return "address" in account;
+}
+
+export async function createKeyring(phrase: string, networkPrefix: number) {
+  const { Keyring } = await import("@polkadot/api");
+  const { cryptoWaitReady } = await import("@polkadot/util-crypto");
+  await cryptoWaitReady();
+
+  return new Keyring({ ss58Format: networkPrefix, type: "sr25519" }).addFromUri(phrase);
+}
+
+const getNonce = (api: ApiPromise, address: string) => api.rpc.system.accountNextIndex(address);
+
+const validateAddress = (address: string, networkPrefix: number) => {
+  try {
+    const decodedAddress = decodeAddress(address, networkPrefix);
+
+    encodeAddress(decodedAddress, "ss58", networkPrefix);
+
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const createTransaction = (api: ApiPromise, { recipient, assetValue }: SubstrateTransferParams) =>
+  api.tx.balances?.transferAllowDeath?.(recipient, assetValue.getBaseValue("number"));
+
+const transfer = async (
+  api: ApiPromise,
+  signer: IKeyringPair | Signer,
+  { recipient, assetValue, sender }: SubstrateTransferParams,
+) => {
+  const transfer = createTransaction(api, { assetValue, recipient });
+  if (!transfer) throw new SwapKitError("toolbox_substrate_transfer_error");
+
+  const isKeyring = isKeyringPair(signer);
+
+  const address = isKeyring ? (signer as IKeyringPair).address : sender;
+  if (!address) throw new SwapKitError("core_transaction_invalid_sender_address");
+
+  const nonce = await getNonce(api, address);
+
+  const tx = await transfer.signAndSend(isKeyring ? signer : address, {
+    nonce,
+    signer: isKeyring ? undefined : signer,
+  });
+
+  return tx.toString();
+};
+
+const estimateTransactionFee = async (
+  api: ApiPromise,
+  signer: IKeyringPair | Signer,
+  gasAsset: AssetValue,
+  { recipient, assetValue, sender }: SubstrateTransferParams,
+) => {
+  const transfer = createTransaction(api, { assetValue, recipient });
+
+  const address = isKeyringPair(signer) ? signer.address : sender;
+  if (!address) return;
+
+  const paymentInfo = (await transfer?.paymentInfo(address, { nonce: await getNonce(api, address) })) || {
+    partialFee: 0,
+  };
+  return gasAsset.set(
+    SwapKitNumber.fromBigInt(BigInt(paymentInfo.partialFee.toString()), gasAsset.decimal).getValue("string"),
+  );
+};
+
+const broadcast = async (tx: SubmittableExtrinsic<"promise">, callback?: Callback<ISubmittableResult>) => {
+  if (callback) return tx.send(callback);
+  const hash = await tx.send();
+  return hash.toString();
+};
+
+const sign = async (signer: IKeyringPair, tx: SubmittableExtrinsic<"promise">) => {
+  const signedTx = await tx.signAsync(signer);
+  return signedTx;
+};
+
+const signAndBroadcastKeyring = (
+  signer: IKeyringPair,
+  tx: SubmittableExtrinsic<"promise">,
+  callback?: Callback<ISubmittableResult>,
+) => {
+  if (callback) return tx.signAndSend(signer, callback);
+  const hash = tx.signAndSend(signer);
+  return hash.toString();
+};
+
+const signAndBroadcast = async ({
+  signer,
+  address,
+  tx,
+  callback,
+  api,
+}: {
+  signer: Signer;
+  address: string;
+  tx: SubmittableExtrinsic<"promise">;
+  api: ApiPromise;
+  callback?: Callback<ISubmittableResult>;
+}) => {
+  const nonce = await getNonce(api, address);
+  if (callback) {
+    tx.signAndSend(address, { nonce, signer }, callback);
+  }
+  const hash = tx.signAndSend(address, { nonce, signer });
+  return hash.toString();
+};
+
+function convertAddress(address: string, newPrefix: number) {
+  const decodedAddress = decodePolkadotAddress(address);
+  const convertedAddress = encodePolkadotAddress(decodedAddress, newPrefix);
+  return convertedAddress;
+}
+
+function decodeAddress(address: string, networkPrefix?: number) {
+  return isHex(address) ? hexToU8a(address) : decodePolkadotAddress(address, undefined, networkPrefix);
+}
+
+function encodeAddress(address: Uint8Array, encoding: "ss58" | "hex" = "ss58", networkPrefix?: number) {
+  if (encoding === "hex") {
+    return u8aToHex(address);
+  }
+
+  return encodePolkadotAddress(address, networkPrefix);
+}
+
+export const BaseSubstrateToolbox = ({
+  api,
+  network,
+  gasAsset,
+  signer,
+  chain,
+}: {
+  api: ApiPromise;
+  network: SubstrateNetwork;
+  gasAsset: AssetValue;
+  signer?: IKeyringPair | Signer;
+  chain?: SubstrateChain;
+}) => ({
+  api,
+  broadcast,
+  convertAddress,
+  createKeyring: (phrase: string) => createKeyring(phrase, network.prefix),
+  createTransaction: (params: GenericCreateTransactionParams) => createTransaction(api, params),
+  decodeAddress,
+  encodeAddress,
+  estimateTransactionFee: (params: SubstrateTransferParams) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    return estimateTransactionFee(api, signer, gasAsset, params);
+  },
+  gasAsset,
+  getAddress: (keyring?: IKeyringPair | Signer) => {
+    const keyringPair = keyring || signer;
+    if (!keyringPair) throw new SwapKitError("core_wallet_not_keypair_wallet");
+
+    return isKeyringPair(keyringPair) ? keyringPair.address : undefined;
+  },
+  getBalance: createBalanceGetter(chain || Chain.Polkadot, api),
+  network,
+  sign: (tx: SubmittableExtrinsic<"promise">) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (isKeyringPair(signer)) return sign(signer, tx);
+
+    throw new SwapKitError(
+      "core_wallet_not_keypair_wallet",
+      "Signer does not have keyring pair capabilities required for signing.",
+    );
+  },
+  signAndBroadcast: ({
+    tx,
+    callback,
+    address,
+  }: {
+    tx: SubmittableExtrinsic<"promise">;
+    callback?: Callback<ISubmittableResult>;
+    address?: string;
+  }) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    if (isKeyringPair(signer)) return signAndBroadcastKeyring(signer, tx, callback);
+
+    if (address) {
+      return signAndBroadcast({ address, api, callback, signer, tx });
+    }
+
+    throw new SwapKitError(
+      "core_wallet_not_keypair_wallet",
+      "Signer does not have keyring pair capabilities required for signing.",
+    );
+  },
+  transfer: (params: SubstrateTransferParams) => {
+    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
+    return transfer(api, signer, params);
+  },
+  validateAddress: (address: string) => validateAddress(address, network.prefix),
+});
+
+export const substrateValidateAddress = ({ address, chain }: { address: string; chain: SubstrateChain }) => {
+  const { prefix } = chain === Chain.Polkadot ? SubstrateNetwork.DOT : SubstrateNetwork.FLIP;
+
+  return validateAddress(address, prefix) || validateAddress(address, SubstrateNetwork.GENERIC.prefix);
+};
+
+export async function createSubstrateToolbox({
+  generic,
+  chain,
+  ...signerParams
+}: ToolboxParams & { chain: SubstrateChain }) {
+  const { ApiPromise, WsProvider } = await import("@polkadot/api");
+
+  const rpcUrl = await getRPCUrl(chain);
+  const provider = new WsProvider(rpcUrl);
+  const api = await ApiPromise.create({ noInitWarn: true, provider });
+  const gasAsset = AssetValue.from({ chain });
+  const network = generic ? SubstrateNetwork.GENERIC : SubstrateNetwork[chain];
+
+  const signer = await match(signerParams)
+    .with({ phrase: P.string }, ({ phrase }) => createKeyring(phrase, SubstrateNetwork[chain].prefix))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  return BaseSubstrateToolbox({ api, chain, gasAsset, network, signer });
+}
+
+export type ToolboxParams = { generic?: boolean } & (
+  | { signer?: KeyringPair | Signer }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+);

package/src/substrate/types.ts

@@ -0,0 +1,115 @@
+import type { Signer as InjectedSigner } from "@polkadot/api/types";
+import type { ProviderInterface } from "@polkadot/rpc-provider/types";
+import type { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
+import type { KeypairType } from "@polkadot/util-crypto/types";
+import type { GenericTransferParams, SubstrateChain } from "@uswap/helpers";
+
+const polkadotNetwork = {
+  decimals: [10],
+  displayName: "Polkadot Relay Chain",
+  network: "polkadot",
+  prefix: 0,
+  standardAccount: "*25519",
+  symbols: ["DOT"],
+  website: "https://polkadot.network",
+};
+
+const chainflipNetwork = {
+  decimals: [18],
+  displayName: "Chainflip",
+  network: "chainflip",
+  prefix: 2112,
+  standardAccount: "*25519",
+  symbols: ["FLIP"],
+  website: "https://chainflip.io/",
+};
+
+const subtrateNetwork = {
+  decimals: [],
+  displayName: "Substrate",
+  network: "substrate",
+  prefix: 42,
+  standardAccount: "*25519",
+  symbols: [],
+  website: "https://substrate.io/",
+};
+
+export const SubstrateNetwork: Record<SubstrateChain | "GENERIC", SubstrateNetwork> = {
+  DOT: polkadotNetwork,
+  FLIP: chainflipNetwork,
+  GENERIC: subtrateNetwork,
+};
+
+export type SubstrateNetwork = typeof polkadotNetwork | typeof chainflipNetwork | typeof subtrateNetwork;
+
+export type SubstrateTransferParams = GenericTransferParams & { sender?: string };
+
+type Unsubcall = () => void;
+
+interface InjectedAccount {
+  address: string;
+  genesisHash?: string | null;
+  name?: string;
+  type?: KeypairType;
+}
+
+interface InjectedAccounts {
+  get: (anyType?: boolean) => Promise<InjectedAccount[]>;
+  subscribe: (cb: (accounts: InjectedAccount[]) => void | Promise<void>) => Unsubcall;
+}
+interface InjectedExtensionInfo {
+  name: string;
+  version: string;
+}
+interface ProviderMeta {
+  network: string;
+  node: "full" | "light";
+  source: string;
+  transport: string;
+}
+interface MetadataDefBase {
+  chain: string;
+  genesisHash: string;
+  icon: string;
+  ss58Format: number;
+  chainType?: "substrate" | "ethereum";
+}
+interface MetadataDef extends MetadataDefBase {
+  color?: string;
+  specVersion: number;
+  tokenDecimals: number;
+  tokenSymbol: string;
+  types: Record<string, Record<string, string> | string>;
+  metaCalls?: string;
+  userExtensions?: ExtDef;
+}
+interface InjectedMetadataKnown {
+  genesisHash: string;
+  specVersion: number;
+}
+interface InjectedMetadata {
+  get: () => Promise<InjectedMetadataKnown[]>;
+  provide: (definition: MetadataDef) => Promise<boolean>;
+}
+type ProviderList = Record<string, ProviderMeta>;
+
+interface InjectedProvider extends ProviderInterface {
+  listProviders: () => Promise<ProviderList>;
+  startProvider: (key: string) => Promise<ProviderMeta>;
+}
+
+type InjectedWalletData = {
+  accounts: InjectedAccounts;
+  metadata?: InjectedMetadata;
+  provider?: InjectedProvider;
+  signer: InjectedSigner;
+};
+
+export type SubstrateInjectedExtension = Record<
+  string,
+  {
+    connect?: (origin: string) => Promise<InjectedExtensionInfo & InjectedWalletData>;
+    enable?: (origin: string) => Promise<InjectedWalletData>;
+    version?: string;
+  }
+>;

package/src/sui/__tests__/toolbox.test.ts

@@ -0,0 +1,82 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { AssetValue, Chain } from "@uswap/helpers";
+import { getSuiToolbox } from "../toolbox";
+
+const TEST_PHRASE = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const KNOWN_SUI_ADDRESS = "0x57b861db681d8e47b586e6e9a92f6ed210dbbb440670b8122420848cf0e844fb";
+
+const context: { toolbox: Awaited<ReturnType<typeof getSuiToolbox>> } = {} as any;
+
+beforeAll(async () => {
+  context.toolbox = await getSuiToolbox({ phrase: TEST_PHRASE });
+});
+
+describe("Sui Toolbox", () => {
+  test("should validate valid Sui addresses", () => {
+    const validAddresses = [KNOWN_SUI_ADDRESS, "0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331"];
+
+    for (const address of validAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid Sui addresses", () => {
+    const invalidAddresses = [
+      "",
+      "invalid",
+      "0xG2a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should generate valid Sui address from phrase", () => {
+    const address = context.toolbox.getAddress();
+    expect(address?.startsWith("0x")).toBe(true);
+    if (address) {
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should fetch balance for known address", async () => {
+    const balances = await context.toolbox.getBalance(KNOWN_SUI_ADDRESS);
+    expect(balances[0]?.chain).toBe(Chain.Sui);
+    expect(balances[0]?.symbol).toBe("SUI");
+  });
+
+  test("should estimate transaction fee", async () => {
+    const fee = await context.toolbox.estimateTransactionFee();
+    expect(fee.chain).toBe(Chain.Sui);
+    expect(fee.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test.skip("should create transaction without broadcasting (needs real SUI for gas)", async () => {
+    const address = context.toolbox.getAddress();
+    if (!address) throw new Error("No address generated");
+
+    const { txBytes } = await context.toolbox.createTransaction({
+      assetValue: AssetValue.from({ chain: Chain.Sui, value: "0.001" }),
+      recipient: KNOWN_SUI_ADDRESS,
+      sender: address,
+    });
+
+    expect(txBytes.length).toBeGreaterThan(0);
+  });
+
+  test.skip("should sign transaction (needs real SUI for gas)", async () => {
+    const address = context.toolbox.getAddress();
+    if (!address) throw new Error("No address generated");
+
+    const signedTx = await context.toolbox.signTransaction({
+      assetValue: AssetValue.from({ chain: Chain.Sui, value: "0.001" }),
+      recipient: KNOWN_SUI_ADDRESS,
+      sender: address,
+    });
+
+    expect(signedTx.bytes.length).toBeGreaterThan(0);
+  });
+});

package/src/sui/index.ts

@@ -0,0 +1,2 @@
+export * from "./toolbox";
+export * from "./types";

package/src/sui/toolbox.ts

@@ -0,0 +1,165 @@
+import { AssetValue, Chain, getChainConfig, SwapKitError } from "@uswap/helpers";
+import { match, P } from "ts-pattern";
+import type { SuiCreateTransactionParams, SuiToolboxParams, SuiTransferParams } from "./types";
+
+export async function getSuiAddressValidator() {
+  const { isValidSuiAddress } = await import("@mysten/sui/utils");
+
+  return function validateAddress(address: string) {
+    try {
+      return isValidSuiAddress(address);
+    } catch {
+      return false;
+    }
+  };
+}
+
+export async function getSuiToolbox({ provider: providerParam, ...signerParams }: SuiToolboxParams = {}) {
+  const validateAddress = await getSuiAddressValidator();
+
+  const signer = await match(signerParams)
+    .with({ phrase: P.string }, async ({ phrase }) => {
+      const { Ed25519Keypair } = await import("@mysten/sui/keypairs/ed25519");
+      return Ed25519Keypair.deriveKeypair(phrase);
+    })
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  async function getSuiClient(url = providerParam) {
+    const { SuiClient, getFullnodeUrl } = await import("@mysten/sui/client");
+    return new SuiClient({ url: url || getFullnodeUrl("mainnet") });
+  }
+
+  function getAddress() {
+    return signer?.toSuiAddress() || "";
+  }
+
+  async function getBalance(targetAddress?: string) {
+    const addressToQuery = targetAddress || getAddress();
+    if (!addressToQuery) {
+      throw new SwapKitError("toolbox_sui_address_required" as any);
+    }
+
+    try {
+      const suiClient = await getSuiClient();
+      const { totalBalance } = await suiClient.getBalance({ owner: addressToQuery });
+      const { baseDecimal: fromBaseDecimal, chain } = getChainConfig(Chain.Sui);
+
+      const suiBalances = [AssetValue.from({ chain, fromBaseDecimal, value: totalBalance })];
+
+      const coinBalances = await suiClient.getAllBalances({ owner: addressToQuery });
+      for (const { coinType, totalBalance } of coinBalances) {
+        if (coinType === "0x2::sui::SUI") continue; // Skip SUI as we already added it
+
+        if (Number(totalBalance) > 0) {
+          const symbol = coinType.split("::").pop()?.toUpperCase() || "UNKNOWN";
+          const asset = `${chain}.${symbol}-${coinType}`;
+          // Default to 9 decimals, should be fetched from coin metadata
+          suiBalances.push(AssetValue.from({ asset, fromBaseDecimal, value: totalBalance }));
+        }
+      }
+
+      return suiBalances;
+    } catch (error) {
+      throw new SwapKitError("toolbox_sui_balance_error" as any, { error });
+    }
+  }
+
+  async function estimateTransactionFee(params?: SuiCreateTransactionParams) {
+    const defaultFee = AssetValue.from({ chain: Chain.Sui, value: "0.01" });
+
+    if (!params) return defaultFee;
+
+    try {
+      const suiClient = await getSuiClient();
+      const { txBytes } = await createTransaction(params);
+      const {
+        effects: { status, gasUsed },
+      } = await suiClient.dryRunTransactionBlock({ transactionBlock: txBytes });
+
+      if (status.status !== "success") return defaultFee;
+
+      const totalGas = Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate);
+
+      return AssetValue.from({ chain: Chain.Sui, value: totalGas.toString() });
+    } catch {
+      return defaultFee;
+    }
+  }
+
+  async function createTransaction({ recipient, assetValue, gasBudget, sender }: SuiCreateTransactionParams) {
+    const { Transaction } = await import("@mysten/sui/transactions");
+
+    const senderAddress = sender || getAddress();
+
+    if (!senderAddress) {
+      throw new SwapKitError("toolbox_sui_no_sender");
+    }
+
+    try {
+      const tx = new Transaction();
+      tx.setSender(senderAddress);
+
+      if (assetValue.isGasAsset || assetValue.symbol === "SUI") {
+        const [suiCoin] = tx.splitCoins(tx.gas, [assetValue.getBaseValue("string")]);
+        tx.transferObjects([suiCoin], recipient);
+      } else {
+        throw new SwapKitError("toolbox_sui_custom_token_transfer_not_implemented" as any);
+      }
+
+      if (gasBudget) {
+        tx.setGasBudget(gasBudget);
+      }
+
+      const suiClient = await getSuiClient();
+      const txBytes = await tx.build({ client: suiClient });
+
+      return { tx, txBytes };
+    } catch (error) {
+      throw new SwapKitError("toolbox_sui_transaction_creation_error" as any, { error });
+    }
+  }
+
+  async function signTransaction(
+    params: Uint8Array<ArrayBuffer> | SuiCreateTransactionParams | Awaited<ReturnType<typeof createTransaction>>,
+  ) {
+    if (!signer) {
+      throw new SwapKitError("toolbox_sui_no_signer");
+    }
+
+    if (params instanceof Uint8Array) {
+      return signer.signTransaction(params);
+    }
+
+    const { txBytes } = "tx" in params ? params : await createTransaction(params);
+
+    return signer.signTransaction(txBytes);
+  }
+
+  async function transfer({ assetValue, gasBudget, recipient }: SuiTransferParams) {
+    if (!signer) {
+      throw new SwapKitError("toolbox_sui_no_signer" as any);
+    }
+
+    const sender = signer.toSuiAddress() || getAddress();
+    if (!sender) {
+      throw new SwapKitError("toolbox_sui_no_sender");
+    }
+
+    const { txBytes } = await createTransaction({ assetValue, gasBudget, recipient, sender });
+    const suiClient = await getSuiClient();
+    const { digest: txHash } = await suiClient.signAndExecuteTransaction({ signer, transaction: txBytes });
+
+    return txHash;
+  }
+
+  return {
+    createTransaction,
+    estimateTransactionFee,
+    getAddress,
+    getBalance,
+    signTransaction,
+    transfer,
+    validateAddress,
+  };
+}

package/src/sui/types.ts

@@ -0,0 +1,11 @@
+import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import type { GenericCreateTransactionParams, GenericTransferParams } from "@uswap/helpers";
+import type { getSuiToolbox } from "./toolbox";
+
+export type SuiWallet = Awaited<ReturnType<typeof getSuiToolbox>>;
+
+export type SuiCreateTransactionParams = Omit<GenericCreateTransactionParams, "feeRate"> & { gasBudget?: number };
+
+export type SuiTransferParams = Omit<GenericTransferParams, "feeRate"> & { gasBudget?: number };
+
+export type SuiToolboxParams = { provider?: string; phrase?: string; signer?: Ed25519Keypair };