@swapkit/wallets 4.0.0-beta.53 → 4.0.0-beta.55

package/src/keepkey/chains/cosmos.ts

@@ -1,78 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  Chain,
-  ChainId,
-  DerivationPath,
-  type DerivationPathArray,
-  SKConfig,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { GenericTransferParams } from "@swapkit/helpers";
-
-import { bip32ToAddressNList } from "../coins";
-
-export const cosmosWalletMethods = async ({
-  sdk,
-  derivationPath,
-}: { sdk: KeepKeySdk; derivationPath?: DerivationPathArray }) => {
-  const {
-    DEFAULT_COSMOS_FEE_MAINNET,
-    getCosmosToolbox,
-    getFeeRateFromSwapKit,
-    createStargateClient,
-  } = await import("@swapkit/toolboxes/cosmos");
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath.GAIA}/0`;
-
-  const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  })) as { address: string };
-
-  const toolbox = await getCosmosToolbox(Chain.Cosmos);
-
-  if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
-    DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-      await getFeeRateFromSwapKit(ChainId.Cosmos, 500),
-    );
-  }
-
-  // TODO support other cosmos assets
-  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-    const amount = assetValue.getBaseValue("string");
-    const accountInfo = await toolbox.getAccount(fromAddress);
-
-    const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
-      signerAddress: fromAddress,
-      signDoc: {
-        fee: DEFAULT_COSMOS_FEE_MAINNET,
-        memo: memo || "",
-        sequence: accountInfo?.sequence.toString() ?? "",
-        chain_id: ChainId.Cosmos,
-        account_number: accountInfo?.accountNumber.toString() ?? "",
-        msgs: [
-          {
-            value: {
-              amount: [{ denom: "uatom", amount }],
-              to_address: recipient,
-              from_address: fromAddress,
-            },
-            type: "cosmos-sdk/MsgSend",
-          },
-        ],
-      },
-    });
-
-    const decodedBytes = atob(keepKeySignedTx.serialized);
-    const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
-      decodedBytes.charCodeAt(i),
-    );
-
-    const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
-    const response = await client.broadcastTx(uint8Array);
-
-    return response.transactionHash;
-  };
-
-  return { ...toolbox, transfer, address: fromAddress };
-};

package/src/keepkey/chains/evm.ts

@@ -1,125 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  type Chain,
-  ChainToChainId,
-  type DerivationPathArray,
-  NetworkDerivationPath,
-  SwapKitError,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
-import { AbstractSigner } from "ethers";
-
-import { bip32ToAddressNList } from "../coins";
-
-interface KeepKeyEVMSignerParams {
-  sdk: KeepKeySdk;
-  chain: Chain;
-  derivationPath?: DerivationPathArray;
-  provider: Provider | JsonRpcProvider;
-}
-
-export class KeepKeySigner extends AbstractSigner {
-  private sdk: KeepKeySdk;
-  private chain: Chain;
-  private derivationPath: DerivationPathArray;
-  private address: string;
-  readonly provider: Provider | JsonRpcProvider;
-
-  constructor({ sdk, chain, derivationPath, provider }: KeepKeyEVMSignerParams) {
-    super();
-    this.sdk = sdk;
-    this.chain = chain;
-    this.derivationPath = derivationPath || NetworkDerivationPath.ETH;
-    this.address = "";
-    this.provider = provider;
-  }
-
-  signTypedData(): Promise<string> {
-    throw new SwapKitError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
-  }
-
-  getAddress = async () => {
-    if (this.address) return this.address;
-    const { address } = await this.sdk.address.ethereumGetAddress({
-      address_n: bip32ToAddressNList(derivationPathToString(this.derivationPath)),
-    });
-
-    this.address = address;
-    return address;
-  };
-
-  signMessage = (message: string) =>
-    this.sdk.eth.ethSign({ address: this.address, message }) as Promise<string>;
-
-  signTransaction = async ({
-    to,
-    value,
-    gasLimit,
-    nonce,
-    data,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    gasPrice,
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-  }: TransactionRequest) => {
-    if (!to)
-      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
-    if (!gasLimit)
-      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
-    if (!data) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing data" });
-
-    const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
-    if (isEIP1559 && !maxFeePerGas)
-      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
-    if (isEIP1559 && !maxPriorityFeePerGas)
-      throw new SwapKitError("wallet_keepkey_invalid_params", {
-        reason: "Missing maxPriorityFeePerGas",
-      });
-    if (!(isEIP1559 || gasPrice))
-      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
-
-    const { toHexString } = await import("@swapkit/toolboxes/evm");
-
-    const nonceValue = nonce
-      ? BigInt(nonce)
-      : BigInt(await this.provider.getTransactionCount(await this.getAddress(), "pending"));
-
-    const input = {
-      gas: toHexString(BigInt(gasLimit)),
-      addressNList: [2147483692, 2147483708, 2147483648, 0, 0],
-      from: this.address,
-      chainId: toHexString(BigInt(ChainToChainId[this.chain])),
-      to: to.toString(),
-      value: toHexString(BigInt(value || 0)),
-      nonce: toHexString(nonceValue),
-      data,
-      ...(isEIP1559 && {
-        maxFeePerGas: toHexString(BigInt(maxFeePerGas?.toString() || "0")),
-        maxPriorityFeePerGas: toHexString(BigInt(maxPriorityFeePerGas?.toString() || "0")),
-      }),
-      ...(!isEIP1559 && {
-        // Fixed syntax error and structure here
-        gasPrice: toHexString(BigInt(gasPrice?.toString() || "0")),
-      }),
-    };
-    const responseSign = await this.sdk.eth.ethSignTransaction(input);
-    return responseSign.serialized;
-  };
-
-  sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new SwapKitError("wallet_keepkey_no_provider");
-
-    const signedTxHex = await this.signTransaction(tx);
-
-    return await this.provider.broadcastTransaction(signedTxHex);
-  };
-
-  connect = (provider: Provider) =>
-    new KeepKeySigner({
-      sdk: this.sdk,
-      chain: this.chain,
-      derivationPath: this.derivationPath,
-      provider,
-    });
-}

package/src/keepkey/chains/mayachain.ts

@@ -1,123 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  type AssetValue,
-  Chain,
-  ChainId,
-  DerivationPath,
-  type DerivationPathArray,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
-
-import { bip32ToAddressNList } from "../coins";
-
-type SignTransactionParams = {
-  assetValue: AssetValue;
-  recipient?: string;
-  sender: string;
-  memo: string | undefined;
-};
-
-export const mayachainWalletMethods = async ({
-  sdk,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  derivationPath?: DerivationPathArray;
-}) => {
-  const { createStargateClient, getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
-
-  const toolbox = await getCosmosToolbox(Chain.Maya);
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath.MAYA}/0`;
-
-  const { address: fromAddress } = (await sdk.address.mayachainGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  })) as { address: string };
-
-  const signTransaction = async ({
-    assetValue,
-    recipient,
-    sender,
-    memo,
-  }: SignTransactionParams) => {
-    const importedAmino = await import("@cosmjs/amino");
-    const makeSignDoc = importedAmino.makeSignDoc ?? importedAmino.default?.makeSignDoc;
-    const { getDenomWithChain } = await import("@swapkit/toolboxes/cosmos");
-
-    const account = await toolbox.getAccount(sender);
-    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
-    const { accountNumber, sequence = 0 } = account;
-    const amount = assetValue.getBaseValue("string");
-
-    const isTransfer = recipient && recipient !== "";
-
-    // TODO check if we can move to toolbox created msg
-    const msg = isTransfer
-      ? {
-          type: "mayachain/MsgSend",
-          value: {
-            amount: [{ amount, denom: assetValue.symbol.toLowerCase() }],
-            from_address: sender,
-            to_address: recipient,
-          },
-        }
-      : {
-          type: "mayachain/MsgDeposit",
-          value: {
-            coins: [{ amount, asset: getDenomWithChain(assetValue) }],
-            memo,
-            signer: sender,
-          },
-        };
-
-    const signDoc = makeSignDoc(
-      [msg],
-      { gas: "500000000", amount: [] },
-      ChainId.Maya,
-      memo,
-      accountNumber?.toString(),
-      sequence,
-    );
-
-    const sdkMethod = isTransfer
-      ? sdk.mayachain.mayachainSignAminoTransfer
-      : sdk.mayachain.mayachainSignAminoDeposit;
-
-    // @ts-expect-error TC
-    const signedTx = await sdkMethod({ signDoc, signerAddress: sender });
-    const decodedBytes = atob(signedTx.serialized);
-    return new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
-  };
-
-  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-    const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Maya]);
-    const signedTransaction = await signTransaction({
-      assetValue,
-      recipient,
-      memo,
-      sender: fromAddress,
-    });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  const deposit = async ({ assetValue, memo }: ThorchainDepositParams) => {
-    const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Maya]);
-    const signedTransaction = await signTransaction({
-      assetValue,
-      memo,
-      sender: fromAddress,
-    });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  return { ...toolbox, transfer, deposit, address: fromAddress };
-};

