0xtrails 0.2.5 → 0.3.0

package/src/transactionIntent/handlers/sameChainSameToken.ts

@@ -0,0 +1,712 @@
+import type { Account, Chain, WalletClient, TransactionReceipt } from "viem"
+import { createPublicClient, http, formatUnits } from "viem"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
+import type { MetaTxnReceipt, PrepareSendReturn, SendReturn } from "../types.js"
+import type { TransactionState } from "../../transactions.js"
+import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
+import type {
+  Intent,
+  CommitIntentResponse,
+  DepositSignature,
+  ExecuteIntentResponse,
+} from "@0xsequence/trails-api"
+import type { SelectedFeeToken } from "../types.js"
+import { logger } from "../../logger.js"
+import {
+  isTestnetDebugMode,
+  getTestnetOriginTokenAddress,
+} from "../utils/testnetHelpers.js"
+import { checkAccountBalance } from "../utils/balanceChecker.js"
+import { getTestnetChainInfo } from "../../chains.js"
+import { getIsCustomCalldata } from "../../contractUtils.js"
+import {
+  buildSameChainSameTokenTransactionParams,
+  getIntent,
+  commitIntent,
+} from "../../intents.js"
+import { estimateGasLimit } from "../../estimate.js"
+import { getNormalizedQuoteObject } from "../quote/normalizeQuote.js"
+import { attemptSwitchChain } from "../../chainSwitch.js"
+import { attemptUserDepositTx } from "../deposits/depositOrchestrator.js"
+import { getIntentArgs } from "../quote/quoteHelpers.js"
+import { TradeType } from "../types.js"
+import { trackPaymentCompleted, trackPaymentError } from "../../analytics.js"
+import { updatePersistentToast } from "../../toast.js"
+import { getChainInfo } from "../../chains.js"
+import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
+import { calcAmountUsdPrice } from "../../prices.js"
+import { pollIntentReceipt } from "../../intentReceiptPoller.js"
+
+/**
+ * @description
+ * This handler manages simple same-chain token transfers (e.g., using USDC to transact with USDC on the same chain).
+ * It supports both standard transfers and custom calldata execution.
+ *
+ * Key characteristics:
+ * - Uses the Trails API with getIntent and commitIntent for setup
+ * - Single transaction leg (user transfer)
+ * - No cross-chain bridging or token swapping required
+ * - Direct transaction submission via attemptUserDepositTx (simpler than cross-chain polling)
+ * - Supports both gasless and standard fee payment modes
+ *
+ * Transaction Flow:
+ * 1. Get intent via getIntent (Intent object with validation)
+ * 2. Commit intent via commitIntent (Record created in backend)
+ * 3. User submits transaction via attemptUserDepositTx (handles both gasless and standard)
+ * 4. Wait for transaction receipt (direct receipt polling, not via waitIntentReceipt API)
+ * 5. Update transaction state and invoke callbacks
+ *
+ * Error Handling:
+ * - Balance validation before transaction submission
+ * - Gas estimation for accurate fee calculation
+ * - Proper error propagation with checkout error callbacks
+ * - Fallback logging for debugging
+ *
+ * State Management:
+ * - transactionStates[0]: User transfer transaction
+ * - Updates propagated via onTransactionStateChange callback
+ * - Analytics tracking for payment completion or errors
+ * - Support for gasless fee options via gasFeeOptions
+ */
+export async function handleSameChainSameToken({
+  mainSignerAddress,
+  originTokenAddress,
+  originTokenDecimals,
+  originTokenSymbol,
+  destinationTokenSymbol,
+  swapAmount,
+  destinationCalldata,
+  recipient,
+  walletClient,
+  onTransactionStateChange,
+  dryMode,
+  account,
+  chain,
+  transactionStates,
+  sourceTokenPriceUsd,
+  destinationTokenPriceUsd,
+  originNativeTokenPriceUsd,
+  slippageTolerance,
+  checkoutOnHandlers,
+  mode,
+  fundMethod,
+  paymasterUrl,
+  selectedFeeToken,
+  walletId,
+  trailsClient,
+  abortSignal,
+  commitIntentFn,
+  executeIntentFn,
+}: {
+  mainSignerAddress: string
+  originTokenAddress: string
+  originTokenDecimals: number
+  originTokenSymbol: string
+  destinationTokenSymbol: string
+  swapAmount: string
+  destinationCalldata?: string
+  recipient: string
+  originChainId: number
+  walletClient: WalletClient
+  onTransactionStateChange: (transactionStates: TransactionState[]) => void
+  dryMode: boolean
+  account: Account
+  chain: Chain
+  transactionStates: TransactionState[]
+  sourceTokenPriceUsd?: number | null
+  destinationTokenPriceUsd?: number | null
+  originNativeTokenPriceUsd?: number | null
+  slippageTolerance: string
+  checkoutOnHandlers?: CheckoutOnHandlers
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
+  fundMethod?: string
+  paymasterUrl?: string
+  selectedFeeToken?: SelectedFeeToken
+  walletId?: string
+  trailsClient: TrailsAPIClient
+  abortSignal?: AbortSignal
+  commitIntentFn?: (intent: Intent) => Promise<CommitIntentResponse>
+  executeIntentFn?: (params: {
+    intentId: string
+    depositTransactionHash?: string
+    depositSignature?: DepositSignature
+  }) => Promise<ExecuteIntentResponse>
+}): Promise<PrepareSendReturn> {
+  logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
+  const testnet = isTestnetDebugMode()
+  const effectiveOriginChain = testnet ? getTestnetChainInfo(chain)! : chain
+  const effectiveOriginChainId = effectiveOriginChain.id
+  const effectiveOriginTokenAddress = testnet
+    ? getTestnetOriginTokenAddress(effectiveOriginChainId)
+    : originTokenAddress
+  const effectivePublicClient = createPublicClient({
+    chain: effectiveOriginChain,
+    transport: http(),
+  })
+
+  let noSufficientBalance = false
+
+  const { hasEnoughBalance } = await checkAccountBalance({
+    account,
+    tokenAddress: originTokenAddress,
+    depositAmount: swapAmount,
+    publicClient: effectivePublicClient,
+  })
+
+  if (!hasEnoughBalance) {
+    noSufficientBalance = true
+  }
+
+  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+
+  // For same-chain transactions, use Intent flow to support gasless deposits
+  const destinationSalt = Date.now().toString()
+  const intentArgs = getIntentArgs(
+    mainSignerAddress,
+    effectiveOriginChainId,
+    effectiveOriginTokenAddress,
+    swapAmount, // originTokenAmount
+    effectiveOriginChainId, // same chain
+    effectiveOriginTokenAddress, // same token
+    "0", // destinationTokenAmount (exact input)
+    recipient,
+    destinationCalldata,
+    destinationSalt,
+    slippageTolerance,
+    TradeType.EXACT_INPUT,
+    "", // quoteProvider - empty for same-chain
+  )
+
+  logger.console.log(
+    "[trails-sdk] Creating intent for same-chain with args:",
+    intentArgs,
+  )
+
+  const { intent, gasFeeOptions } = await getIntent(trailsClient, intentArgs, {
+    originTokenSymbol,
+    destinationTokenSymbol,
+    feeTokenSymbol: originTokenSymbol,
+  })
+
+  logger.console.log("[trails-sdk] Got intent:", intent)
+  logger.console.log("[trails-sdk] Got gasFeeOptions:", gasFeeOptions)
+
+  if (!intent.preconditions?.length || !intent.calls?.length) {
+    throw new Error("Invalid intent")
+  }
+
+  // Build origin call params and estimate gas limit for the quote
+  const originCallParamsBase = buildSameChainSameTokenTransactionParams({
+    hasCustomCalldata,
+    recipient,
+    effectiveOriginTokenAddress,
+    destinationCalldata,
+    swapAmount,
+    effectiveOriginChainId,
+    effectiveOriginChain,
+  })
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] About to estimate gas limit for quote with params:",
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: originCallParamsBase.value,
+    },
+  )
+
+  const estimatedGasLimitForQuote = await estimateGasLimit(
+    effectivePublicClient,
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: BigInt(originCallParamsBase.value),
+    },
+    "quote",
+  )
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] Estimated gas limit for quote:",
+    estimatedGasLimitForQuote,
+  )
+
+  const quote = await getNormalizedQuoteObject({
+    originDepositAddress: intent.originIntentAddress,
+    destinationDepositAddress: intent.destinationIntentAddress,
+    destinationAddress: recipient,
+    destinationCalldata,
+    originAmount: swapAmount,
+    destinationAmount: swapAmount,
+    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
+    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
+    originTokenAddress: effectiveOriginTokenAddress,
+    destinationTokenAddress: effectiveOriginTokenAddress,
+    transactionStates,
+    originChainId: effectiveOriginChainId,
+    destinationChainId: effectiveOriginChainId,
+    originNativeTokenPriceUsd,
+    slippageTolerance,
+    quoteProvider: intent.quote?.quoteProvider || "",
+    noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
+    intent,
+  })
+
+  // Call onCheckoutQuote callback if provided
+  if (checkoutOnHandlers?.triggerCheckoutQuote) {
+    checkoutOnHandlers.triggerCheckoutQuote(quote)
+  }
+
+  // Log gasless fee options availability
+  if (gasFeeOptions && walletId !== "sequence-waas") {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled for same-chain. Using gasFeeOptions from QuoteIntent response",
+      { originChainId: effectiveOriginChainId, gasFeeOptions },
+    )
+  }
+
+  return {
+    quote,
+    feeOptions: gasFeeOptions,
+    send: async ({
+      onOriginSend,
+      selectedFeeToken: runtimeSelectedFeeToken,
+    }: {
+      onOriginSend?: () => void
+      selectedFeeToken?: any
+    }): Promise<SendReturn> => {
+      // Use runtime selectedFeeToken if provided, otherwise fall back to the one from prepareSend
+      const effectiveSelectedFeeToken =
+        runtimeSelectedFeeToken ?? selectedFeeToken
+      const effectiveGasless =
+        effectiveSelectedFeeToken !== null &&
+        effectiveSelectedFeeToken !== undefined &&
+        walletId !== "sequence-waas"
+      logger.console.log(
+        "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] send() called for same-chain:",
+        {
+          runtimeSelectedFeeToken,
+          prepareTimeSelectedFeeToken: selectedFeeToken,
+          effectiveSelectedFeeToken,
+          effectiveGasless,
+        },
+      )
+      try {
+        const { hasEnoughBalance, balanceError } = await checkAccountBalance({
+          account,
+          tokenAddress: effectiveOriginTokenAddress,
+          depositAmount: swapAmount,
+          publicClient: effectivePublicClient,
+        })
+
+        if (!hasEnoughBalance) {
+          throw balanceError
+        }
+
+        const depositAmountFormatted = Number(
+          formatUnits(BigInt(swapAmount), originTokenDecimals),
+        )
+        const depositAmountUsd = calcAmountUsdPrice({
+          amount: depositAmountFormatted,
+          usdPrice: sourceTokenPriceUsd,
+        })
+
+        const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+
+        // Build origin call params (reusing the same logic as quote estimation)
+        const originCallParamsBase = buildSameChainSameTokenTransactionParams({
+          hasCustomCalldata,
+          recipient,
+          effectiveOriginTokenAddress,
+          destinationCalldata,
+          swapAmount,
+          effectiveOriginChainId,
+          effectiveOriginChain,
+        })
+
+        // Estimate gas limit for consistency with actual transaction
+        const gasLimit = await estimateGasLimit(
+          effectivePublicClient,
+          {
+            account: account.address,
+            to: originCallParamsBase.to,
+            data: originCallParamsBase.data,
+            value: BigInt(originCallParamsBase.value),
+          },
+          "send",
+        )
+
+        const originCallParams = {
+          ...originCallParamsBase,
+          gasLimit,
+        }
+
+        logger.console.log("[trails-sdk] origin call params", originCallParams)
+
+        let depositUserTxnReceipt: TransactionReceipt | null = null
+        const originMetaTxnReceipt: MetaTxnReceipt | null = null
+        const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
+
+        // Commit the intent
+        const commitIntentFnToUse =
+          commitIntentFn ||
+          ((intent: Intent) =>
+            commitIntent(trailsClient, intent, {
+              originTokenSymbol,
+              destinationTokenSymbol,
+            }))
+        await commitIntentFnToUse(intent)
+
+        logger.console.log(
+          "[trails-sdk] Intent committed for same-chain transaction",
+        )
+
+        await attemptSwitchChain({
+          walletClient,
+          desiredChainId: effectiveOriginChainId,
+        })
+        if (!dryMode) {
+          // For gasless flows on same-chain same-token, we need to track 2 transactions:
+          // [0] = Deposit transaction (relayed)
+          // [1] = Origin intent transaction (executed on chain after deposit is confirmed)
+
+          // Initialize local transaction states for gasless flows to track both deposit and execute
+          const createInitialStates = (): TransactionState[] => {
+            const depositState: TransactionState = {
+              transactionHash: "",
+              explorerUrl: "",
+              chainId: effectiveOriginChainId,
+              state: "pending",
+              label: effectiveGasless ? "Deposit" : "Execute",
+            }
+
+            const executeState: TransactionState = {
+              transactionHash: "",
+              explorerUrl: "",
+              chainId: effectiveOriginChainId,
+              state: "pending",
+              label: "Execute",
+            }
+
+            return effectiveGasless
+              ? [depositState, executeState]
+              : [depositState]
+          }
+
+          const localTransactionStates = createInitialStates()
+
+          try {
+            onTransactionStateChange(localTransactionStates)
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
+          }
+
+          // For gasless flows, pass the localTransactionStates instead of the input parameter
+          // This ensures we track both deposit and execute transactions
+          const statesForDeposit = effectiveGasless
+            ? localTransactionStates
+            : transactionStates
+
+          // Use attemptUserDepositTx which handles both gasless and non-gasless flows
+          // For non-gasless same-chain same-token, pass recipient to send directly to user instead of intent contract
+          depositUserTxnReceipt = await attemptUserDepositTx({
+            originTokenAddress: effectiveOriginTokenAddress,
+            paymasterUrl,
+            chain: effectiveOriginChain,
+            account,
+            firstPreconditionMin: swapAmount,
+            originIntentAddress: intent.originIntentAddress,
+            onOriginSend,
+            publicClient: effectivePublicClient,
+            walletClient,
+            destinationTokenDecimals: originTokenDecimals,
+            sourceTokenDecimals: originTokenDecimals,
+            fee: "0",
+            dryMode,
+            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+            swapAmount,
+            onTransactionStateChange,
+            transactionStates: statesForDeposit,
+            fundMethod,
+            originTokenSymbol,
+            destinationTokenSymbol,
+            depositAmountUsd,
+            feeOptions: gasFeeOptions,
+            trailsClient,
+            selectedFeeToken: effectiveSelectedFeeToken,
+            walletId,
+            abortSignal,
+            checkoutOnHandlers,
+            intentId: intent.intentId,
+            executeIntentFn,
+            depositRecipientOverride: recipient,
+            isSameChainSameToken: true,
+          })
+
+          // attemptUserDepositTx handles both gasless and non-gasless flows
+          // Transaction state updates and toasts are handled within that function
+          logger.console.log("[trails-sdk] Deposit transaction completed", {
+            hasReceipt: !!depositUserTxnReceipt,
+            isGasless: effectiveGasless,
+          })
+
+          // For gasless flows, start polling for both deposit and origin transactions via API
+          if (effectiveGasless && !depositUserTxnReceipt) {
+            logger.console.log(
+              "[trails-sdk] Starting unified polling for gasless same-chain transaction with 2 states",
+            )
+            try {
+              await pollIntentReceipt({
+                intentId: intent.intentId,
+                trailsClient,
+                callbacks: {
+                  onDepositTransactionFound: async (txHash) => {
+                    logger.console.log(
+                      "[trails-sdk] Deposit transaction discovered for same-chain gasless flow",
+                      { txHash },
+                    )
+
+                    if (localTransactionStates[0]) {
+                      try {
+                        const depositTxReceipt =
+                          await effectivePublicClient.getTransactionReceipt({
+                            hash: txHash as `0x${string}`,
+                          })
+                        logger.console.log(
+                          "[trails-sdk] Deposit transaction receipt fetched",
+                          {
+                            txHash,
+                            blockNumber: depositTxReceipt?.blockNumber,
+                            status: depositTxReceipt?.status,
+                          },
+                        )
+
+                        localTransactionStates[0] =
+                          getTransactionStateFromReceipt(
+                            depositTxReceipt,
+                            effectiveOriginChainId,
+                            localTransactionStates[0]?.label,
+                          )
+                        onTransactionStateChange(localTransactionStates)
+                      } catch (error) {
+                        logger.console.error(
+                          "[trails-sdk] Error fetching deposit transaction receipt:",
+                          error,
+                        )
+                      }
+                    }
+                  },
+                  onOriginTransactionFound: async (originTxHash) => {
+                    logger.console.log(
+                      "[trails-sdk] Origin intent transaction discovered for same-chain gasless flow",
+                      { originTxHash },
+                    )
+
+                    // For same-chain gasless, localTransactionStates[1] is the origin intent transaction
+                    if (localTransactionStates[1]) {
+                      try {
+                        const originTxReceipt =
+                          await effectivePublicClient.getTransactionReceipt({
+                            hash: originTxHash as `0x${string}`,
+                          })
+                        logger.console.log(
+                          "[trails-sdk] Origin transaction receipt fetched",
+                          {
+                            originTxHash,
+                            blockNumber: originTxReceipt?.blockNumber,
+                            status: originTxReceipt?.status,
+                          },
+                        )
+
+                        localTransactionStates[1] =
+                          getTransactionStateFromReceipt(
+                            originTxReceipt,
+                            effectiveOriginChainId,
+                            localTransactionStates[1]?.label,
+                          )
+                        onTransactionStateChange(localTransactionStates)
+                      } catch (error) {
+                        logger.console.error(
+                          "[trails-sdk] Error fetching origin transaction receipt:",
+                          error,
+                        )
+                      }
+                    }
+                  },
+                },
+                maxWaitTime: 120000, // 120 seconds max wait for both transactions
+              })
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error polling for gasless same-chain transactions:",
+                error,
+              )
+            }
+          }
+
+          if (depositUserTxnReceipt) {
+            try {
+              const updatedStates = [
+                getTransactionStateFromReceipt(
+                  depositUserTxnReceipt,
+                  effectiveOriginChainId,
+                  transactionStates[0]?.label,
+                ),
+              ]
+              onTransactionStateChange(updatedStates)
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error calling onTransactionStateChange:",
+                error,
+              )
+            }
+          }
+
+          // Show conditional toast based on transaction status
+          const chainInfo = getChainInfo(effectiveOriginChainId)
+          if (depositUserTxnReceipt) {
+            if (depositUserTxnReceipt?.status === "success") {
+              updatePersistentToast(
+                "Transfer Confirmed",
+                `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+                "info",
+              )
+            } else {
+              updatePersistentToast(
+                "Transfer Failed",
+                `Your transaction on ${chainInfo?.name || "chain"} failed`,
+                "error",
+              )
+            }
+          }
+
+          // Track payment completion for same-chain same-token transaction
+          if (
+            depositUserTxnReceipt &&
+            depositUserTxnReceipt.status === "success"
+          ) {
+            // Check if any transaction failed or was refunded
+            const hasAnyCallFailed = transactionStates.some((tx) =>
+              tx?.decodedGuestModuleEvents?.some(
+                (e: any) => e?.type === "CallFailed",
+              ),
+            )
+            const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
+            const txStatus =
+              !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
+
+            // Always track payment completion regardless of success/failure
+            trackPaymentCompleted({
+              userAddress: account.address,
+              originTxHash: depositUserTxnReceipt.transactionHash,
+              originChainId: effectiveOriginChainId, // Same chain
+              mode,
+              fundMethod,
+              originTokenAddress,
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+              destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+            })
+
+            // Call onCheckoutComplete callback with transaction status
+            if (checkoutOnHandlers?.triggerCheckoutComplete) {
+              checkoutOnHandlers.triggerCheckoutComplete(
+                txStatus,
+                account.address,
+              )
+            }
+          } else if (depositUserTxnReceipt) {
+            trackPaymentError({
+              error: "Transaction failed",
+              userAddress: account.address,
+              mode,
+              fundMethod,
+              originTokenAddress,
+            })
+
+            // Call onCheckoutError callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutError) {
+              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
+            }
+          } else if (effectiveGasless && !depositUserTxnReceipt) {
+            // For gasless flows with polling, check if both transactions are confirmed
+            const depositConfirmed =
+              localTransactionStates[0]?.state === "confirmed"
+            const originConfirmed =
+              localTransactionStates[1]?.state === "confirmed"
+
+            if (depositConfirmed && originConfirmed) {
+              logger.console.log(
+                "[trails-sdk] Gasless same-chain transaction fully completed via polling",
+              )
+              const txStatus = "success"
+
+              trackPaymentCompleted({
+                userAddress: account.address,
+                originTxHash:
+                  localTransactionStates[0]?.transactionHash ||
+                  localTransactionStates[1]?.transactionHash,
+                originChainId: effectiveOriginChainId,
+                mode,
+                fundMethod,
+                originTokenAddress,
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
+                destinationTokenAmountUsd: depositAmountUsd?.toString(),
+              })
+
+              // Call onCheckoutComplete callback with transaction status
+              if (checkoutOnHandlers?.triggerCheckoutComplete) {
+                checkoutOnHandlers.triggerCheckoutComplete(
+                  txStatus,
+                  account.address,
+                )
+              }
+            } else if (depositConfirmed) {
+              logger.console.log(
+                "[trails-sdk] Gasless same-chain deposit confirmed, waiting for origin transaction",
+              )
+            }
+          }
+        }
+
+        return {
+          depositUserTxnReceipt,
+          originMetaTxnReceipt,
+          destinationMetaTxnReceipt,
+          totalCompletionSeconds: 0,
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error
+            ? error.message
+            : "Unknown error occurred during transaction"
+        logger.console.error(
+          "[trails-sdk] Error in sendHandlerForSameChainSameToken:",
+          error,
+        )
+
+        // Track payment error
+        trackPaymentError({
+          error: errorMessage,
+          userAddress: account.address,
+          mode,
+          fundMethod,
+          originTokenAddress,
+        })
+
+        // Call onCheckoutError callback if provided
+        if (checkoutOnHandlers?.triggerCheckoutError) {
+          checkoutOnHandlers.triggerCheckoutError(errorMessage)
+        }
+
+        // Re-throw the error so caller can handle if needed
+        throw error
+      }
+    },
+  }
+}