@funkit/connect 9.24.0-next.0 → 9.25.0

package/dist/clients/chunk-YYMIRDCQ.js

@@ -1,230 +0,0 @@
-"use client";
-import {
-  Box
-} from "./chunk-JBWB54MX.js";
-import {
-  logger
-} from "./chunk-UUHGOBKZ.js";
-
-// src/components/AsyncImage/useAsyncImage.ts
-import { useEffect, useReducer } from "react";
-var cachedUrls = /* @__PURE__ */ new Map();
-var cachedRequestPromises = /* @__PURE__ */ new Map();
-async function loadAsyncImage(asyncImage) {
-  const cachedRequestPromise = cachedRequestPromises.get(asyncImage);
-  if (cachedRequestPromise) {
-    return cachedRequestPromise;
-  }
-  const load = async () => asyncImage().then(async (url) => {
-    cachedUrls.set(asyncImage, url);
-    return url;
-  });
-  const requestPromise = load().catch(async () => {
-    return load().catch(() => {
-      cachedRequestPromises.delete(asyncImage);
-      return void 0;
-    });
-  });
-  cachedRequestPromises.set(asyncImage, requestPromise);
-  return requestPromise;
-}
-function useForceUpdate() {
-  const [, forceUpdate] = useReducer((x) => x + 1, 0);
-  return forceUpdate;
-}
-function useAsyncImage(url) {
-  const cachedUrl = typeof url === "function" ? cachedUrls.get(url) : void 0;
-  const forceUpdate = useForceUpdate();
-  useEffect(() => {
-    if (typeof url === "function" && !cachedUrl) {
-      loadAsyncImage(url).then(forceUpdate);
-    }
-  }, [url, cachedUrl, forceUpdate]);
-  return typeof url === "function" ? cachedUrl : url;
-}
-var REMOTE_IMG_CACHE = /* @__PURE__ */ new Set();
-function preloadRemoteImages(...imageUrls) {
-  for (const imageUrl of imageUrls) {
-    try {
-      const { protocol } = new URL(imageUrl);
-      if (protocol !== "https:" && protocol !== "http:") {
-        logger.warn("preloadRemoteImages:invalidUrl", {
-          message: "Invalid protocol",
-          imageUrl
-        });
-        continue;
-      }
-      if (!REMOTE_IMG_CACHE.has(imageUrl)) {
-        REMOTE_IMG_CACHE.add(imageUrl);
-        const preloadImage = new Image();
-        preloadImage.src = imageUrl;
-      }
-    } catch (error) {
-      logger.warn("preloadRemoteImages:error", {
-        message: "Unable to preload image",
-        imageUrl,
-        error
-      });
-    }
-  }
-}
-
-// src/components/AsyncImage/AsyncImage.tsx
-import React, { useMemo, useReducer as useReducer2, useState } from "react";
-
-// src/utils/sanitizeUrl.ts
-var SAFE_URL_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
-function sanitizeUrl(url) {
-  if (!url) {
-    return void 0;
-  }
-  try {
-    const parsed = new URL(url);
-    if (SAFE_URL_PROTOCOLS.has(parsed.protocol)) {
-      return parsed.href;
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-function sanitizeCssUrl(url) {
-  const safeUrl = sanitizeUrl(url);
-  if (!safeUrl) {
-    return void 0;
-  }
-  return safeUrl.replace(/['()\\]/g, (char) => {
-    return `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`;
-  });
-}
-
-// src/components/AsyncImage/AsyncImage.tsx
-function useTriggeredOnce() {
-  return useReducer2(() => true, false);
-}
-function AsyncImage({
-  alt,
-  background,
-  borderColor,
-  borderRadius,
-  boxShadow,
-  height,
-  useAsImage,
-  src: srcProp,
-  fallbackSrc,
-  fallbackElement,
-  width,
-  testId
-}) {
-  const src = useAsyncImage(srcProp || fallbackSrc);
-  const isRemoteImage = src !== void 0 && /^(https?|data):/.test(src);
-  const [isRemoteImageLoaded, setRemoteImageLoaded] = useTriggeredOnce();
-  const [hasError, setHasError] = useState(
-    srcProp === void 0 && fallbackSrc === void 0
-  );
-  const { asyncStyle, imgProps } = useMemo(() => {
-    const asyncStyle2 = !useAsImage ? getRemoteImageStyles(isRemoteImage, isRemoteImageLoaded, src) : {};
-    if (useAsImage || isRemoteImage) {
-      const imgProps2 = {
-        as: "img",
-        src,
-        "aria-hidden": true,
-        onError: ({
-          currentTarget
-        }) => {
-          currentTarget.onerror = null;
-          if (fallbackSrc !== void 0) {
-            currentTarget.src = fallbackSrc;
-          } else {
-            setHasError(true);
-          }
-        },
-        onLoad: isRemoteImage ? setRemoteImageLoaded : void 0
-      };
-      return { imgProps: imgProps2, asyncStyle: asyncStyle2 };
-    }
-    return {
-      imgProps: {
-        backgroundSize: "cover"
-      },
-      asyncStyle: {
-        ...asyncStyle2,
-        // has to be added as a inline style because vanilla-extract doesn't recognize this as a valid style
-        backgroundPosition: "center"
-      }
-    };
-  }, [
-    fallbackSrc,
-    isRemoteImage,
-    isRemoteImageLoaded,
-    src,
-    useAsImage,
-    setRemoteImageLoaded
-  ]);
-  const mainElement = hasError && fallbackElement || /* @__PURE__ */ React.createElement(
-    Box,
-    {
-      ...imgProps,
-      height: "full",
-      position: "absolute",
-      style: {
-        WebkitTouchCallout: "none",
-        transition: "opacity .15s linear",
-        userSelect: "none",
-        ...asyncStyle
-      },
-      width: "full"
-    }
-  );
-  return /* @__PURE__ */ React.createElement(
-    Box,
-    {
-      "aria-label": alt,
-      borderRadius,
-      boxShadow,
-      height: typeof height === "string" ? height : void 0,
-      overflow: "hidden",
-      position: "relative",
-      role: "img",
-      style: {
-        background,
-        height: typeof height === "number" ? height : void 0,
-        width: typeof width === "number" ? width : void 0
-      },
-      width: typeof width === "string" ? width : void 0,
-      testId
-    },
-    mainElement,
-    borderColor ? /* @__PURE__ */ React.createElement(
-      Box,
-      {
-        ...typeof borderColor === "object" && "custom" in borderColor ? { style: { borderColor: borderColor.custom } } : { borderColor },
-        borderRadius,
-        borderStyle: "solid",
-        borderWidth: "1",
-        height: "full",
-        position: "relative",
-        width: "full"
-      }
-    ) : null
-  );
-}
-var getRemoteImageStyles = (isRemoteImage, isRemoteImageLoaded, src) => {
-  if (isRemoteImage) {
-    return {
-      opacity: isRemoteImageLoaded ? 1 : 0
-    };
-  }
-  const safeSrc = sanitizeCssUrl(src);
-  return {
-    // note the url must have quotation, see https://github.com/evanw/esbuild/issues/1843#issuecomment-1370108070
-    backgroundImage: safeSrc ? `url('${safeSrc}')` : void 0,
-    backgroundRepeat: "no-repeat",
-    opacity: src ? 1 : 0
-  };
-};
-
-export {
-  preloadRemoteImages,
-  AsyncImage
-};

package/dist/clients/chunk-ZNVFASTH.js

@@ -1,54 +0,0 @@
-"use client";
-import {
-  Box
-} from "./chunk-7FIVHWNC.js";
-
-// src/components/Text/Text.tsx
-import React from "react";
-var Text = React.forwardRef(
-  ({
-    as = "div",
-    children,
-    className,
-    color = "primaryText",
-    display,
-    font = "body",
-    id,
-    size = "16",
-    style,
-    tabIndex,
-    title,
-    textAlign = "inherit",
-    textTransform = "none",
-    weight = "regular",
-    testId
-  }, ref) => {
-    return /* @__PURE__ */ React.createElement(
-      Box,
-      {
-        as,
-        className,
-        color: color === "inherit" ? void 0 : color,
-        display,
-        fontFamily: font,
-        fontSize: size,
-        fontWeight: weight,
-        id,
-        title,
-        ref,
-        style,
-        tabIndex,
-        textAlign,
-        textTransform,
-        testId,
-        background: { selection: "textSelection" }
-      },
-      children
-    );
-  }
-);
-Text.displayName = "Text";
-
-export {
-  Text
-};

package/dist/clients/nado.d.ts

@@ -1,78 +0,0 @@
-/**
- * Nado deposit routed through the Ink VaultDepositooor.
- *
- * Each deposit is a 2-action batch:
- *   1. approve(collateralToken, VAULT_DEPOSITOR, maxUint256)   — covers the live balance pull
- *   2. VAULT_DEPOSITOR.deposit(collateralToken, NADO_ENDPOINT, calldata, 0)
- *
- * No zero-first approve reset: USDT0 on Ink (TetherTokenOFTExtension) inherits
- * OpenZeppelin's plain approve — verified on the Ink explorer, no legacy
- * non-zero->non-zero revert — and the other collaterals are standard OZ tokens.
- *
- * The Endpoint calldata carries AMOUNT_PLACEHOLDER where the uint128 amount
- * goes; the VaultDepositooor injects its caller's LIVE collateral balance over
- * the placeholder before calling the Endpoint. That makes the deposit robust
- * to bridge fee drift: whatever actually arrived is what gets deposited, with
- * no under-funded revert and no dust stranded on the EOA. The selector is the
- * canonical uint128 one (0x221f0939, registered for the Endpoint on the Ink
- * VaultDepositooor) while the head encodes the amount slot as uint256 so the
- * 32-byte placeholder word fits — uint128 and uint256 head-encode identically.
- *
- * `subaccount` packs the recipient address (high 20 bytes) with the
- * subaccount name "default" (right-padded to the remaining 12 bytes) into a
- * single bytes32 word. `productId` is per-collateral and is looked up by the
- * integrator from the Nado SpotEngine allowlist.
- *
- * Spec: https://www.notion.so/the-fun-group/37bfc3b2a002816bac41c920902e03c2
- */
-import { type Address, type Hex } from 'viem';
-import type { FunkitCheckoutActionParams } from '../providers/FunkitCheckoutContext/types';
-/** Nado Endpoint on Ink mainnet (chain 57073). */
-export declare const NADO_ENDPOINT_ADDRESS: `0x${string}`;
-/** VaultDepositooor on Ink — fresh CREATE3 deploy (differs from the canonical
- *  address on other chains). The Nado Endpoint is registered on it with
- *  selector 0x221f0939 and no decimal conversion. Mirrors
- *  VAULT_DEPOSITOR_ADDRESSES[INK] in fun-backend's packages/types. */
-export declare const INK_VAULT_DEPOSITOR_ADDRESS: `0x${string}`;
-/** Sentinel value Nado treats as "no referral". */
-export declare const NADO_NO_REFERRAL_CODE = "-1";
-/** Default subaccount name used by the Nado UI/SDK. */
-export declare const NADO_DEFAULT_SUBACCOUNT_NAME = "default";
-/**
- * Build a Nado `bytes32` subaccount from an owner address and subaccount
- * name. Layout: `[owner (20 bytes)] [name (right-padded to 12 bytes)]`.
- *
- * Throws if `name` encodes to more than 12 bytes — without this, `pad()`
- * surfaces viem's opaque `SizeExceedsPaddingSizeError`.
- */
-export declare function buildNadoSubaccount(owner: Address, name?: string): Hex;
-export interface NadoDepositActionsConfig {
-    /** Address credited on Nado (typically the connected wallet). */
-    recipientAddress: Address | undefined;
-    /** Collateral ERC20 on Ink being deposited (USDT0, kBTC, WETH, USDC, ...). */
-    collateralTokenAddress: Address;
-    /** Nado SpotEngine productId for the collateral token. */
-    productId: number;
-    /** Optional subaccount name. Defaults to "default". */
-    subaccountName?: string;
-    /** Optional referral code. Defaults to the no-referral sentinel "-1". */
-    referralCode?: string;
-}
-/**
- * Builds the 2-action batch (approve + deposit) for a Nado collateral
- * deposit routed through the Endpoint.
- *
- * Usage:
- * ```ts
- * const checkoutConfig: FunkitCheckoutConfig = {
- *   // ...
- *   generateActionsParams: () => async (amount, output) =>
- *     createNadoDepositActions({
- *       recipientAddress: walletAddress,
- *       collateralTokenAddress: output.targetAsset,
- *       productId: NADO_PRODUCT_ID_BY_TOKEN[output.targetAsset],
- *     }),
- * }
- * ```
- */
-export declare function createNadoDepositActions(config: NadoDepositActionsConfig): FunkitCheckoutActionParams[];

package/dist/clients/nado.js

@@ -1,107 +0,0 @@
-"use client";
-
-// src/clients/nado.tsx
-import {
-  concat,
-  encodeAbiParameters,
-  erc20Abi,
-  getAddress,
-  maxUint256,
-  pad,
-  stringToHex,
-  toFunctionSelector
-} from "viem";
-var NADO_ENDPOINT_ADDRESS = getAddress(
-  "0x05ec92d78ed421f3d3ada77ffde167106565974e"
-);
-var INK_VAULT_DEPOSITOR_ADDRESS = getAddress(
-  "0xDB9d579B0DCbf566E372C73A2e374c44B161E1Ee"
-);
-var AMOUNT_PLACEHOLDER = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffdeadbeefn;
-var VAULT_DEPOSITOR_ABI = [
-  {
-    name: "deposit",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "token", type: "address" },
-      { name: "vault", type: "address" },
-      { name: "callData", type: "bytes" },
-      { name: "minAmountOut", type: "uint256" }
-    ],
-    outputs: []
-  }
-];
-var NADO_NO_REFERRAL_CODE = "-1";
-var NADO_DEFAULT_SUBACCOUNT_NAME = "default";
-var NADO_SUBACCOUNT_NAME_MAX_BYTES = 12;
-function buildNadoSubaccount(owner, name = NADO_DEFAULT_SUBACCOUNT_NAME) {
-  const nameHex = stringToHex(name);
-  const nameByteLength = (nameHex.length - 2) / 2;
-  if (nameByteLength > NADO_SUBACCOUNT_NAME_MAX_BYTES) {
-    throw new Error(
-      `Nado subaccount name must encode to \u2264 ${NADO_SUBACCOUNT_NAME_MAX_BYTES} bytes (got ${nameByteLength}: "${name}")`
-    );
-  }
-  return concat([
-    owner,
-    pad(nameHex, { dir: "right", size: NADO_SUBACCOUNT_NAME_MAX_BYTES })
-  ]);
-}
-function createNadoDepositActions(config) {
-  const {
-    recipientAddress,
-    collateralTokenAddress,
-    productId,
-    subaccountName,
-    referralCode = NADO_NO_REFERRAL_CODE
-  } = config;
-  if (!recipientAddress) {
-    throw new Error("Please connect your wallet before starting a Nado deposit");
-  }
-  const collateral = getAddress(collateralTokenAddress);
-  const subaccount = buildNadoSubaccount(recipientAddress, subaccountName);
-  const depositCalldata = concat([
-    toFunctionSelector(
-      "depositCollateralWithReferral(bytes32,uint32,uint128,string)"
-    ),
-    encodeAbiParameters(
-      [
-        { type: "bytes32" },
-        { type: "uint32" },
-        { type: "uint256" },
-        { type: "string" }
-      ],
-      [subaccount, productId, AMOUNT_PLACEHOLDER, referralCode]
-    )
-  ]);
-  return [
-    // MAX approve so the pull covers whatever balance actually arrived (the
-    // amount is only known at execution); the spender is Fun's own audited
-    // VaultDepositooor. No zero-first reset needed: Ink USDT0 uses plain OZ
-    // approve (verified), unlike legacy mainnet USDT.
-    {
-      contractAbi: erc20Abi,
-      contractAddress: collateral,
-      functionName: "approve",
-      functionArgs: [INK_VAULT_DEPOSITOR_ADDRESS, maxUint256]
-    },
-    // VaultDepositooor pulls the live balance, injects it over the
-    // placeholder, and calls the Endpoint. minAmountOut is 0 because the
-    // collateral passes through 1:1 (no vault rate to bound).
-    {
-      contractAbi: VAULT_DEPOSITOR_ABI,
-      contractAddress: INK_VAULT_DEPOSITOR_ADDRESS,
-      functionName: "deposit",
-      functionArgs: [collateral, NADO_ENDPOINT_ADDRESS, depositCalldata, 0n]
-    }
-  ];
-}
-export {
-  INK_VAULT_DEPOSITOR_ADDRESS,
-  NADO_DEFAULT_SUBACCOUNT_NAME,
-  NADO_ENDPOINT_ADDRESS,
-  NADO_NO_REFERRAL_CODE,
-  buildNadoSubaccount,
-  createNadoDepositActions
-};

package/dist/clients/polymarket.d.ts

@@ -1,161 +0,0 @@
-/**
- * Polymarket V2 PMCT withdrawal.
- *
- * Two flows are supported, dispatched on input shape:
- *
- *   1. **UDA / PMCT transfer** (legacy) — caller supplies `userId` +
- *      `sendPmctTransfer`. The backend handles the unwrap/route via
- *      PermissionedRamp. Returns a {@link CustomWithdrawalConfig}.
- *
- *   2. **Wallet unwrap** — caller supplies `proxyAddress`, a `publicClient`,
- *      and a batched `sendTransactions` primitive. `preWithdrawalAction`
- *      reads the pUSD allowance and returns the approve (when needed) +
- *      `unwrap()` to USDCe as an array of {@link WithdrawalTransaction}s.
- *      The SDK prepends those to the withdrawal txn and atomically broadcasts
- *      the batch via the integrator's `sendTransactions`. Returns a
- *      {@link WalletWithdrawalConfig}.
- */
-import { type Address, type PublicClient, type TransactionReceipt } from 'viem';
-import type { CustomWithdrawalConfig, FunkitCheckoutActionParams, FunkitWithdrawalConfig, WalletWithdrawalConfig } from '../providers/FunkitCheckoutContext/types';
-import type { WithdrawalTransaction } from '../wallets/Wallet';
-export interface PolymarketWithdrawalCallbackConfig {
-    userId: string;
-    modalTitle?: string;
-    disableConnectedWallet?: boolean;
-    sourceTokenSymbol?: string;
-    defaultReceiveToken?: string;
-    sourceTokenAddress?: Address;
-    iconSrc?: string;
-    /**
-     * Execute the ERC-20 transfer of PMCT from the user's proxy to the UDA.
-     * Called after the UDA address is generated.
-     * Should return when the transaction has been submitted (not necessarily confirmed).
-     */
-    sendPmctTransfer: (params: {
-        /** The UDA address to send PMCT to */
-        udaAddress: Address;
-        /** Amount in base units (from the quote) */
-        amountBaseUnit: bigint;
-    }) => Promise<void>;
-}
-/**
- * Caller-supplied batched submitter. Receives the full ordered list of txs
- * (helper-injected approve+unwrap, then the SDK's withdrawal txn). Must
- * broadcast them atomically in a single user signature and return a tx hash
- * that {@link WithdrawalClient.confirmTransaction} can wait on.
- */
-export type PolymarketSendTransactions = (txs: WithdrawalTransaction[]) => Promise<string>;
-export interface PolymarketWalletUnwrapWithdrawalConfig {
-    /** Polymarket proxy that holds pUSD and signs the batched tx. */
-    proxyAddress: Address;
-    /** Polygon public client used for the pre-flight allowance read. */
-    publicClient: PublicClient;
-    /**
-     * Batched send primitive. The SDK passes the full ordered list of txs —
-     * helper-emitted `approve(pUSD → offramp)` (only when allowance is
-     * insufficient) and `offramp.unwrap(USDCe, proxy, amount)` from
-     * `preWithdrawalAction`, followed by the withdrawal txn — and the
-     * integrator broadcasts them atomically in a single user signature.
-     */
-    sendTransactions: PolymarketSendTransactions;
-    /**
-     * Optional override for waiting on a tx receipt. Defaults to
-     * `publicClient.waitForTransactionReceipt`.
-     */
-    confirmTransaction?: (txHash: string, chainId: number) => Promise<TransactionReceipt>;
-    modalTitle?: string;
-    disableConnectedWallet?: boolean;
-    sourceTokenSymbol?: string;
-    sourceTokenAddress?: Address;
-    defaultReceiveToken?: string;
-    iconSrc?: string;
-}
-/**
- * Combined input — supplies params for both flows. The runtime path is
- * chosen at call time via the `enable-polymarket-wallet-withdrawal`
- * Statsig gate (read synchronously through {@link checkFeatureGate}, so
- * this stays a regular function callable from event handlers).
- */
-export interface PolymarketWithdrawalConfig extends PolymarketWithdrawalCallbackConfig, PolymarketWalletUnwrapWithdrawalConfig {
-}
-/**
- * Combined / gated entry point. Returns a {@link CustomWithdrawalConfig}
- * (UDA path) or {@link WalletWithdrawalConfig} (wallet-unwrap path)
- * depending on the gate value at call time.
- *
- * ```ts
- * const withdrawalConfig = createPolymarketWithdrawalConfig({
- *   userId: walletAddress,
- *   sendPmctTransfer: async ({ udaAddress, amountBaseUnit }) => { ... },
- *   proxyAddress,
- *   publicClient,
- *   sendTransactions: async (txs) => myBatchedSend(txs),
- * })
- * ```
- */
-export declare function createPolymarketWithdrawalConfig(config: PolymarketWithdrawalConfig): FunkitWithdrawalConfig;
-/**
- * Legacy UDA / PMCT transfer flow. Returns a {@link CustomWithdrawalConfig}.
- *
- * @deprecated Pass the combined {@link PolymarketWithdrawalConfig} instead so
- * the wallet-unwrap rollout can be staged via the
- * `enable-polymarket-wallet-withdrawal` Statsig gate. Direct callers of this
- * single-flow overload bypass the gate.
- *
- * ```ts
- * const withdrawalConfig = createPolymarketWithdrawalConfig({
- *   userId: walletAddress,
- *   sendPmctTransfer: async ({ udaAddress, amountBaseUnit }) => { ... },
- * })
- * ```
- */
-export declare function createPolymarketWithdrawalConfig(config: PolymarketWithdrawalCallbackConfig): CustomWithdrawalConfig;
-/**
- * Wallet-flow with embedded pUSD → USDCe unwrap. Returns a
- * {@link WalletWithdrawalConfig} whose `preWithdrawalAction` and `wallet`
- * coordinate via a closure-scoped queue, so the integrator only sees the
- * batched `sendTransactions` primitive.
- *
- * @deprecated Pass the combined {@link PolymarketWithdrawalConfig} instead so
- * the wallet-unwrap rollout can be staged via the
- * `enable-polymarket-wallet-withdrawal` Statsig gate. Direct callers of this
- * single-flow overload bypass the gate.
- *
- * ```ts
- * const withdrawalConfig = createPolymarketWithdrawalConfig({
- *   proxyAddress,
- *   publicClient,
- *   sendTransactions: async (txs) => myBatchedSend(txs),
- * })
- * ```
- */
-export declare function createPolymarketWithdrawalConfig(config: PolymarketWalletUnwrapWithdrawalConfig): WalletWithdrawalConfig;
-export interface PolymarketPerpsDepositConfig {
-    /**
-     * Polymarket Perps account credited with the deposit
-     */
-    recipientAddress: Address;
-}
-/**
- * Builds the `generateActionsParams` callback for a Polymarket Perps deposit.
- *
- * Both legs run inside a single Relay Router V3 `cleanupErc20sViaCall` sweep,
- * each mediated by the VaultDepositor proxy so the flow composes with
- * EXACT_INPUT quoting — the VaultDepositor pulls msg.sender's full balance and
- * substitutes AMOUNT_PLACEHOLDER at exec time, so arrival amounts don't need to
- * be known at quote time:
- *   1. USDC.e → pUSD via `CollateralOnramp.wrap`, attributing pUSD to Relay
- *      Router V3.
- *   2. pUSD → `POLYMARKET_PERPS_ADDRESS.deposit`, crediting `recipientAddress`.
- *
- * Usage:
- * ```ts
- * const checkoutConfig: FunkitCheckoutConfig = {
- *   // ...
- *   generateActionsParams: createPerpsGenerateActionParams({
- *     recipientAddress: proxyAddress,
- *   }),
- * }
- * ```
- */
-export declare function createPerpsGenerateActionParams(config: PolymarketPerpsDepositConfig): () => Promise<FunkitCheckoutActionParams[]>;