package/src/keepkey/chains/ripple.ts

@@ -1,118 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  Chain,
-  DerivationPath,
-  type DerivationPathArray,
-  type GenericTransferParams,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import { bip32ToAddressNList } from "../coins";
-
-import { getRippleToolbox } from "@swapkit/toolboxes/ripple";
-
-export const rippleWalletMethods = async ({
-  sdk,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  derivationPath?: DerivationPathArray;
-}) => {
-  // Derivation path handling (default to standard XRP 44'/144'/0'/0/0)
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath[Chain.Ripple]}/0`;
-
-  // Fetch address from KeepKey
-  // @ts-ignore - keepkey-sdk typings may not yet include xrpGetAddress
-  const { address } = await (sdk as any).address.xrpGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  });
-
-  // Inject minimal signer so toolbox's address helpers work
-  const signer = {
-    getAddress: () => Promise.resolve(address),
-    signTransaction: () => {
-      throw new Error("signTransaction not supported via toolbox");
-    },
-  };
-
-  const toolbox = await getRippleToolbox({ signer });
-
-  const transfer = async ({ recipient, assetValue, memo }: GenericTransferParams) => {
-    // Build XRPL Payment tx using toolbox helper
-    const tx = await toolbox.createTransaction({
-      assetValue,
-      recipient,
-      memo,
-      sender: address,
-    });
-
-    // Convert toolbox Payment tx into KeepKey StdTx wrapper (KeepKey-specific format)
-    const stdTx = {
-      type: "auth/StdTx",
-      value: {
-        fee: {
-          amount: [
-            {
-              amount: "1000",
-              denom: "drop",
-            },
-          ],
-          gas: "28000",
-        },
-        memo: memo && memo.length > 0 ? memo : "",
-        msg: [
-          {
-            type: "ripple-sdk/MsgSend",
-            value: {
-              amount: [
-                {
-                  amount: tx.Amount,
-                  denom: "drop",
-                },
-              ],
-              from_address: address,
-              to_address: recipient,
-            },
-          },
-        ],
-        signatures: null,
-      },
-    };
-
-    const unsignedTx = {
-      addressNList: bip32ToAddressNList(derivationPathString),
-      tx: stdTx,
-      flags: tx.Flags === 0 ? undefined : tx.Flags,
-      lastLedgerSequence: tx.LastLedgerSequence?.toString(),
-      sequence: (tx.Sequence ?? 0).toString(),
-      payment: {
-        amount: tx.Amount,
-        destination: tx.Destination,
-        destinationTag: (tx.DestinationTag ?? "0").toString(),
-      },
-    } as any;
-
-    // Sign with KeepKey
-    // @ts-ignore - typings missing
-    const responseSign = JSON.parse(await (sdk as any).xrp.xrpSignTransaction(unsignedTx));
-
-    // keepkey-sdk may return either { tx_blob } or StdTx with Base64 serializedTx
-    const txBlob: string | undefined =
-      (responseSign as any).tx_blob ?? (responseSign as any).value?.signatures?.[0]?.serializedTx;
-    if (!txBlob) throw new Error("KeepKey XRP sign failed");
-
-    const buffer = Buffer.from(txBlob, "base64");
-    const txBlobHex = buffer.toString("hex");
-
-    // Broadcast signed tx via toolbox
-    return toolbox.broadcastTransaction(txBlobHex);
-  };
-
-  return {
-    ...toolbox,
-    address,
-    getAddress: () => address,
-    transfer,
-  };
-};

package/src/keepkey/chains/thorchain.ts

@@ -1,118 +0,0 @@
-import type {
-  KeepKeySdk,
-  TypesThorchainSignDocDeposit,
-  TypesThorchainSignDocTransfer,
-} from "@keepkey/keepkey-sdk";
-import {
-  type AssetValue,
-  Chain,
-  ChainId,
-  DerivationPath,
-  type DerivationPathArray,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
-
-import { bip32ToAddressNList } from "../coins";
-
-type SignTransactionParams = {
-  assetValue: AssetValue;
-  recipient?: string;
-  sender: string;
-  memo: string | undefined;
-};
-
-export const thorchainWalletMethods = async ({
-  sdk,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  derivationPath?: DerivationPathArray;
-}) => {
-  const importedAmino = await import("@cosmjs/amino");
-  const makeSignDoc = importedAmino.makeSignDoc ?? importedAmino.default?.makeSignDoc;
-  const { buildAminoMsg, getDefaultChainFee, createStargateClient, getCosmosToolbox } =
-    await import("@swapkit/toolboxes/cosmos");
-
-  const toolbox = await getCosmosToolbox(Chain.THORChain);
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath.THOR}/0`;
-
-  const { address: fromAddress } = (await sdk.address.thorchainGetAddress({
-    address_n: bip32ToAddressNList(derivationPathString),
-  })) as { address: string };
-
-  const signTransaction = async ({
-    assetValue,
-    recipient,
-    sender,
-    memo,
-  }: SignTransactionParams) => {
-    const account = await toolbox.getAccount(sender);
-    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
-    const { accountNumber, sequence = 0 } = account;
-
-    const isTransfer = recipient && recipient !== "";
-
-    const msg = buildAminoMsg({ sender, recipient, assetValue, memo });
-
-    const chainId = ChainId.THORChain;
-
-    const signDoc = makeSignDoc(
-      [msg],
-      getDefaultChainFee(Chain.THORChain),
-      chainId,
-      memo,
-      accountNumber?.toString(),
-      sequence,
-    );
-
-    const signedTx = isTransfer
-      ? await sdk.thorchain.thorchainSignAminoTransfer({
-          signDoc: signDoc as TypesThorchainSignDocTransfer,
-          signerAddress: sender,
-        })
-      : await sdk.thorchain.thorchainSignAminoDeposit({
-          signDoc: signDoc as TypesThorchainSignDocDeposit,
-          signerAddress: sender,
-        });
-    const decodedBytes = atob(signedTx.serialized);
-    return new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
-  };
-
-  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-    const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.THORChain]);
-    const signedTransaction = await signTransaction({
-      assetValue,
-      recipient,
-      memo,
-      sender: fromAddress,
-    });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  const deposit = async ({ assetValue, memo }: ThorchainDepositParams) => {
-    const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.THORChain]);
-    const signedTransaction = await signTransaction({
-      assetValue,
-      memo,
-      sender: fromAddress,
-    });
-    const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
-
-    return transactionHash;
-  };
-
-  // const signMessage = async (message: string) => {
-  //   const stargateClient = await createStargateClient(RPCUrl.THORChain);
-  //   // return signedTx;
-  // };
-
-  return { ...toolbox, transfer, deposit, address: fromAddress };
-};

