@funkit/connect 9.20.0 → 9.21.0

package/dist/clients/lighter.js

@@ -1,14 +1,14 @@
 "use client";
 import {
   AsyncImage
-} from "./chunk-47AQXZQE.js";
+} from "./chunk-NCCAYPLO.js";
 import {
   useFunkitConfig
-} from "./chunk-UNCVGPTD.js";
+} from "./chunk-ZMVXBMON.js";
 import {
   Box,
   useFunkitTranslation
-} from "./chunk-JVTKIEOP.js";
+} from "./chunk-52NKHZS2.js";
 import {
   logger
 } from "./chunk-UUHGOBKZ.js";

package/dist/clients/nado.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1,107 @@
+"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
+};