package/src/keepkey/chains/utxo.ts

@@ -1,147 +0,0 @@
-import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
-import {
-  Chain,
-  DerivationPath,
-  type DerivationPathArray,
-  FeeOption,
-  type GenericTransferParams,
-  SwapKitError,
-  type UTXOChain,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { Psbt } from "bitcoinjs-lib";
-
-import type { UTXOToolboxes } from "@swapkit/toolboxes/utxo";
-import { ChainToKeepKeyName, bip32ToAddressNList } from "../coins";
-
-interface KeepKeyInputObject {
-  addressNList: number[];
-  scriptType: string;
-  amount: string;
-  vout: number;
-  txid: string;
-  hex: string;
-}
-
-export const utxoWalletMethods = async ({
-  sdk,
-  chain,
-  derivationPath,
-}: {
-  sdk: KeepKeySdk;
-  chain: Exclude<UTXOChain, Chain.Zcash>;
-  derivationPath?: DerivationPathArray;
-}) => {
-  const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-  // This might not work for BCH
-  const toolbox = await getUtxoToolbox(chain);
-  const scriptType = [Chain.Bitcoin, Chain.Litecoin].includes(chain)
-    ? ("p2wpkh" as const)
-    : ("p2pkh" as const);
-
-  const derivationPathString = derivationPath
-    ? derivationPathToString(derivationPath)
-    : `${DerivationPath[chain]}/0`;
-
-  const addressInfo = {
-    coin: ChainToKeepKeyName[chain],
-    script_type: scriptType,
-    address_n: bip32ToAddressNList(derivationPathString),
-  };
-
-  const walletAddress: string = (await sdk.address.utxoGetAddress(addressInfo)).address;
-
-  const signTransaction = async (psbt: Psbt, inputs: KeepKeyInputObject[], memo = "") => {
-    const outputs = psbt.txOutputs
-      .map((output) => {
-        const { value, address, change } = output as {
-          address: string;
-          script: Buffer;
-          value: number;
-          change?: boolean;
-        };
-
-        const outputAddress =
-          // @ts-expect-error - stripToCashAddress is not defined in the UTXO toolbox just only on BCH
-          chain === Chain.BitcoinCash ? toolbox.stripToCashAddress(address) : address;
-
-        if (change || address === walletAddress) {
-          return {
-            addressNList: addressInfo.address_n,
-            isChange: true,
-            addressType: "change",
-            amount: value,
-            scriptType,
-          };
-        }
-
-        if (outputAddress) {
-          return { address: outputAddress, amount: value, addressType: "spend" };
-        }
-
-        return null;
-      })
-      .filter(Boolean);
-
-    const removeNullAndEmptyObjectsFromArray = (arr: any[]) => {
-      return arr.filter(
-        (item) => item !== null && typeof item === "object" && Object.keys(item).length > 0,
-      );
-    };
-
-    const responseSign = await sdk.utxo.utxoSignTransaction({
-      coin: ChainToKeepKeyName[chain],
-      inputs,
-      outputs: removeNullAndEmptyObjectsFromArray(outputs),
-      opReturnData: memo,
-    });
-
-    return responseSign.serializedTx?.toString();
-  };
-
-  const transfer = async ({
-    recipient,
-    feeOptionKey,
-    feeRate,
-    memo,
-    ...rest
-  }: GenericTransferParams) => {
-    if (!walletAddress)
-      throw new SwapKitError("wallet_keepkey_invalid_params", {
-        reason: "From address must be provided",
-      });
-    if (!recipient)
-      throw new SwapKitError("wallet_keepkey_invalid_params", {
-        reason: "Recipient address must be provided",
-      });
-
-    const createTxMethod =
-      chain === Chain.BitcoinCash
-        ? (toolbox as UTXOToolboxes["BCH"]).buildTx
-        : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
-
-    const { psbt, inputs: rawInputs } = await createTxMethod({
-      ...rest,
-      memo,
-      recipient,
-      feeRate: feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast],
-      sender: walletAddress,
-      fetchTxHex: true,
-    });
-
-    const inputs = rawInputs.map(({ value, index, hash, txHex }) => ({
-      //@TODO don't hardcode master, lookup on blockbook what input this is for and what path that address is!
-      addressNList: addressInfo.address_n,
-      amount: value.toString(),
-      hex: txHex || "",
-      scriptType,
-      txid: hash,
-      vout: index,
-    }));
-
-    const txHex = await signTransaction(psbt, inputs, memo);
-    return toolbox.broadcastTx(txHex);
-  };
-
-  return { ...toolbox, signTransaction, transfer, address: walletAddress };
-};