From c36805aad38e4d42af7ade3c7ee8d837721bb16a Mon Sep 17 00:00:00 2001 From: Brenda Profiro Date: Tue, 18 Aug 2026 15:08:09 -0300 Subject: [PATCH] feat(nextjs-defi-lending-moonwell): Moonwell USDC lending recipe (Base) Supply and withdraw USDC on Moonwell (Base) with a Dynamic embedded wallet, structured after nextjs-defi-lending-morpho: JS SDK + react hooks, raw viem + minimal ABIs, headless email OTP, WaaS bootstrap via getChainsMissingWaasWalletAccounts(). Market list and live APYs come from api.moonwell.fi/v1/markets with deprecated markets filtered out; markets are keyed by mToken address because native USDC and legacy USDbC both report the mUSDC symbol. Supplying is approve -> mint; withdrawals use redeemUnderlying, or redeem of the full mToken balance for Max so no dust is stranded. Balances derive from exchangeRateStored. Every write simulates first and asserts the Compound v2 return code is zero, since these markets answer some failures with a code instead of a revert. RECIPE.mdx is the companion recipe doc for the docs site, mirroring the Morpho recipe's structure; every code block is a verbatim excerpt of this example. --- .../nextjs-defi-lending-moonwell/.env.example | 4 + .../nextjs-defi-lending-moonwell/.gitignore | 42 + .../nextjs-defi-lending-moonwell/README.md | 114 + .../nextjs-defi-lending-moonwell/RECIPE.mdx | 892 ++ .../eslint.config.mjs | 16 + .../next.config.ts | 11 + .../nextjs-defi-lending-moonwell/package.json | 37 + .../pnpm-lock.yaml | 7383 +++++++++++++++++ .../pnpm-workspace.yaml | 6 + .../postcss.config.mjs | 5 + .../public/favicon.ico | Bin 0 -> 10117 bytes .../public/logo.svg | 42 + .../src/app/error.tsx | 27 + .../src/app/globals.css | 28 + .../src/app/layout.tsx | 39 + .../src/app/lend/[mToken]/page.tsx | 165 + .../src/app/lend/page.tsx | 54 + .../src/app/page.tsx | 5 + .../src/components/BalanceDisplay.tsx | 63 + .../src/components/Login.tsx | 110 + .../src/components/MarketRow.tsx | 62 + .../src/components/Navigation.tsx | 38 + .../src/components/SupplyWithdrawForm.tsx | 282 + .../src/components/dynamic/DynamicButton.tsx | 147 + .../src/components/dynamic/Logo.tsx | 59 + .../src/components/footer.tsx | 40 + .../src/components/ui/Badge.tsx | 30 + .../src/components/ui/Skeleton.tsx | 10 + .../src/components/ui/TokenIcon.tsx | 46 + .../src/lib/ABIs/ERC20_ABI.ts | 36 + .../src/lib/ABIs/MTOKEN_ABI.ts | 44 + .../src/lib/ABIs/index.ts | 2 + .../src/lib/constants.ts | 42 + .../src/lib/dynamic.ts | 71 + .../src/lib/hooks/index.ts | 7 + .../src/lib/hooks/useBalances.ts | 73 + .../src/lib/hooks/useLendingOperations.ts | 316 + .../src/lib/hooks/useMarkets.ts | 26 + .../src/lib/moonwell.ts | 174 + .../src/lib/providers.tsx | 113 + .../src/lib/utils.ts | 25 + .../src/lib/viem.ts | 9 + .../tsconfig.json | 27 + 43 files changed, 10722 insertions(+) create mode 100644 examples/nextjs-defi-lending-moonwell/.env.example create mode 100644 examples/nextjs-defi-lending-moonwell/.gitignore create mode 100644 examples/nextjs-defi-lending-moonwell/README.md create mode 100644 examples/nextjs-defi-lending-moonwell/RECIPE.mdx create mode 100644 examples/nextjs-defi-lending-moonwell/eslint.config.mjs create mode 100644 examples/nextjs-defi-lending-moonwell/next.config.ts create mode 100644 examples/nextjs-defi-lending-moonwell/package.json create mode 100644 examples/nextjs-defi-lending-moonwell/pnpm-lock.yaml create mode 100644 examples/nextjs-defi-lending-moonwell/pnpm-workspace.yaml create mode 100644 examples/nextjs-defi-lending-moonwell/postcss.config.mjs create mode 100644 examples/nextjs-defi-lending-moonwell/public/favicon.ico create mode 100644 examples/nextjs-defi-lending-moonwell/public/logo.svg create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/error.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/globals.css create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/layout.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/lend/[mToken]/page.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/lend/page.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/app/page.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/BalanceDisplay.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/Login.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/MarketRow.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/Navigation.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/SupplyWithdrawForm.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/dynamic/DynamicButton.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/dynamic/Logo.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/footer.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/ui/Badge.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/ui/Skeleton.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/components/ui/TokenIcon.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/ABIs/ERC20_ABI.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/ABIs/MTOKEN_ABI.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/ABIs/index.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/constants.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/dynamic.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/hooks/index.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/hooks/useBalances.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/hooks/useLendingOperations.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/hooks/useMarkets.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/moonwell.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/providers.tsx create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/utils.ts create mode 100644 examples/nextjs-defi-lending-moonwell/src/lib/viem.ts create mode 100644 examples/nextjs-defi-lending-moonwell/tsconfig.json diff --git a/examples/nextjs-defi-lending-moonwell/.env.example b/examples/nextjs-defi-lending-moonwell/.env.example new file mode 100644 index 0000000..fb52192 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/.env.example @@ -0,0 +1,4 @@ +NEXT_PUBLIC_DYNAMIC_ENV_ID=your-dynamic-environment-id + +# Optional Base RPC override. Defaults to https://rpc.moonwell.fi/main/evm/8453 +# NEXT_PUBLIC_BASE_RPC_URL=https://base-mainnet.g.alchemy.com/v2/YOUR_KEY diff --git a/examples/nextjs-defi-lending-moonwell/.gitignore b/examples/nextjs-defi-lending-moonwell/.gitignore new file mode 100644 index 0000000..b5d0160 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/.gitignore @@ -0,0 +1,42 @@ +# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. + +# dependencies +/node_modules +/.pnp +.pnp.* +.yarn/* +!.yarn/patches +!.yarn/plugins +!.yarn/releases +!.yarn/versions + +# testing +/coverage + +# next.js +/.next/ +/out/ + +# production +/build + +# misc +.DS_Store +*.pem + +# debug +npm-debug.log* +yarn-debug.log* +yarn-error.log* +.pnpm-debug.log* + +# env files (can opt-in for committing if needed) +.env* + +# vercel +.vercel + +# typescript +*.tsbuildinfo +next-env.d.ts +!.env.example diff --git a/examples/nextjs-defi-lending-moonwell/README.md b/examples/nextjs-defi-lending-moonwell/README.md new file mode 100644 index 0000000..bd133bd --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/README.md @@ -0,0 +1,114 @@ +# Earn yield by lending on Moonwell + +Supply and withdraw USDC on [Moonwell](https://moonwell.fi) (Base) using a Dynamic +embedded wallet. Built with the Dynamic JavaScript SDK — headless email OTP +sign-in, an automatically created WaaS wallet, and viem for the contract calls. + +## What this example shows + +- **Headless email OTP login** with `useSendEmailOTP` / `useVerifyOTP` — the JS SDK + ships no modal, so the sign-in form is yours +- **WaaS wallet bootstrap** on `userChanged`, using + `getChainsMissingWaasWalletAccounts()` rather than an account-count guard +- **Live market data** from `https://api.moonwell.fi/v1/markets?chainId=8453`, + with deprecated markets filtered out +- **Supply and withdraw USDC** through Moonwell's mToken (a Compound v2 fork): + `approve` → `mint`, and `redeemUnderlying` / `redeem` +- **Compound v2 error codes** — every write simulates first and asserts the + returned code is `0`, because these contracts answer some failures with a + return value instead of a revert + +Every market has a detail page with live rates. Supply and withdraw are wired up +for the USDC market only — the others are read-only. + +## Setup + +### 1. Dynamic dashboard + +In [app.dynamic.xyz](https://app.dynamic.xyz): + +- Enable **Base** under _Chains & Networks_ +- Enable **Embedded wallets** under _Wallets_ +- Enable **Email** under _Sign-in Methods_ +- Add `http://localhost:3000` under _Security → Allowed Origins_ +- Copy your environment ID from _Developer Settings → SDK & API Keys_ + +Optionally toggle **Show Confirmation UI** and **Transaction Simulation** under +_Developer Settings → Embedded Wallets → Dynamic_ for a transaction preview. + +### 2. Environment + +```bash +cp .env.example .env.local +``` + +```env +NEXT_PUBLIC_DYNAMIC_ENV_ID=your-environment-id +``` + +Reads and broadcasts go through `https://rpc.moonwell.fi/main/evm/8453` by +default. Set `NEXT_PUBLIC_BASE_RPC_URL` to use your own provider. Base's public +endpoint (`mainnet.base.org`) is a poor choice here — it rate-limits browser +traffic and answers with 403, which shows up as a failed broadcast. + +### 3. Run + +```bash +pnpm install +pnpm dev +``` + +Open [http://localhost:3000](http://localhost:3000). To move real funds you need +USDC and a little ETH for gas on Base. + +## Scripts + +| Command | What it does | +| ---------------- | ----------------------------------- | +| `pnpm dev` | Dev server on port 3000 | +| `pnpm build` | Production build | +| `pnpm typecheck` | `tsc --noEmit` | +| `pnpm lint` | ESLint | + +## Project structure + +``` +src/ + app/ + lend/ + page.tsx # market list with live APYs + [mToken]/page.tsx # any market's rates; supply/withdraw for USDC + components/ + Login.tsx # headless email OTP form + MarketRow.tsx + BalanceDisplay.tsx + SupplyWithdrawForm.tsx + ui/ # Badge, TokenIcon, Skeleton + lib/ + dynamic.ts # client + addEvmExtension() + initializeClient() + providers.tsx # QueryClientProvider > DynamicProvider > WaasBootstrap + constants.ts # chain, API URL, USDC + mUSDC addresses + moonwell.ts # pure API parsing + mToken math (unit tested) + utils.ts # error formatting + retry predicate (unit tested) + viem.ts # read-only Base public client + ABIs/ # ERC20 + minimal mToken + hooks/ + useMarkets.ts + useBalances.ts + useLendingOperations.ts +``` + +## Notes + +- **Base only.** There is no network selector; `CHAIN_ID` is fixed to `8453`. +- **Two markets report the `mUSDC` symbol** — native USDC and the deprecated + USDbC market. Markets are always keyed by `mTokenAddress`, never by symbol. +- **Supplied balance is derived**, not read: an mToken balance stays constant + while `exchangeRateStored` grows, so interest only appears once you compute + `mTokenBalance * exchangeRateStored / 1e18`. + +## Resources + +- [Dynamic JS SDK quickstart](https://docs.dynamic.xyz/javascript/reference/quickstart) +- [Moonwell documentation](https://docs.moonwell.fi) +- [Moonwell markets API](https://api.moonwell.fi/v1/markets) diff --git a/examples/nextjs-defi-lending-moonwell/RECIPE.mdx b/examples/nextjs-defi-lending-moonwell/RECIPE.mdx new file mode 100644 index 0000000..f5fbaa3 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/RECIPE.mdx @@ -0,0 +1,892 @@ +# Moonwell lending markets + +> Let users supply stablecoins to Moonwell's lending markets on Base and earn interest that accrues automatically + +## Overview + +[Moonwell](https://moonwell.fi/) is an open lending protocol on Base. Suppliers deposit assets into a market, borrowers pay interest to draw against it, and that interest accrues to suppliers continuously. This guide walks through integrating Moonwell's USDC market into a Next.js app with Dynamic embedded wallets. + +For the final code, see the [GitHub repository](https://github.com/dynamic-labs-oss/examples/tree/main/examples/nextjs-defi-lending-moonwell). + +## How it works + +Moonwell's core markets are a Compound v2 fork. When a user supplies USDC they receive **mUSDC**, an interest-bearing receipt token. The mToken balance never changes; instead the market's exchange rate grows every block as borrowers pay interest, so each mToken becomes redeemable for more USDC over time. + +**Example:** a user supplies 1,000 USDC when `exchangeRateStored` is `0.0231` USDC per mUSDC (the raw on-chain value is a large integer — `231174377482736` — scaled as described below), receiving about 43,290 mUSDC. Their mUSDC balance stays at 43,290. When the rate reaches `0.0243`, that same balance redeems for roughly 1,052 USDC — the extra 52 USDC is accrued interest. Nothing needs to be claimed or compounded. + +Two details follow from this design and shape the code below: + +- **The supplied balance is derived, not read.** `underlyingBalance = mTokenBalance * exchangeRateStored / 1e18`. The rate is scaled by `1e(10 + underlyingDecimals)`, so this one formula is correct for any market regardless of the underlying's decimals. +- **Some failures return an error code instead of reverting.** `mint`, `redeem` and `redeemUnderlying` return a `uint` status. A transaction can therefore succeed on-chain while doing nothing, so every write is simulated first and the returned code checked. + +APY is variable and moves with borrower demand. + +## Setup + +### Project setup + +Follow the [JS SDK Quickstart](/docs/javascript/reference/quickstart) to initialize a Next.js app with Dynamic. Scaffold a Next.js app with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app) and mirror the provider wiring from the quickstart or the [GitHub repository](https://github.com/dynamic-labs-oss/examples/tree/main/examples/nextjs-defi-lending-moonwell) linked above. + + + In the Dynamic dashboard, enable **Base** under **Chains & Networks**, enable **Embedded wallets** under **Wallets**, enable **Email** under **Sign-in Methods**, and add your app's origin under **Security → Allowed Origins**. + + +### Install dependencies + + + ```bash npm + npm install @dynamic-labs-sdk/client @dynamic-labs-sdk/evm @dynamic-labs-sdk/react-hooks @tanstack/react-query viem + ``` + + ```bash yarn + yarn add @dynamic-labs-sdk/client @dynamic-labs-sdk/evm @dynamic-labs-sdk/react-hooks @tanstack/react-query viem + ``` + + ```bash pnpm + pnpm add @dynamic-labs-sdk/client @dynamic-labs-sdk/evm @dynamic-labs-sdk/react-hooks @tanstack/react-query viem + ``` + + ```bash bun + bun add @dynamic-labs-sdk/client @dynamic-labs-sdk/evm @dynamic-labs-sdk/react-hooks @tanstack/react-query viem + ``` + + +`@tanstack/react-query` is a required peer dependency of `@dynamic-labs-sdk/react-hooks` — every state, query and mutation hook is built on it. + + + This guide's hook surface — `useGetWalletAccounts`, `useOnEvent`, `useSendEmailOTP`, `useVerifyOTP` — requires `@dynamic-labs-sdk/*` **1.26.0 or later**. Earlier releases expose different hooks under different names. + + +### Environment variables + +```env .env.local +NEXT_PUBLIC_DYNAMIC_ENV_ID=your-environment-id-here + +# Optional Base RPC override. Defaults to Moonwell's public endpoint. +# NEXT_PUBLIC_BASE_RPC_URL=https://base-mainnet.g.alchemy.com/v2/YOUR_KEY +``` + +Your environment ID is in the Dynamic dashboard under **Developer Settings → SDK & API Keys**. + +### Initialize Dynamic + +Create `src/lib/dynamic.ts`. Extensions are registered immediately after the client is created, before initialization completes, and they take no arguments: + +```typescript src/lib/dynamic.ts +import { createDynamicClient, initializeClient } from "@dynamic-labs-sdk/client"; +import { addEvmExtension } from "@dynamic-labs-sdk/evm"; +import { BASE_RPC_URL, CHAIN_ID } from "@/lib/constants"; + +// `universalLink` defaults to `window.location.origin`, which does not exist +// while Next.js renders on the server — fall back to the dev origin so this +// module can be imported from a "use client" module graph without throwing. +const universalLink = + typeof window !== "undefined" + ? window.location.origin + : "http://localhost:3000"; + +// Named loudly because it is the one setup step every reader must get right — +// without it the SDK fails with a message that says nothing about env vars. +if (typeof window !== "undefined" && !process.env.NEXT_PUBLIC_DYNAMIC_ENV_ID) { + console.error( + "NEXT_PUBLIC_DYNAMIC_ENV_ID is not set. Copy .env.example to .env.local " + + "and fill in your environment ID from app.dynamic.xyz.", + ); +} + +export const dynamicClient = createDynamicClient({ + autoInitialize: false, + environmentId: process.env.NEXT_PUBLIC_DYNAMIC_ENV_ID!, + metadata: { + name: "Moonwell Lending", + universalLink, + }, + transformers: { + /** + * The first network of a chain is the default for a fresh wallet, so + * restricting the EVM list to Base makes Base the default — without this, + * an environment that also has Ethereum enabled hands out wallets sitting + * on chain 1 and every write fails until the user switches. + * + * Also puts `BASE_RPC_URL` in front of the project's own RPC list, so the + * WaaS client broadcasts through it — Dynamic builds that transport from + * `networkData.rpcUrls`, so overriding it here is what makes the send use + * a working endpoint rather than Base's rate-limited public one. + */ + networksData: (networksData) => + networksData + .filter( + (network) => + network.chain !== "EVM" || Number(network.networkId) === CHAIN_ID, + ) + .map((network) => { + if (Number(network.networkId) !== CHAIN_ID) return network; + return { + ...network, + rpcUrls: { + ...network.rpcUrls, + http: [BASE_RPC_URL, ...network.rpcUrls.http], + }, + }; + }), + }, +}); + +// Register extensions and initialize at module scope so both happen before any +// component renders. Extension functions take NO arguments. The browser guard +// is a Next.js concern only: "use client" modules still execute during SSR, +// where there is no wallet environment to initialize. +if (typeof window !== "undefined") { + addEvmExtension(); + // The react-hooks surface reports init failure through `initStatus`; the + // log keeps the underlying cause from being swallowed with it. + initializeClient().catch((error) => { + console.error("Dynamic client failed to initialize", error); + }); +} +``` + + + **A fresh embedded wallet opens on the first EVM network in your project, not on the one your app happens to target.** If your environment also has Ethereum enabled, users get wallets on chain 1 and every write fails. The `networksData` transformer above fixes this at the source: the `.filter()` restricts the EVM list to Base (which also makes Base the default), and the `.map()` puts your own RPC in front of the network's list. The override matters past a demo — public endpoints rate-limit browser traffic and answer with 403, which shows up as a failed broadcast rather than a failed read. + + +### Configure providers + +Create `src/lib/providers.tsx`. `QueryClientProvider` must sit **outside** `DynamicProvider`. Embedded wallet creation is not automatic — `WaasBootstrap` subscribes once with `useOnEvent` and creates the missing wallets after authentication: + +```typescript src/lib/providers.tsx +"use client"; + +import { createContext, useContext, type ReactNode } from "react"; +import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; +import { DynamicProvider, useOnEvent, useUser, useGetWalletAccounts } from "@dynamic-labs-sdk/react-hooks"; +import { + createWaasWalletAccounts, + getChainsMissingWaasWalletAccounts, + isWaasWalletAccount, +} from "@dynamic-labs-sdk/client/waas"; +import type { WalletAccount } from "@dynamic-labs-sdk/client"; +import { isEvmWalletAccount, type EvmWalletAccount } from "@dynamic-labs-sdk/evm"; +import { CHAIN_ID } from "@/lib/constants"; +import { dynamicClient } from "@/lib/dynamic"; + +interface WalletContextValue { + evmAccount: EvmWalletAccount | null; + loggedIn: boolean; + /** Base only — this example has no network selector. */ + chainId: number; +} + +const WalletContext = createContext({ + evmAccount: null, + loggedIn: false, + chainId: CHAIN_ID, +}); + +export function useWallet() { + return useContext(WalletContext); +} + +const queryClient = new QueryClient({ + defaultOptions: { + queries: { + // Matches the Moonwell app's 5s cadence for on-chain reads. Window-focus + // refetching is deliberately left on: polling pauses while the tab is in + // the background, so without it a user who switches away during a + // transaction comes back to stale balances. + staleTime: 1000 * 5, + }, + }, +}); + +/** + * Embedded (WaaS) wallet creation is not automatic — it has to be triggered + * after authentication. `getChainsMissingWaasWalletAccounts()` is the correct + * signal: guarding on `accounts.length === 0` can read a stale non-empty list + * immediately after auth and silently skip creation. + * + * `useOnEvent` (never a raw `onEvent` call in a component) deduplicates the + * subscription and cleans it up on unmount, including under Strict Mode. + */ +function WaasBootstrap() { + useOnEvent({ + event: "userChanged", + listener: async (user) => { + if (!user) return; + const missingChains = getChainsMissingWaasWalletAccounts(); + if (missingChains.length === 0) return; + try { + await createWaasWalletAccounts({ chains: missingChains }); + } catch (error) { + // Nothing awaits an event listener, so an uncaught rejection here is + // silent — and the UI would wait forever for a wallet that never + // arrives. Signing out and back in retries the creation. + console.error("Embedded wallet creation failed", error); + } + }, + }); + return null; +} + +function WalletContextProvider({ children }: { children: ReactNode }) { + const { data: user } = useUser(); + const { data: accounts = [] } = useGetWalletAccounts(); + // `useGetWalletAccounts` is typed as the chain-agnostic base account, while + // the type guard is declared over the chain-specific `WalletAccount` union. + const evmAccounts = (accounts as WalletAccount[]).filter(isEvmWalletAccount); + + // Prefer the embedded wallet. `addEvmExtension()` also registers EIP-6963 + // discovery, so an external browser wallet can appear in this list — and only + // the WaaS provider signs locally. Picking the first EVM account instead would + // hand transactions to a provider that just forwards `eth_sendTransaction` to + // a public RPC, which has no keys and rejects it. + const evmAccount = + evmAccounts.find((walletAccount) => isWaasWalletAccount({ walletAccount })) ?? + evmAccounts[0] ?? + null; + + return ( + + {children} + + ); +} + +/** + * `QueryClientProvider` must sit OUTSIDE `DynamicProvider`: every hook in + * `@dynamic-labs-sdk/react-hooks` is built on TanStack Query. + */ +export default function Providers({ children }: { children: ReactNode }) { + return ( + + + + {children} + + + ); +} +``` + +Sign-in is headless — the JavaScript SDK ships no modal. `useSendEmailOTP` returns the `OTPVerification` handle that `useVerifyOTP` consumes, and the code is passed as `verificationToken` (not `otp`): + +```typescript src/components/Login.tsx +const { + mutate: sendEmailOTP, + data: otpVerification, + isPending: isSending, + error: sendError, + reset: resetSend, +} = useSendEmailOTP(); + +const { + mutate: verifyOTP, + isPending: isVerifying, + error: verifyError, +} = useVerifyOTP(); +``` + +`sendEmailOTP` is called with the address, and `verifyOTP` with the handle it produced plus the code the user typed: + +```typescript src/components/Login.tsx +onClick={() => sendEmailOTP({ email })} +``` + +```typescript src/components/Login.tsx +onClick={() => + verifyOTP( + { otpVerification, verificationToken: code }, + { onSuccess: () => onDone?.() }, + ) +} +``` + +### Configure networks and constants + +This example is Base-only, so there is no network selector. Markets are identified by their mToken address: + +```typescript src/lib/constants.ts +/** Base mainnet. This example is single-network by design — no chain selector. */ +export const CHAIN_ID = 8453; + +/** + * Moonwell's public markets endpoint. It defaults to Base, but the chain is + * passed explicitly so the URL documents itself. + */ +export const MARKETS_API = "https://api.moonwell.fi/v1/markets?chainId=8453"; + +/** Native USDC on Base (6 decimals). */ +export const USDC_ADDRESS = + "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const; + +/** + * Moonwell's mToken for the native USDC market (8 decimals). + * + * Two markets report the `mUSDC` symbol: this one and the deprecated USDbC + * market at 0x703843C3379b52F9FF486c9f5892218d2a065cC8. Always identify a + * market by its mToken address, never by symbol. + */ +export const MUSDC_ADDRESS = + "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22" as const; + +export const USDC_DECIMALS = 6; +/** + * Not referenced by the app — the exchange-rate scaling absorbs it — but kept + * because the recipe documents the 8-decimal mToken scale beside USDC's 6. + */ +export const MTOKEN_DECIMALS = 8; + +export const BASESCAN_URL = "https://basescan.org"; + +/** + * Base RPC used for both reads and broadcasting. + * + * Defaults to Moonwell's public endpoint. Base's own public endpoint + * (`mainnet.base.org`) rate-limits browser traffic and answers with 403, which + * shows up as a failed broadcast rather than a failed read. Override with + * `NEXT_PUBLIC_BASE_RPC_URL` to point at your own provider. + */ +export const BASE_RPC_URL = + process.env.NEXT_PUBLIC_BASE_RPC_URL || "https://rpc.moonwell.fi/main/evm/8453"; +``` + +Reads go through a plain viem public client; only writes need the Dynamic wallet: + +```typescript src/lib/viem.ts +import { createPublicClient, http } from "viem"; +import { base } from "viem/chains"; +import { BASE_RPC_URL } from "@/lib/constants"; + +/** Read-only Base client. Writes go through the Dynamic wallet client. */ +export const publicClient = createPublicClient({ + chain: base, + transport: http(BASE_RPC_URL), +}); +``` + +### Set up contract ABIs + +Create the ABI files in `src/lib/ABIs/`: + +* **ERC20\_ABI.ts** — standard token interface (`balanceOf`, `allowance`, `approve`, `decimals`) +* **MTOKEN\_ABI.ts** — the Moonwell market (`mint`, `redeem`, `redeemUnderlying`, `exchangeRateStored`, `balanceOf`) + +Five functions cover the whole supply/withdraw flow: + +```typescript src/lib/ABIs/MTOKEN_ABI.ts +/** + * Minimal Moonwell mToken interface (Compound v2 fork). + * + * `mint`, `redeem` and `redeemUnderlying` return a uint error code rather than + * reverting on some failures — simulate first and assert the result is `0n` + * before broadcasting. + */ +export const MTOKEN_ABI = [ + { + inputs: [{ name: "mintAmount", type: "uint256" }], + name: "mint", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [{ name: "redeemTokens", type: "uint256" }], + name: "redeem", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [{ name: "redeemAmount", type: "uint256" }], + name: "redeemUnderlying", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "exchangeRateStored", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, + { + inputs: [{ name: "owner", type: "address" }], + name: "balanceOf", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, +] as const; +``` + +You can find these files in the [GitHub repository](https://github.com/dynamic-labs-oss/examples/tree/main/examples/nextjs-defi-lending-moonwell/src/lib/ABIs). + +## Fetching market data + +### Market list + +`https://api.moonwell.fi/v1/markets?chainId=8453` returns `{ success, data: Market[], meta }`. Each market carries `asset`, `assetAddress`, `mToken`, `mTokenAddress`, `deprecated`, `baseSupplyApy`, `totalSupplyApr`, `totalSupplyUsd`, `liquidityUsd`, `utilization` and `collateralFactor`. APY fields are **already percentages** — `3.668` means 3.67%, no multiplication needed. + + + Two markets on Base report the mToken symbol **`mUSDC`**: native USDC (`0xEdc817…6c22`) and the legacy USDbC market (`0x703843…5cC8`, `deprecated: true`). Filter on `deprecated === false` and key every market by `mTokenAddress` — symbols are not unique. + + +Parsing and filtering live in a pure module so they can be unit tested without a browser: + +```typescript src/lib/moonwell.ts +/** + * Runtime guard over the markets endpoint. The response is + * `{ success, data: Market[], meta }`; anything else is a hard error rather + * than a silently empty market list. + */ +export function parseMarketsResponse(payload: unknown): Market[] { + if (!isRecord(payload)) { + throw new Error("Moonwell API: expected a JSON object"); + } + if (payload.success !== true) { + throw new Error("Moonwell API: response success flag was not true"); + } + if (!Array.isArray(payload.data)) { + throw new Error("Moonwell API: expected data to be an array"); + } + if (!payload.data.every(isMarket)) { + throw new Error("Moonwell API: a market is missing required fields"); + } + return payload.data; +} + +/** Deprecated markets are read-only husks — never show or target them. */ +export function filterActiveMarkets(markets: Market[]): Market[] { + return markets.filter((market) => !market.deprecated); +} + +/** Markets are identified by mToken address because symbols collide. */ +export function findMarketByMToken( + markets: Market[], + mTokenAddress: string, +): Market | undefined { + const needle = mTokenAddress.toLowerCase(); + return markets.find((m) => m.mTokenAddress.toLowerCase() === needle); +} +``` + +The hook is a thin TanStack Query wrapper: + +```typescript src/lib/hooks/useMarkets.ts +async function fetchActiveMarkets(): Promise { + const res = await fetch(MARKETS_API); + if (!res.ok) { + throw new Error(`Moonwell API returned ${res.status}`); + } + return filterActiveMarkets(parseMarketsResponse(await res.json())); +} + +/** Live Base markets, deprecated ones already removed. */ +export function useMarkets() { + return useQuery({ + queryKey: ["moonwell", "markets"], + queryFn: fetchActiveMarkets, + staleTime: 30_000, + }); +} +``` + +### User balances + +The supplied balance is not stored anywhere — it is the mToken balance multiplied by the current exchange rate: + +```typescript src/lib/moonwell.ts +/** + * Converts an mToken balance into the underlying asset's smallest unit. + * + * `exchangeRateStored` is scaled by 1e(10 + underlyingDecimals), so dividing + * the product by 1e18 lands in underlying units for any market, regardless of + * the underlying's decimals. Truncating division rounds in the protocol's + * favour, which is what we want when displaying a redeemable balance. + */ +export function underlyingFromMTokens( + mTokenBalance: bigint, + exchangeRateStored: bigint, +): bigint { + return (mTokenBalance * exchangeRateStored) / 10n ** 18n; +} +``` + +Four reads give everything the UI needs — wallet balance, position and allowance: + +```typescript src/lib/hooks/useBalances.ts +const [walletUsdc, mTokenBalance, exchangeRate, allowance] = + await Promise.all([ + publicClient.readContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "balanceOf", + args: [owner], + }), + publicClient.readContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "balanceOf", + args: [owner], + }), + publicClient.readContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "exchangeRateStored", + }), + publicClient.readContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "allowance", + args: [owner, MUSDC_ADDRESS], + }), + ]); + +return { + walletUsdc, + mTokenBalance, + suppliedUsdc: underlyingFromMTokens(mTokenBalance, exchangeRate), + allowance, +}; +``` + +## Supply and withdraw + +Supplying requires two transactions: approve the mToken to spend USDC, then `mint`. Withdrawing needs no approval. Use viem directly with `createWalletClientForWalletAccount`. + +One thing to get right first: **an embedded wallet does not start on Base just because Base is enabled.** It opens on whatever network the environment resolves first — if Ethereum Mainnet is also enabled, that is chain 1, and every write fails. And because `createWalletClientForWalletAccount` takes its chain from the wallet's *current* network, the switch has to happen before the client is built, not after: + +```typescript src/lib/hooks/useLendingOperations.ts +const getWalletClient = useCallback( + async (onSwitchStart?: () => void) => { + if (!evmAccount) throw new Error("Connect a wallet first"); + + const { networkId } = await getActiveNetworkId({ + walletAccount: evmAccount, + }); + + if (Number(networkId) !== CHAIN_ID) { + if (!isProgrammaticNetworkSwitchAvailable({ walletAccount: evmAccount })) { + throw new Error( + `This wallet is on chain ${networkId} and cannot switch networks programmatically. Switch to Base (${CHAIN_ID}) in your wallet, then try again.`, + ); + } + onSwitchStart?.(); + await switchActiveNetwork({ + networkId: String(CHAIN_ID), + walletAccount: evmAccount, + }); + } + + const walletClient = await createWalletClientForWalletAccount({ + walletAccount: evmAccount, + }); + + // Backstop: if the switch silently failed we would otherwise sign against + // the wrong chain's contracts. + if (walletClient.chain?.id !== CHAIN_ID) { + throw new Error( + `Wallet is still on chain ${walletClient.chain?.id ?? "unknown"} after switching to Base (${CHAIN_ID}).`, + ); + } + + // The embedded wallet signs locally, which viem models as a `local` + // account. A `json-rpc` account means the SDK fell back to proxying + // through a provider that cannot sign — the transaction would be + // forwarded to a public RPC, which holds no keys and answers + // `eth_sendTransaction` with "rpc method is unsupported". Failing here + // names the cause instead of surfacing that as a network error. + if (walletClient.account?.type !== "local") { + throw new Error( + `Selected wallet cannot sign locally (viem account type "${walletClient.account?.type ?? "unknown"}"). This example expects a Dynamic embedded wallet.`, + ); + } + return walletClient; + }, + [evmAccount], +); +``` + +Embedded wallets switch programmatically with no user prompt, which is why this can run inline in the transaction path. An external wallet may refuse, so `isProgrammaticNetworkSwitchAvailable` is checked rather than assumed — that branch is where you would fall back to asking the user to switch by hand. + + + **Simulate with the wallet's account object, not its address.** This is the single easiest way to break an embedded-wallet integration, and it fails in a way that points nowhere near the cause. + + `writeContract` prefers the account carried on the simulated request over the one on the client: + + ```typescript + const { abi, account: account_ = client.account, ... } = parameters // viem + ``` + + An address string parses into a **`json-rpc`** account, so viem asks the transport to sign via `eth_sendTransaction`. The embedded wallet signs *locally* — its client carries a **`local`** account and broadcasts `eth_sendRawTransaction`. Pass the address and you silently opt out of that, and the request goes to your RPC endpoint, which holds no keys: + + ``` + The method "eth_sendTransaction" does not exist / is not available. + ``` + + ```typescript + // ✅ signs locally with the embedded wallet + publicClient.simulateContract({ ...args, account: walletClient.account }) + + // ❌ becomes a json-rpc account; eth_sendTransaction goes to the RPC + publicClient.simulateContract({ ...args, account: walletClient.account.address }) + ``` + + +Every write follows the same cycle — simulate, check the Compound error code, broadcast, wait, invalidate: + +```typescript src/lib/hooks/useLendingOperations.ts +/** + * Compound v2 markets answer some failures with a non-zero return code instead + * of reverting, so a transaction can succeed on-chain while doing nothing. + * Simulating first exposes that code — anything but 0 is a refusal. + */ +export function assertNoErrorCode(result: unknown, action: string) { + if (typeof result === "bigint" && result !== 0n) { + throw new Error( + `Moonwell rejected the ${action} with error code ${result}. ` + + `See https://docs.moonwell.fi for what each code means.`, + ); + } +} + +let hash: `0x${string}` | undefined; + +const walletClient = await getWalletClient(() => + setTx({ phase: "switching" }), +); +setTx({ phase }); + +let simulated: Awaited> | undefined; +for (let attempt = 1; ; attempt++) { + try { + simulated = await simulate(walletClient.account); + break; + } catch (error) { + if (attempt >= simulateAttempts || !isStaleAllowanceError(error)) { + throw error; + } + await new Promise((resolve) => setTimeout(resolve, 1_000)); + } +} + +const { request, result } = simulated; +assertNoErrorCode(result, action); + +hash = await walletClient.writeContract(request); +const receipt = await publicClient.waitForTransactionReceipt({ hash }); +if (receipt.status !== "success") { + throw new Error(`${action} transaction reverted`); +} + +// The transaction is final the moment the receipt says success, so +// report it now. The refresh below makes ten more RPC round-trips, and +// a hiccup in any of them must not repaint a mined transaction as a +// failure. +setTx({ phase: "success", hash, action }); + +try { + // Only refetch once the RPC can actually see this block, otherwise + // the refreshed balances are the pre-transaction ones. + await waitForBlock(receipt.blockNumber); + await queryClient.invalidateQueries({ + queryKey: balancesQueryKey(address), + }); +} catch (refreshError) { + // Best-effort: the 5s balance poll catches up on its own. + console.error(`Balance refresh after the ${action} failed`, refreshError); +} +``` + +The four operations differ only in which contract call they simulate: + +```typescript src/lib/hooks/useLendingOperations.ts +/** Approves the mToken to spend `amount` USDC. */ +const approve = useCallback( + (amount: bigint) => + run("approving", "approval", async (account) => + publicClient.simulateContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "approve", + args: [MUSDC_ADDRESS, amount], + account, + }), + ), + [run], +); + +/** + * Supplies USDC and receives mUSDC. + * + * `simulateAttempts` above 1 is for a supply chained straight onto an + * approval: the allowance is on-chain but the read path may not serve it for + * a few seconds, and retrying the simulate absorbs that without asking the + * user to press anything twice. + */ +const supply = useCallback( + (amount: bigint, simulateAttempts = 1) => + run( + "pending", + "supply", + async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "mint", + args: [amount], + account, + }), + simulateAttempts, + ), + [run], +); + +/** Withdraws an exact USDC amount. */ +const withdraw = useCallback( + (amount: bigint) => + run("pending", "withdrawal", async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "redeemUnderlying", + args: [amount], + account, + }), + ), + [run], +); + +/** + * Withdraws everything by redeeming the whole mToken balance. Going through + * `redeem` rather than `redeemUnderlying` avoids leaving dust behind when the + * exchange rate moves between quoting and mining. + */ +const withdrawMax = useCallback( + (mTokenBalance: bigint) => + run("pending", "withdrawal", async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "redeem", + args: [mTokenBalance], + account, + }), + ), + [run], +); +``` + + + **A mined approval is not the same as a readable one.** `waitForTransactionReceipt` proves *one* node saw the approve. Simulate the `mint` immediately afterwards and a load-balanced RPC can serve you a node one block behind, which still reads the old allowance: + + ``` + The contract function "mint" reverted with the following reason: + ERC20: transfer amount exceeds allowance + ``` + + The approval is fine, the supply is fine, and re-clicking works — which is what makes this easy to misread as a bug in the approve. + + **Retry the simulation, not the transaction.** Polling the allowance before supplying looks like the obvious fix and is not reliable: it decides in advance how long propagation will take, and when it guesses low the user is asked to press a button twice for no reason. Simulating is a read, so retrying it is free — and it tests the exact condition that matters instead of a proxy for it. The write still happens once, after a simulate that succeeded: + + ```typescript src/lib/hooks/useLendingOperations.ts + let simulated: Awaited> | undefined; + for (let attempt = 1; ; attempt++) { + try { + simulated = await simulate(walletClient.account); + break; + } catch (error) { + if (attempt >= simulateAttempts || !isStaleAllowanceError(error)) { + throw error; + } + await new Promise((resolve) => setTimeout(resolve, 1_000)); + } + } + ``` + + Retry only the failure that patience fixes. A balance that is genuinely too low or a paused market must surface at once, not after twenty seconds of silence: + + ```typescript src/lib/utils.ts + export function isStaleAllowanceError(error: unknown): boolean { + return formatErrorMessage(error).toLowerCase().includes("allowance"); + } + ``` + + Pass the retries only where a stale allowance is plausible — straight after an approval. Everywhere else, an allowance error is real. + + + +In the form, a supply first tops up the allowance when it is short, and a full withdrawal is routed to `redeem` so no dust is stranded: + +```typescript src/components/SupplyWithdrawForm.tsx +const handleSubmit = async () => { + if (!amount) return; + setApprovalStands(false); + if (mode === "supply") { + const approving = needsApproval; + // Approval and supply are one click. The error is already on screen if the + // approval itself failed. + if (approving && !(await approve(amount))) return; + // A supply straight after an approval may simulate before the new + // allowance is readable. Retrying the simulate absorbs that rather than + // making the user press Supply a second time; without a preceding + // approval an allowance error is real, so it surfaces at once. + const supplied = await supply(amount, approving ? 20 : 1); + // The amount is only cleared on success: after a failure the user needs + // it on screen to retry, next to the error explaining what happened. + if (supplied) clearInput(); + else if (approving) setApprovalStands(true); + return; + } + // A "withdraw everything" request redeems the mToken balance outright so no + // dust is left behind by an exchange-rate tick between quote and mining. + const isFullWithdrawal = isMax || (amount === maxAmount && maxAmount > 0n); + const withdrew = + isFullWithdrawal && balances + ? await withdrawMax(balances.mTokenBalance) + : await withdraw(amount); + if (withdrew) clearInput(); +}; +``` + +Two pieces of state make this honest. `isMax` remembers the Max click explicitly — the supplied balance grows with every exchange-rate tick, so inferring "withdraw everything" from an equality check goes stale within one balance poll. And `approvalStands` tells the user that a mined approval is still in place when the supply chained onto it fails, instead of leaving a standing allowance undisclosed. + +## Enable transaction simulation + +Dynamic's embedded wallets include built-in transaction previews. To enable, go to **Developer Settings → Embedded Wallets → Dynamic** in the dashboard and toggle on **Show Confirmation UI** and **Transaction Simulation**. Users will see the exact assets being transferred, estimated fees, and the market contract before confirming. + +## Run the app + + + ```bash npm + npm run dev + ``` + + ```bash yarn + yarn dev + ``` + + ```bash pnpm + pnpm dev + ``` + + ```bash bun + bun dev + ``` + + +Add `http://localhost:3000` to your allowed origins in the Dynamic dashboard under **Security → Allowed Origins**. + +## Full source code + +[GitHub repository →](https://github.com/dynamic-labs-oss/examples/tree/main/examples/nextjs-defi-lending-moonwell) + +## Additional resources + +* [Earn yield with Aave](/docs/recipes/integrations/yield/aave) +* [Morpho yield vaults](/docs/recipes/integrations/yield/morpho) +* [Moonwell documentation](https://docs.moonwell.fi) +* [Dynamic JS SDK](/docs/javascript/reference/quickstart) diff --git a/examples/nextjs-defi-lending-moonwell/eslint.config.mjs b/examples/nextjs-defi-lending-moonwell/eslint.config.mjs new file mode 100644 index 0000000..c85fb67 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/eslint.config.mjs @@ -0,0 +1,16 @@ +import { dirname } from "path"; +import { fileURLToPath } from "url"; +import { FlatCompat } from "@eslint/eslintrc"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +const compat = new FlatCompat({ + baseDirectory: __dirname, +}); + +const eslintConfig = [ + ...compat.extends("next/core-web-vitals", "next/typescript"), +]; + +export default eslintConfig; diff --git a/examples/nextjs-defi-lending-moonwell/next.config.ts b/examples/nextjs-defi-lending-moonwell/next.config.ts new file mode 100644 index 0000000..dae3464 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/next.config.ts @@ -0,0 +1,11 @@ +import type { NextConfig } from "next"; + +const nextConfig: NextConfig = { + webpack: (config) => { + config.externals.push("pino-pretty", "lokijs", "encoding"); + return config; + }, +}; + + +export default nextConfig; diff --git a/examples/nextjs-defi-lending-moonwell/package.json b/examples/nextjs-defi-lending-moonwell/package.json new file mode 100644 index 0000000..820ba0a --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/package.json @@ -0,0 +1,37 @@ +{ + "name": "nextjs-defi-lending-moonwell", + "version": "0.1.0", + "private": true, + "scripts": { + "dev": "next dev", + "build": "next build", + "start": "next start", + "lint": "next lint", + "typecheck": "tsc --noEmit" + }, + "dependencies": { + "@dynamic-labs-sdk/client": "1.26.0", + "@dynamic-labs-sdk/evm": "1.26.0", + "@dynamic-labs-sdk/react-hooks": "1.26.0", + "@tanstack/react-query": "5.90.12", + "clsx": "2.1.1", + "lucide-react": "0.542.0", + "next": "15.5.9", + "react": "19.1.2", + "react-dom": "19.1.2", + "tailwind-merge": "3.4.0", + "viem": "2.42.1" + }, + "devDependencies": { + "@eslint/eslintrc": "3.3.1", + "@tailwindcss/postcss": "4.1.18", + "@types/node": "20.19.27", + "@types/react": "19.1.12", + "@types/react-dom": "19.1.9", + "eslint": "9.39.2", + "eslint-config-next": "15.5.9", + "postcss": "8.5.6", + "tailwindcss": "4.1.18", + "typescript": "5.9.3" + } +} diff --git a/examples/nextjs-defi-lending-moonwell/pnpm-lock.yaml b/examples/nextjs-defi-lending-moonwell/pnpm-lock.yaml new file mode 100644 index 0000000..5ab016e --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/pnpm-lock.yaml @@ -0,0 +1,7383 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + dependencies: + '@dynamic-labs-sdk/client': + specifier: 1.26.0 + version: 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@dynamic-labs-sdk/evm': + specifier: 1.26.0 + version: 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(@types/react@19.1.12)(aws4fetch@1.0.20)(fastestsmallesttextencoderdecoder@1.0.22)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)(typescript@5.9.3)(viem@2.42.1(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76) + '@dynamic-labs-sdk/react-hooks': + specifier: 1.26.0 + version: 1.26.0(@dynamic-labs-sdk/client@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2))(@tanstack/react-query@5.90.12(react@19.1.2))(react@19.1.2) + '@tanstack/react-query': + specifier: 5.90.12 + version: 5.90.12(react@19.1.2) + clsx: + specifier: 2.1.1 + version: 2.1.1 + lucide-react: + specifier: 0.542.0 + version: 0.542.0(react@19.1.2) + next: + specifier: 15.5.9 + version: 15.5.9(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + react: + specifier: 19.1.2 + version: 19.1.2 + react-dom: + specifier: 19.1.2 + version: 19.1.2(react@19.1.2) + tailwind-merge: + specifier: 3.4.0 + version: 3.4.0 + viem: + specifier: 2.42.1 + version: 2.42.1(typescript@5.9.3)(zod@3.25.76) + devDependencies: + '@eslint/eslintrc': + specifier: 3.3.1 + version: 3.3.1 + '@tailwindcss/postcss': + specifier: 4.1.18 + version: 4.1.18 + '@types/node': + specifier: 20.19.27 + version: 20.19.27 + '@types/react': + specifier: 19.1.12 + version: 19.1.12 + '@types/react-dom': + specifier: 19.1.9 + version: 19.1.9(@types/react@19.1.12) + eslint: + specifier: 9.39.2 + version: 9.39.2(jiti@2.7.0) + eslint-config-next: + specifier: 15.5.9 + version: 15.5.9(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + postcss: + specifier: 8.5.6 + version: 8.5.6 + tailwindcss: + specifier: 4.1.18 + version: 4.1.18 + typescript: + specifier: 5.9.3 + version: 5.9.3 + +packages: + + '@ably/msgpack-js@0.4.1': + resolution: {integrity: sha512-Sjxj6SOr17hExAVrsycN7u6oV4PhZcK7Z2S8dM71CH/butgO47cSo/TL6FJPCXUyDAzKkOWjMUpJGyZkEpyu4Q==} + + '@adraffy/ens-normalize@1.11.1': + resolution: {integrity: sha512-nhCBV3quEgesuf7c7KYfperqSS14T8bYuvJ8PcLJp6znkZpFc0AuW4qBtr8eKVyPPe/8RSr7sglCWPU5eaxwKQ==} + + '@alloc/quick-lru@5.2.0': + resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==} + engines: {node: '>=10'} + + '@base-org/account@2.5.2': + resolution: {integrity: sha512-B3e0XiZWHXgCPLRXk0dDGA2WN8eFk/MDprqRX1Xl4PPx1LAdzynGcGUg6rnidMrIQ/GSL+oelWDHdGbWtCOOoA==} + + '@coinbase/cdp-sdk@1.55.0': + resolution: {integrity: sha512-5PbUg3n3Jk9nm8nEStskRv6jTrVZKkgwxMFjW+i/xUDDzK1fXksKwXdjgUiHB1hf0FZx1LiYBosrh4IULxFyPA==} + peerDependencies: + '@x402/core': ^2.21.0 + '@x402/evm': ^2.21.0 + '@x402/extensions': ^2.21.0 + '@x402/svm': ^2.21.0 + peerDependenciesMeta: + '@x402/core': + optional: true + '@x402/evm': + optional: true + '@x402/extensions': + optional: true + '@x402/svm': + optional: true + + '@dynamic-labs-sdk/assert-package-version@1.26.0': + resolution: {integrity: sha512-gsRDYW5TntgS4mIMnOJE2nLi2ln4uIWrh5bWilsrkeoUxuF3B+oLf3bt5PAb7ah9c/6rjINa4jwqafUUhNCOGQ==} + + '@dynamic-labs-sdk/client@1.26.0': + resolution: {integrity: sha512-oVkCljOrKVY9MPCHOVf5t0hVHwABpwbK8+4Z0durVT80v1xH436eMjZ0Yd3R83mCxENpVoaxxE+j9CUSnm6AyQ==} + peerDependencies: + '@react-native-async-storage/async-storage': ^2.2.0 + react-native: '>=0.73.6' + react-native-inappbrowser-reborn: ^3.7.0 + react-native-keychain: ^10.0.0 + react-native-passkey: '>=3.3.2' + peerDependenciesMeta: + '@react-native-async-storage/async-storage': + optional: true + react-native: + optional: true + react-native-inappbrowser-reborn: + optional: true + react-native-keychain: + optional: true + react-native-passkey: + optional: true + + '@dynamic-labs-sdk/evm@1.26.0': + resolution: {integrity: sha512-AFTJAqVsK4Z2RFD30OGLDBLYNsaXoDnRZUIclvgRwo1lUT51yIRt/zbW5JCLH7MBVyBmadiuK12qc6b7Qx3PXQ==} + peerDependencies: + viem: ^2.28.4 + + '@dynamic-labs-sdk/metamask@1.26.0': + resolution: {integrity: sha512-MILu+Apx5stfEWsvLr19czQh0wiFlDssJutVmS3U1SFxfmPU4dX+QAlglYPOxWVKamMmZB6D7XpDJVr4lsiE5A==} + + '@dynamic-labs-sdk/react-hooks@1.26.0': + resolution: {integrity: sha512-MjyOk6vqrFa42PCScn+2IYgdrRxJimi7Q0bXc4vJPyhPivoIv6pGox8VH/sYww83KfMGPBarqO9pP9sEge/CGg==} + peerDependencies: + '@dynamic-labs-sdk/client': 1.26.0 + '@tanstack/react-query': ^5.0.0 + react: ^18.0.0 || ^19.0.0 + + '@dynamic-labs-sdk/wallet-connect@1.26.0': + resolution: {integrity: sha512-RIuk7cq7rQ5uEHAq1w2rrtw9mZFaOxAD/HjIrRcXE+N1FWMs4HE+ap4lClgvNbrLy2eNAnzTiD1v5tO5VJbupw==} + + '@dynamic-labs-wallet/browser-wallet-client@1.0.79': + resolution: {integrity: sha512-M2Le4XT83Q/PFuaDWkkbE94V9R1BLm4P02YCJClq/PBSJL8YDCDoy9b5IQGC5NDv0DlxQxFgbTpuYL9gnvZlyQ==} + + '@dynamic-labs-wallet/core@1.0.79': + resolution: {integrity: sha512-qjbc9AYnLvL/9FCRl66dxlxAAUZsAkVH1FeTbK23uJnYreposdf9TvOpmRAg1FTiRBUAQ9jwz7BjwseiE9MTIQ==} + peerDependencies: + '@dynamic-labs-wallet/forward-mpc-client': 1.0.1 + + '@dynamic-labs-wallet/forward-mpc-client@1.0.1': + resolution: {integrity: sha512-G4o5PAIAqXQrDo0uV6Q2GTtwdMpNv0RaHlJ0eSqtrrhHb3Hl3ZZzYDJLM3EAdzD1RXh/kzVu+c/bzANApJL3pQ==} + peerDependencies: + '@dynamic-labs-wallet/primitives': '>=0.0.336 || 0.0.1' + + '@dynamic-labs-wallet/forward-mpc-shared@0.7.1': + resolution: {integrity: sha512-GPTYQ55z0nj18bkEAJEgvodH0l8phE03hY3VDOz1J4U91bFL+BKh6tjJQU6uycAhP/DouZggPYr0qKi/RBBdbA==} + peerDependencies: + '@dynamic-labs-wallet/primitives': '>=0.0.336 || 0.0.1' + + '@dynamic-labs-wallet/primitives@1.0.79': + resolution: {integrity: sha512-ALTaxyuQDLKeOK9A0uU99L0fjH9PuZcjgVhseprbV9riRw17Uiy5gIpx9E7n+cKH9eWhaPLvRwiYKZwLNemzSw==} + + '@dynamic-labs/assert-package-version@4.96.0': + resolution: {integrity: sha512-drpqTUEL6mt+LHPFclEoCZR4iB2hWUoEexEa3quVc1BzntM7qo1mf8EuNUJOMLDS6HhtX0zppfRmCtUnCa2fvQ==} + + '@dynamic-labs/logger@4.96.0': + resolution: {integrity: sha512-E6W8gbHzKQi/QldrQwvxT32p38OJek5WpHkd8C6qr3xeyroIsz5dKLPoEAaiUTlXGCBpkTQHqGexhwhyOGCpDg==} + + '@dynamic-labs/message-transport@4.96.0': + resolution: {integrity: sha512-p5emJ8iKDKmGdVrI+yVzTYVEDwdVfTcVZpUK9ZL4CPHTatBVMeGLW4OvlqPSZIE4ia2OBfcE1kUlmkZgtwzLHA==} + + '@dynamic-labs/sdk-api-core@0.0.1083': + resolution: {integrity: sha512-enVgDPvsMob7ReL9ob34KCSRXsZwqQDb3wUsl4vFYCnka+uHCfzCUTkp6/8yDuy6m3Ps6Mk4nC0Z/Ot7ppXOcA==} + + '@dynamic-labs/sdk-api-core@0.0.1093': + resolution: {integrity: sha512-NdtIGe5XlgY4ohvy//RHjokUiMJ/1BHA+IV12awIDwPfeR9+dp0gMKurlTIbnOqn0P95pbUQKdpbtxZmtCWDRw==} + + '@dynamic-labs/sdk-api-core@0.0.1122': + resolution: {integrity: sha512-Fhzxbo/7iFkSO9WqCrLo6cs43+P8ASjvA03PLvp3pTsr2OGhT35yR3huyjfJr5+oLPNxv9E6BL15hMHn5DhC7g==} + + '@dynamic-labs/types@4.96.0': + resolution: {integrity: sha512-FasXpGZ/bK/JIcVqjA68bPW6qW4v3c7lLslLpHkWjPM1X7uC26viiVKo2qpz3jDDH8vqAsnbz5jabxpntZLm1Q==} + + '@dynamic-labs/utils@4.96.0': + resolution: {integrity: sha512-F6SXz5pTv7fGpfC2qeGUokVk3HxMsnK327/dpnWA2XqDBmoV8d0/dNkgbCCdl5TVDxSMw/oFpJdcu72vbEyVFw==} + + '@ecies/ciphers@0.2.6': + resolution: {integrity: sha512-patgsRPKGkhhoBjETV4XxD0En4ui5fbX0hzayqI3M8tvNMGUoUvmyYAIWwlxBc1KX5cturfqByYdj5bYGRpN9g==} + engines: {bun: '>=1', deno: '>=2.7.10', node: '>=16'} + peerDependencies: + '@noble/ciphers': ^1.0.0 + + '@emnapi/core@1.10.0': + resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==} + + '@emnapi/runtime@1.10.0': + resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==} + + '@emnapi/runtime@1.11.3': + resolution: {integrity: sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==} + + '@emnapi/wasi-threads@1.2.1': + resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==} + + '@eslint-community/eslint-utils@4.10.1': + resolution: {integrity: sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + + '@eslint-community/regexpp@4.12.2': + resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + + '@eslint/config-array@0.21.2': + resolution: {integrity: sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/config-helpers@0.4.2': + resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/core@0.17.0': + resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/eslintrc@3.3.1': + resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/js@9.39.2': + resolution: {integrity: sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/object-schema@2.1.7': + resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/plugin-kit@0.4.1': + resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@ethereumjs/common@3.2.0': + resolution: {integrity: sha512-pksvzI0VyLgmuEF2FA/JR/4/y6hcPq8OUail3/AvycBaW1d5VSauOZzqGvJ3RTmR4MU35lWE8KseKOsEhrFRBA==} + + '@ethereumjs/rlp@4.0.1': + resolution: {integrity: sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw==} + engines: {node: '>=14'} + hasBin: true + + '@ethereumjs/tx@4.2.0': + resolution: {integrity: sha512-1nc6VO4jtFd172BbSnTnDQVr9IYBFl1y4xPzZdtkrkKIncBCkdbgfdRV+MiTkJYAtTxvV12GRZLqBFT1PNK6Yw==} + engines: {node: '>=14'} + + '@ethereumjs/util@8.1.0': + resolution: {integrity: sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA==} + engines: {node: '>=14'} + + '@evervault/wasm-attestation-bindings@0.3.1': + resolution: {integrity: sha512-pJsbax/pEPdRXSnFKahzGZeq2CNTZ0skAPWpnEZK/8vdcvlan7LE7wMSOVr+Z+MqTBnVEnS7O80TKpXKU5Rsbw==} + + '@humanfs/core@0.19.2': + resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==} + engines: {node: '>=18.18.0'} + + '@humanfs/node@0.16.8': + resolution: {integrity: sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==} + engines: {node: '>=18.18.0'} + + '@humanfs/types@0.15.0': + resolution: {integrity: sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==} + engines: {node: '>=18.18.0'} + + '@humanwhocodes/module-importer@1.0.1': + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + + '@humanwhocodes/retry@0.4.3': + resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==} + engines: {node: '>=18.18'} + + '@img/colour@1.1.0': + resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==} + engines: {node: '>=18'} + + '@img/sharp-darwin-arm64@0.34.5': + resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [darwin] + + '@img/sharp-darwin-x64@0.34.5': + resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-darwin-arm64@1.2.4': + resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==} + cpu: [arm64] + os: [darwin] + + '@img/sharp-libvips-darwin-x64@1.2.4': + resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==} + cpu: [x64] + os: [darwin] + + '@img/sharp-libvips-linux-arm64@1.2.4': + resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-arm@1.2.4': + resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-ppc64@1.2.4': + resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-riscv64@1.2.4': + resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-s390x@1.2.4': + resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linux-x64@1.2.4': + resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@img/sharp-linux-arm64@0.34.5': + resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-arm@0.34.5': + resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-ppc64@0.34.5': + resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-riscv64@0.34.5': + resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-s390x@0.34.5': + resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@img/sharp-linux-x64@0.34.5': + resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@img/sharp-linuxmusl-arm64@0.34.5': + resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@img/sharp-linuxmusl-x64@0.34.5': + resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [linux] + libc: [musl] + + '@img/sharp-wasm32@0.34.5': + resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [wasm32] + + '@img/sharp-win32-arm64@0.34.5': + resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [arm64] + os: [win32] + + '@img/sharp-win32-ia32@0.34.5': + resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [ia32] + os: [win32] + + '@img/sharp-win32-x64@0.34.5': + resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + cpu: [x64] + os: [win32] + + '@jridgewell/gen-mapping@0.3.13': + resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==} + + '@jridgewell/remapping@2.3.5': + resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==} + + '@jridgewell/resolve-uri@3.1.2': + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + + '@jridgewell/sourcemap-codec@1.5.5': + resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + + '@jridgewell/trace-mapping@0.3.31': + resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==} + + '@metamask/analytics@0.5.0': + resolution: {integrity: sha512-BXY7frsjCg1eJcxj7DAqFXyrECYspCVC8+inKfTC/IdW5i4wrMFei02VthnRvLjXAUNZ4c/i4NZvL9DT6HxOnw==} + engines: {node: '>=20.19.0'} + + '@metamask/connect-evm@1.3.0': + resolution: {integrity: sha512-3H9j58XSoAlbHqkQpQx8uLDvJhYj0bbVEECrcyVti6oJjvuIZnXpVKak9IxNwhNglb/2wddqm9Y+718/oMbvdw==} + engines: {node: '>=20.19.0'} + + '@metamask/connect-multichain@0.14.0': + resolution: {integrity: sha512-G1bOsOBF7Xy269fbiD+zdTX5wv2sAKEICUafOj51TK4uRGIo8vHWuGdqP1sxfrutCRo3SmqjF4mAI9n8UijuFQ==} + engines: {node: '>=20.19.0'} + peerDependencies: + '@react-native-async-storage/async-storage': ^1.23 + peerDependenciesMeta: + '@react-native-async-storage/async-storage': + optional: true + + '@metamask/mobile-wallet-protocol-core@0.4.0': + resolution: {integrity: sha512-rB1wMogvSUsFaxyH/eVUCczIkTxVaPPETlD/wgm+gw7EbWP0LlZPY7Bh+DICSfUCJ0zqnoFuwr77WNJvZ6ZiWw==} + engines: {node: '>=20'} + + '@metamask/mobile-wallet-protocol-dapp-client@0.3.0': + resolution: {integrity: sha512-rXStrvIa57a8OaeM+3HeR6Z9ETHOvmQi/9s6CLplDwH2hn2MWjI6WW3EUrxq2KGmGuhbO5Oo21ANnD23QKfduw==} + engines: {node: '>=20'} + + '@metamask/multichain-api-client@0.10.1': + resolution: {integrity: sha512-LsqO2SiDcTgOuXyVYEB0zgBaVNhryhP2tYI3L7tLa7PoeDqMkNIreFhDeu8jM5tPWkCimQvMwCkG3DF4P5dD3A==} + engines: {node: ^18.20 || ^20.17 || >=22} + + '@metamask/multichain-ui@0.4.1': + resolution: {integrity: sha512-tJgTot8Pfkda895A6biJu7rE+jlQdVCNVzGgW+2wM9aFG20G+GEbQy3KO7uC4ImUvaKV4SyJ45r6Ir/Yf55mqw==} + engines: {node: '>=20.19.0'} + + '@metamask/onboarding@1.0.1': + resolution: {integrity: sha512-FqHhAsCI+Vacx2qa5mAFcWNSrTcVGMNjzxVgaX8ECSny/BJ9/vgXP9V7WF/8vb9DltPeQkxr+Fnfmm6GHfmdTQ==} + + '@metamask/rpc-errors@7.0.3': + resolution: {integrity: sha512-nrEaeBawm8yFU7hetJKok/CUs0tQsWtTqp3OLbFhPUMXYqU7uI5LAV5vi9o7rTjFkUyof7Nzbw5bea5+1ou+dg==} + engines: {node: ^18.20 || ^20.17 || >=22} + + '@metamask/superstruct@3.4.1': + resolution: {integrity: sha512-caTaaBUcwBGbUNf3r0uT48upX4nECRbKhQ9pPOfW4sIkfcIUUDV4S9DZxq/5fuNPVt5KWpyd5xIIz0sP+iWLlg==} + engines: {node: '>=16.0.0'} + + '@metamask/utils@11.11.0': + resolution: {integrity: sha512-0nF2CWjWQr/m0Y2t2lJnBTU1/CZPPTvKvcESLplyWe/tyeb8zFOi/FeneDmaFnML6LYRIGZU6f+xR0jKAIUZfw==} + engines: {node: ^18.18 || ^20.14 || >=22} + + '@metamask/utils@9.3.0': + resolution: {integrity: sha512-w8CVbdkDrVXFJbfBSlDfafDR6BAkpDmv1bC1UJVCoVny5tW2RKAdn9i68Xf7asYT4TnUhl/hN4zfUiKQq9II4g==} + engines: {node: '>=16.0.0'} + + '@msgpack/msgpack@3.1.2': + resolution: {integrity: sha512-JEW4DEtBzfe8HvUYecLU9e6+XJnKDlUAIve8FvPzF3Kzs6Xo/KuZkZJsDH0wJXl/qEZbeeE7edxDNY3kMs39hQ==} + engines: {node: '>= 18'} + + '@napi-rs/wasm-runtime@1.2.2': + resolution: {integrity: sha512-JfB4kuJQjaoHuCTseIINHtHWeJnvgEcxjwA5t/Y00ZgaOO1Crz3fjT/p8kT28zA/Caz7oiUMn3d6H2yOVCVwuw==} + engines: {node: ^20.19.0 || ^22.13.0 || >=23.5.0} + peerDependencies: + '@emnapi/core': ^1.7.1 || ^2.0.0-alpha.3 + '@emnapi/runtime': ^1.7.1 || ^2.0.0-alpha.3 + + '@next/env@15.5.9': + resolution: {integrity: sha512-4GlTZ+EJM7WaW2HEZcyU317tIQDjkQIyENDLxYJfSWlfqguN+dHkZgyQTV/7ykvobU7yEH5gKvreNrH4B6QgIg==} + + '@next/eslint-plugin-next@15.5.9': + resolution: {integrity: sha512-kUzXx0iFiXw27cQAViE1yKWnz/nF8JzRmwgMRTMh8qMY90crNsdXJRh2e+R0vBpFR3kk1yvAR7wev7+fCCb79Q==} + + '@next/swc-darwin-arm64@15.5.7': + resolution: {integrity: sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + + '@next/swc-darwin-x64@15.5.7': + resolution: {integrity: sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + + '@next/swc-linux-arm64-gnu@15.5.7': + resolution: {integrity: sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@next/swc-linux-arm64-musl@15.5.7': + resolution: {integrity: sha512-nfymt+SE5cvtTrG9u1wdoxBr9bVB7mtKTcj0ltRn6gkP/2Nu1zM5ei8rwP9qKQP0Y//umK+TtkKgNtfboBxRrw==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@next/swc-linux-x64-gnu@15.5.7': + resolution: {integrity: sha512-hvXcZvCaaEbCZcVzcY7E1uXN9xWZfFvkNHwbe/n4OkRhFWrs1J1QV+4U1BN06tXLdaS4DazEGXwgqnu/VMcmqw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@next/swc-linux-x64-musl@15.5.7': + resolution: {integrity: sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + libc: [musl] + + '@next/swc-win32-arm64-msvc@15.5.7': + resolution: {integrity: sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + + '@next/swc-win32-x64-msvc@15.5.7': + resolution: {integrity: sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + + '@noble/ciphers@0.4.1': + resolution: {integrity: sha512-QCOA9cgf3Rc33owG0AYBB9wszz+Ul2kramWN8tXG44Gyciud/tbkEqvxRF/IpqQaBpRBNi9f4jdNxqB2CQCIXg==} + + '@noble/ciphers@1.3.0': + resolution: {integrity: sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw==} + engines: {node: ^14.21.3 || >=16} + + '@noble/curves@1.4.2': + resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==} + + '@noble/curves@1.8.0': + resolution: {integrity: sha512-j84kjAbzEnQHaSIhRPUmB3/eVXu2k3dKPl2LOrR8fSOIL+89U+7lV117EWHtq/GHM3ReGHM46iRBdZfpc4HRUQ==} + engines: {node: ^14.21.3 || >=16} + + '@noble/curves@1.9.1': + resolution: {integrity: sha512-k11yZxZg+t+gWvBbIswW0yoJlu8cHOC7dhunwOzoWH/mXGBiYyR4YY6hAEK/3EUs4UpB8la1RfdRpeGsFHkWsA==} + engines: {node: ^14.21.3 || >=16} + + '@noble/curves@1.9.2': + resolution: {integrity: sha512-HxngEd2XUcg9xi20JkwlLCtYwfoFw4JGkuZpT+WlsPD4gB/cxkvTD8fSsoAnphGZhFdZYKeQIPCuFlWPm1uE0g==} + engines: {node: ^14.21.3 || >=16} + + '@noble/curves@1.9.7': + resolution: {integrity: sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==} + engines: {node: ^14.21.3 || >=16} + + '@noble/curves@2.0.1': + resolution: {integrity: sha512-vs1Az2OOTBiP4q0pwjW5aF0xp9n4MxVrmkFBxc6EKZc6ddYx5gaZiAsZoq0uRRXWbi3AT/sBqn05eRPtn1JCPw==} + engines: {node: '>= 20.19.0'} + + '@noble/hashes@1.4.0': + resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} + engines: {node: '>= 16'} + + '@noble/hashes@1.7.0': + resolution: {integrity: sha512-HXydb0DgzTpDPwbVeDGCG1gIu7X6+AuU6Zl6av/E/KG8LMsvPntvq+w17CHRpKBmN6Ybdrt1eP3k4cj8DJa78w==} + engines: {node: ^14.21.3 || >=16} + + '@noble/hashes@1.8.0': + resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==} + engines: {node: ^14.21.3 || >=16} + + '@noble/hashes@2.0.1': + resolution: {integrity: sha512-XlOlEbQcE9fmuXxrVTXCTlG2nlRXa9Rj3rr5Ue/+tX+nmkgbX720YHh0VR3hBF9xDvwnb8D2shVGOwNx+ulArw==} + engines: {node: '>= 20.19.0'} + + '@noble/hashes@2.3.0': + resolution: {integrity: sha512-oN+QwyX7VSHotibwubG3kpzbwKrfnyR6OOO+3Nk/53ADL7FmgHHz4TgrbaYKvvOw09u6QTx0oiH1cNCIOuN0CQ==} + engines: {node: '>= 20.19.0'} + + '@noble/post-quantum@0.5.4': + resolution: {integrity: sha512-leww0zzIirrvwaYMPI9fj6aRIlA/c6Y0/lifQQ1YOOyHEr0MNH3yYpjXeiVG+tWdPps4XxGclFWX2INPO3Yo5w==} + engines: {node: '>= 20.19.0'} + + '@nodelib/fs.scandir@2.1.5': + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} + + '@nodelib/fs.stat@2.0.5': + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} + + '@nodelib/fs.walk@1.2.8': + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} + + '@nolyfill/is-core-module@1.0.39': + resolution: {integrity: sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==} + engines: {node: '>=12.4.0'} + + '@paulmillr/qr@0.2.1': + resolution: {integrity: sha512-IHnV6A+zxU7XwmKFinmYjUcwlyK9+xkG3/s9KcQhI9BjQKycrJ1JRO+FbNYPwZiPKW3je/DR0k7w8/gLa5eaxQ==} + deprecated: 'Switch to "qr" (new package name) for security updates: npm install qr' + + '@protobufjs/aspromise@1.1.2': + resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==} + + '@protobufjs/base64@1.1.2': + resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==} + + '@protobufjs/codegen@2.0.5': + resolution: {integrity: sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==} + + '@protobufjs/eventemitter@1.1.1': + resolution: {integrity: sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==} + + '@protobufjs/fetch@1.1.1': + resolution: {integrity: sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==} + + '@protobufjs/float@1.0.2': + resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==} + + '@protobufjs/path@1.1.2': + resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==} + + '@protobufjs/pool@1.1.0': + resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==} + + '@protobufjs/utf8@1.1.2': + resolution: {integrity: sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug==} + + '@rtsao/scc@1.1.0': + resolution: {integrity: sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==} + + '@rushstack/eslint-patch@1.16.1': + resolution: {integrity: sha512-TvZbIpeKqGQQ7X0zSCvPH9riMSFQFSggnfBjFZ1mEoILW+UuXCKwOoPcgjMwiUtRqFZ8jWhPJc4um14vC6I4ag==} + + '@scure/base@1.1.9': + resolution: {integrity: sha512-8YKhl8GHiNI/pU2VMaofa2Tor7PJRAjwQLBBuilkJ9L5+13yVbC7JO/wS7piioAvPSwR3JKM1IJ/u4xQzbcXKg==} + + '@scure/base@1.2.6': + resolution: {integrity: sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg==} + + '@scure/bip32@1.4.0': + resolution: {integrity: sha512-sVUpc0Vq3tXCkDGYVWGIZTRfnvu8LoTDaev7vbwh0omSvVORONr960MQWdKqJDCReIEmTj3PAr73O3aoxz7OPg==} + + '@scure/bip32@1.7.0': + resolution: {integrity: sha512-E4FFX/N3f4B80AKWp5dP6ow+flD1LQZo/w8UnLGYZO674jS6YnYeepycOOksv+vLPSpgN35wgKgy+ybfTb2SMw==} + + '@scure/bip39@1.3.0': + resolution: {integrity: sha512-disdg7gHuTDZtY+ZdkmLpPCk7fxZSu3gBiEGuoC1XYxv9cGx3Z6cpTggCgW6odSOOIXCiDjuGejW+aJKCY/pIQ==} + + '@scure/bip39@1.6.0': + resolution: {integrity: sha512-+lF0BbLiJNwVlev4eKelw1WWLaiKXw7sSl8T6FvBlWkdX+94aGJ4o8XjUdlyhTCjd8c+B3KT3JfS8P0bLRNU6A==} + + '@simplewebauthn/browser@13.1.0': + resolution: {integrity: sha512-WuHZ/PYvyPJ9nxSzgHtOEjogBhwJfC8xzYkPC+rR/+8chl/ft4ngjiK8kSU5HtRJfczupyOh33b25TjYbvwAcg==} + + '@sindresorhus/is@4.6.0': + resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} + engines: {node: '>=10'} + + '@solana-program/system@0.10.0': + resolution: {integrity: sha512-Go+LOEZmqmNlfr+Gjy5ZWAdY5HbYzk2RBewD9QinEU/bBSzpFfzqDRT55JjFRBGJUvMgf3C2vfXEGT4i8DSI4g==} + peerDependencies: + '@solana/kit': ^5.0 + + '@solana-program/token@0.9.0': + resolution: {integrity: sha512-vnZxndd4ED4Fc56sw93cWZ2djEeeOFxtaPS8SPf5+a+JZjKA/EnKqzbE1y04FuMhIVrLERQ8uR8H2h72eZzlsA==} + peerDependencies: + '@solana/kit': ^5.0 + + '@solana/accounts@5.5.1': + resolution: {integrity: sha512-TfOY9xixg5rizABuLVuZ9XI2x2tmWUC/OoN556xwfDlhBHBjKfszicYYOyD6nbFmwTGYarCmyGIdteXxTXIdhQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/addresses@5.5.1': + resolution: {integrity: sha512-5xoah3Q9G30HQghu/9BiHLb5pzlPKRC3zydQDmE3O9H//WfayxTFppsUDCL6FjYUHqj/wzK6CWHySglc2RkpdA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/assertions@5.5.1': + resolution: {integrity: sha512-YTCSWAlGwSlVPnWtWLm3ukz81wH4j2YaCveK+TjpvUU88hTy6fmUqxi0+hvAMAe4zKXpJyj3Az7BrLJRxbIm4Q==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/codecs-core@5.5.1': + resolution: {integrity: sha512-TgBt//bbKBct0t6/MpA8ElaOA3sa8eYVvR7LGslCZ84WiAwwjCY0lW/lOYsFHJQzwREMdUyuEyy5YWBKtdh8Rw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/codecs-data-structures@5.5.1': + resolution: {integrity: sha512-97bJWGyUY9WvBz3mX1UV3YPWGDTez6btCfD0ip3UVEXJbItVuUiOkzcO5iFDUtQT5riKT6xC+Mzl+0nO76gd0w==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/codecs-numbers@5.5.1': + resolution: {integrity: sha512-rllMIZAHqmtvC0HO/dc/21wDuWaD0B8Ryv8o+YtsICQBuiL/0U4AGwH7Pi5GNFySYk0/crSuwfIqQFtmxNSPFw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/codecs-strings@5.5.1': + resolution: {integrity: sha512-7klX4AhfHYA+uKKC/nxRGP2MntbYQCR3N6+v7bk1W/rSxYuhNmt+FN8aoThSZtWIKwN6BEyR1167ka8Co1+E7A==} + engines: {node: '>=20.18.0'} + peerDependencies: + fastestsmallesttextencoderdecoder: ^1.0.22 + typescript: ^5.0.0 + peerDependenciesMeta: + fastestsmallesttextencoderdecoder: + optional: true + typescript: + optional: true + + '@solana/codecs@5.5.1': + resolution: {integrity: sha512-Vea29nJub/bXjfzEV7ZZQ/PWr1pYLZo3z0qW0LQL37uKKVzVFRQlwetd7INk3YtTD3xm9WUYr7bCvYUk3uKy2g==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/errors@5.5.1': + resolution: {integrity: sha512-vFO3p+S7HoyyrcAectnXbdsMfwUzY2zYFUc2DEe5BwpiE9J1IAxPBGjOWO6hL1bbYdBrlmjNx8DXCslqS+Kcmg==} + engines: {node: '>=20.18.0'} + hasBin: true + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/fast-stable-stringify@5.5.1': + resolution: {integrity: sha512-Ni7s2FN33zTzhTFgRjEbOVFO+UAmK8qi3Iu0/GRFYK4jN696OjKHnboSQH/EacQ+yGqS54bfxf409wU5dsLLCw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/functional@5.5.1': + resolution: {integrity: sha512-tTHoJcEQq3gQx5qsdsDJ0LEJeFzwNpXD80xApW9o/PPoCNimI3SALkZl+zNW8VnxRrV3l3yYvfHWBKe/X3WG3w==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/instruction-plans@5.5.1': + resolution: {integrity: sha512-7z3CB7YMcFKuVvgcnNY8bY6IsZ8LG61Iytbz7HpNVGX2u1RthOs1tRW8luTzSG1MPL0Ox7afyAVMYeFqSPHnaQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/instructions@5.5.1': + resolution: {integrity: sha512-h0G1CG6S+gUUSt0eo6rOtsaXRBwCq1+Js2a+Ps9Bzk9q7YHNFA75/X0NWugWLgC92waRp66hrjMTiYYnLBoWOQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/keys@5.5.1': + resolution: {integrity: sha512-KRD61cL7CRL+b4r/eB9dEoVxIf/2EJ1Pm1DmRYhtSUAJD2dJ5Xw8QFuehobOGm9URqQ7gaQl+Fkc1qvDlsWqKg==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/kit@5.5.1': + resolution: {integrity: sha512-irKUGiV2yRoyf+4eGQ/ZeCRxa43yjFEL1DUI5B0DkcfZw3cr0VJtVJnrG8OtVF01vT0OUfYOcUn6zJW5TROHvQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/nominal-types@5.5.1': + resolution: {integrity: sha512-I1ImR+kfrLFxN5z22UDiTWLdRZeKtU0J/pkWkO8qm/8WxveiwdIv4hooi8pb6JnlR4mSrWhq0pCIOxDYrL9GIQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/offchain-messages@5.5.1': + resolution: {integrity: sha512-g+xHH95prTU+KujtbOzj8wn+C7ZNoiLhf3hj6nYq3MTyxOXtBEysguc97jJveUZG0K97aIKG6xVUlMutg5yxhw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/options@5.5.1': + resolution: {integrity: sha512-eo971c9iLNLmk+yOFyo7yKIJzJ/zou6uKpy6mBuyb/thKtS/haiKIc3VLhyTXty3OH2PW8yOlORJnv4DexJB8A==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/plugin-core@5.5.1': + resolution: {integrity: sha512-VUZl30lDQFJeiSyNfzU1EjYt2QZvoBFKEwjn1lilUJw7KgqD5z7mbV7diJhT+dLFs36i0OsjXvq5kSygn8YJ3A==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/programs@5.5.1': + resolution: {integrity: sha512-7U9kn0Jsx1NuBLn5HRTFYh78MV4XN145Yc3WP/q5BlqAVNlMoU9coG5IUTJIG847TUqC1lRto3Dnpwm6T4YRpA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/promises@5.5.1': + resolution: {integrity: sha512-T9lfuUYkGykJmppEcssNiCf6yiYQxJkhiLPP+pyAc2z84/7r3UVIb2tNJk4A9sucS66pzJnVHZKcZVGUUp6wzA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-api@5.5.1': + resolution: {integrity: sha512-XWOQQPhKl06Vj0xi3RYHAc6oEQd8B82okYJ04K7N0Vvy3J4PN2cxeK7klwkjgavdcN9EVkYCChm2ADAtnztKnA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-parsed-types@5.5.1': + resolution: {integrity: sha512-HEi3G2nZqGEsa3vX6U0FrXLaqnUCg4SKIUrOe8CezD+cSFbRTOn3rCLrUmJrhVyXlHoQVaRO9mmeovk31jWxJg==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-spec-types@5.5.1': + resolution: {integrity: sha512-6OFKtRpIEJQs8Jb2C4OO8KyP2h2Hy1MFhatMAoXA+0Ik8S3H+CicIuMZvGZ91mIu/tXicuOOsNNLu3HAkrakrw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-spec@5.5.1': + resolution: {integrity: sha512-m3LX2bChm3E3by4mQrH4YwCAFY57QBzuUSWqlUw7ChuZ+oLLOq7b2czi4i6L4Vna67j3eCmB3e+4tqy1j5wy7Q==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-subscriptions-api@5.5.1': + resolution: {integrity: sha512-5Oi7k+GdeS8xR2ly1iuSFkAv6CZqwG0Z6b1QZKbEgxadE1XGSDrhM2cn59l+bqCozUWCqh4c/A2znU/qQjROlw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-subscriptions-channel-websocket@5.5.1': + resolution: {integrity: sha512-7tGfBBrYY8TrngOyxSHoCU5shy86iA9SRMRrPSyBhEaZRAk6dnbdpmUTez7gtdVo0BCvh9nzQtUycKWSS7PnFQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-subscriptions-spec@5.5.1': + resolution: {integrity: sha512-iq+rGq5fMKP3/mKHPNB6MC8IbVW41KGZg83Us/+LE3AWOTWV1WT20KT2iH1F1ik9roi42COv/TpoZZvhKj45XQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-subscriptions@5.5.1': + resolution: {integrity: sha512-CTMy5bt/6mDh4tc6vUJms9EcuZj3xvK0/xq8IQ90rhkpYvate91RjBP+egvjgSayUg9yucU9vNuUpEjz4spM7w==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-transformers@5.5.1': + resolution: {integrity: sha512-OsWqLCQdcrRJKvHiMmwFhp9noNZ4FARuMkHT5us3ustDLXaxOjF0gfqZLnMkulSLcKt7TGXqMhBV+HCo7z5M8Q==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-transport-http@5.5.1': + resolution: {integrity: sha512-yv8GoVSHqEV0kUJEIhkdOVkR2SvJ6yoWC51cJn2rSV7plr6huLGe0JgujCmB7uZhhaLbcbP3zxXxu9sOjsi7Fg==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc-types@5.5.1': + resolution: {integrity: sha512-bibTFQ7PbHJJjGJPmfYC2I+/5CRFS4O2p9WwbFraX1Keeel+nRrt/NBXIy8veP5AEn2sVJIyJPpWBRpCx1oATA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/rpc@5.5.1': + resolution: {integrity: sha512-ku8zTUMrkCWci66PRIBC+1mXepEnZH/q1f3ck0kJZ95a06bOTl5KU7HeXWtskkyefzARJ5zvCs54AD5nxjQJ+A==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/signers@5.5.1': + resolution: {integrity: sha512-FY0IVaBT2kCAze55vEieR6hag4coqcuJ31Aw3hqRH7mv6sV8oqwuJmUrx+uFwOp1gwd5OEAzlv6N4hOOple4sQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/subscribable@5.5.1': + resolution: {integrity: sha512-9K0PsynFq0CsmK1CDi5Y2vUIJpCqkgSS5yfDN0eKPgHqEptLEaia09Kaxc90cSZDZU5mKY/zv1NBmB6Aro9zQQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/sysvars@5.5.1': + resolution: {integrity: sha512-k3Quq87Mm+geGUu1GWv6knPk0ALsfY6EKSJGw9xUJDHzY/RkYSBnh0RiOrUhtFm2TDNjOailg8/m0VHmi3reFA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/transaction-confirmation@5.5.1': + resolution: {integrity: sha512-j4mKlYPHEyu+OD7MBt3jRoX4ScFgkhZC6H65on4Fux6LMScgivPJlwnKoZMnsgxFgWds0pl+BYzSiALDsXlYtw==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/transaction-messages@5.5.1': + resolution: {integrity: sha512-aXyhMCEaAp3M/4fP0akwBBQkFPr4pfwoC5CLDq999r/FUwDax2RE/h4Ic7h2Xk+JdcUwsb+rLq85Y52hq84XvQ==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@solana/transactions@5.5.1': + resolution: {integrity: sha512-8hHtDxtqalZ157pnx6p8k10D7J/KY/biLzfgh9R09VNLLY3Fqi7kJvJCr7M2ik3oRll56pxhraAGCC9yIT6eOA==} + engines: {node: '>=20.18.0'} + peerDependencies: + typescript: ^5.0.0 + peerDependenciesMeta: + typescript: + optional: true + + '@swc/helpers@0.5.15': + resolution: {integrity: sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==} + + '@szmarczak/http-timer@4.0.6': + resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==} + engines: {node: '>=10'} + + '@tailwindcss/node@4.1.18': + resolution: {integrity: sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ==} + + '@tailwindcss/oxide-android-arm64@4.1.18': + resolution: {integrity: sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [android] + + '@tailwindcss/oxide-darwin-arm64@4.1.18': + resolution: {integrity: sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + + '@tailwindcss/oxide-darwin-x64@4.1.18': + resolution: {integrity: sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + + '@tailwindcss/oxide-freebsd-x64@4.1.18': + resolution: {integrity: sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [freebsd] + + '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18': + resolution: {integrity: sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA==} + engines: {node: '>= 10'} + cpu: [arm] + os: [linux] + + '@tailwindcss/oxide-linux-arm64-gnu@4.1.18': + resolution: {integrity: sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@tailwindcss/oxide-linux-arm64-musl@4.1.18': + resolution: {integrity: sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@tailwindcss/oxide-linux-x64-gnu@4.1.18': + resolution: {integrity: sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@tailwindcss/oxide-linux-x64-musl@4.1.18': + resolution: {integrity: sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + libc: [musl] + + '@tailwindcss/oxide-wasm32-wasi@4.1.18': + resolution: {integrity: sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==} + engines: {node: '>=14.0.0'} + cpu: [wasm32] + bundledDependencies: + - '@napi-rs/wasm-runtime' + - '@emnapi/core' + - '@emnapi/runtime' + - '@tybys/wasm-util' + - '@emnapi/wasi-threads' + - tslib + + '@tailwindcss/oxide-win32-arm64-msvc@4.1.18': + resolution: {integrity: sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + + '@tailwindcss/oxide-win32-x64-msvc@4.1.18': + resolution: {integrity: sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + + '@tailwindcss/oxide@4.1.18': + resolution: {integrity: sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A==} + engines: {node: '>= 10'} + + '@tailwindcss/postcss@4.1.18': + resolution: {integrity: sha512-Ce0GFnzAOuPyfV5SxjXGn0CubwGcuDB0zcdaPuCSzAa/2vII24JTkH+I6jcbXLb1ctjZMZZI6OjDaLPJQL1S0g==} + + '@tanstack/query-core@5.90.12': + resolution: {integrity: sha512-T1/8t5DhV/SisWjDnaiU2drl6ySvsHj1bHBCWNXd+/T+Hh1cf6JodyEYMd5sgwm+b/mETT4EV3H+zCVczCU5hg==} + + '@tanstack/react-query@5.90.12': + resolution: {integrity: sha512-graRZspg7EoEaw0a8faiUASCyJrqjKPdqJ9EwuDRUF9mEYJ1YPczI9H+/agJ0mOJkPCJDk0lsz5QTrLZ/jQ2rg==} + peerDependencies: + react: ^18 || ^19 + + '@tybys/wasm-util@0.10.3': + resolution: {integrity: sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==} + + '@types/cacheable-request@6.0.3': + resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} + + '@types/debug@4.1.13': + resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==} + + '@types/estree@1.0.9': + resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==} + + '@types/http-cache-semantics@4.2.0': + resolution: {integrity: sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==} + + '@types/json-schema@7.0.15': + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + + '@types/json5@0.0.29': + resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} + + '@types/keyv@3.1.4': + resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} + + '@types/lodash@4.17.25': + resolution: {integrity: sha512-+K1NIO8I+F9/wNulfVvu23QYd0Pe9/OCqRrim4NoYIf1VoEDL90Ve4ClzpyqBLc7NpGGWRvYNCKZ1BE/Jpf8dQ==} + + '@types/ms@2.1.0': + resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} + + '@types/node@20.19.27': + resolution: {integrity: sha512-N2clP5pJhB2YnZJ3PIHFk5RkygRX5WO/5f0WC08tp0wd+sv0rsJk3MqWn3CbNmT2J505a5336jaQj4ph1AdMug==} + + '@types/react-dom@19.1.9': + resolution: {integrity: sha512-qXRuZaOsAdXKFyOhRBg6Lqqc0yay13vN7KrIg4L7N4aaHN68ma9OK3NE1BoDFgFOTfM7zg+3/8+2n8rLUH3OKQ==} + peerDependencies: + '@types/react': ^19.0.0 + + '@types/react@19.1.12': + resolution: {integrity: sha512-cMoR+FoAf/Jyq6+Df2/Z41jISvGZZ2eTlnsaJRptmZ76Caldwy1odD4xTr/gNV9VLj0AWgg/nmkevIyUfIIq5w==} + + '@types/responselike@1.0.3': + resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} + + '@typescript-eslint/eslint-plugin@8.66.0': + resolution: {integrity: sha512-p088eaGrzYz1s+7cov0aMOCkNGTJlVxF4jgubf28c8L0Cv9Rloj8YBHnv4hXLq6IIEE1AsjNWavO+k+8kP2Y0A==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + '@typescript-eslint/parser': ^8.66.0 + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/parser@8.66.0': + resolution: {integrity: sha512-X6ypGChaWYk6PBtUg2BwuTZEFFcHJAtGTVJ9/lCTOufhZ4i9fNolQNnktq+kkMCwMj7V8Svsq7+TxSDslmhE0g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/project-service@8.66.0': + resolution: {integrity: sha512-7MthGPTt4BP69lSryqpqq8HQqxuzynssckL/jyDyk3+TNMQ3y2jFWkptCrktWvBrP+EH787Nl5N5Qpw7WZg+5g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/scope-manager@8.66.0': + resolution: {integrity: sha512-8TGcH25j9zqJ/IULB/ppyhRvxA8QYfFEZ7nfbg6/BN9spDgb8fPWQXlE5l8TWBL50EtUx007uZ1o9VOwrq2/9g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/tsconfig-utils@8.66.0': + resolution: {integrity: sha512-9D5gLYZG4rOjcoag8MQ/fWI8WqA9wcPDyOGyWtWFhvM1lHRbliqUSPIY5J3zqCU1tvSwzXxnnjhQhz5Ne7mJ4g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/type-utils@8.66.0': + resolution: {integrity: sha512-LG2dWfjZQQp0ADtAu/EWJVayefGL2UEZ3CDeI44D9v3rXB/WYUqE/jpO28KrEKul5AySrmI+Zh1v6v+xW2U9+g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/types@8.66.0': + resolution: {integrity: sha512-H6gcYaSDOyvL3AD/jHUtUFo2jqGgn/F6nuyuZSu0QTesxL+cP4dQoIMrODRofuJC09g64+WgZ6tE19Y1N2YIFQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/typescript-estree@8.66.0': + resolution: {integrity: sha512-8/x4INiiQb10jGgXYD7116/zQ+OL84ZIFn0za68wwFHCanT/VLbBEroWht8RV8fn0/ZCAoazHLQgwUC0UQcDfg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/utils@8.66.0': + resolution: {integrity: sha512-jasearZPolBw5NJNYGMwxzHMF83niVWmMU1VdHzG1CyfI2VS7f7nZltnKtHcg20hW+7Uo5GfK4MeDPoU3qI8EA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.1.0' + + '@typescript-eslint/visitor-keys@8.66.0': + resolution: {integrity: sha512-dkKR8q+lKciskj1Y3vthHktl+3cMLWGyVUP23bRiPZ5O9BRT++4EqDDV+TVeIKBL1VXVEqrJlz8MYbcnvJcAlg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@unrs/resolver-binding-android-arm-eabi@1.12.2': + resolution: {integrity: sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==} + cpu: [arm] + os: [android] + + '@unrs/resolver-binding-android-arm64@1.12.2': + resolution: {integrity: sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==} + cpu: [arm64] + os: [android] + + '@unrs/resolver-binding-darwin-arm64@1.12.2': + resolution: {integrity: sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==} + cpu: [arm64] + os: [darwin] + + '@unrs/resolver-binding-darwin-x64@1.12.2': + resolution: {integrity: sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==} + cpu: [x64] + os: [darwin] + + '@unrs/resolver-binding-freebsd-x64@1.12.2': + resolution: {integrity: sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==} + cpu: [x64] + os: [freebsd] + + '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2': + resolution: {integrity: sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==} + cpu: [arm] + os: [linux] + + '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2': + resolution: {integrity: sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==} + cpu: [arm] + os: [linux] + + '@unrs/resolver-binding-linux-arm64-gnu@1.12.2': + resolution: {integrity: sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-arm64-musl@1.12.2': + resolution: {integrity: sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@unrs/resolver-binding-linux-loong64-gnu@1.12.2': + resolution: {integrity: sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==} + cpu: [loong64] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-loong64-musl@1.12.2': + resolution: {integrity: sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==} + cpu: [loong64] + os: [linux] + libc: [musl] + + '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2': + resolution: {integrity: sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2': + resolution: {integrity: sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-riscv64-musl@1.12.2': + resolution: {integrity: sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==} + cpu: [riscv64] + os: [linux] + libc: [musl] + + '@unrs/resolver-binding-linux-s390x-gnu@1.12.2': + resolution: {integrity: sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-x64-gnu@1.12.2': + resolution: {integrity: sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@unrs/resolver-binding-linux-x64-musl@1.12.2': + resolution: {integrity: sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@unrs/resolver-binding-openharmony-arm64@1.12.2': + resolution: {integrity: sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==} + cpu: [arm64] + os: [openharmony] + + '@unrs/resolver-binding-wasm32-wasi@1.12.2': + resolution: {integrity: sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==} + engines: {node: '>=14.0.0'} + cpu: [wasm32] + + '@unrs/resolver-binding-win32-arm64-msvc@1.12.2': + resolution: {integrity: sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==} + cpu: [arm64] + os: [win32] + + '@unrs/resolver-binding-win32-ia32-msvc@1.12.2': + resolution: {integrity: sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==} + cpu: [ia32] + os: [win32] + + '@unrs/resolver-binding-win32-x64-msvc@1.12.2': + resolution: {integrity: sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==} + cpu: [x64] + os: [win32] + + '@vue/reactivity@3.5.41': + resolution: {integrity: sha512-rznsqKM0np0x18EjzF8x88MpEhdNsffbvFbckLL5+oUKz1BxAImEmO7J1ArRYSyo6aQaVoBDp7jEkT91OOxydA==} + + '@vue/shared@3.5.41': + resolution: {integrity: sha512-IOnwSCma8j+9xJT6b8H0dEYidC80NsYmNMlZxRsukYcSoGaDBohog5hDxzeUXdFeGWFA++vWvxqOmrr96VlqMA==} + + '@walletconnect/core@2.21.8': + resolution: {integrity: sha512-MD1SY7KAeHWvufiBK8C1MwP9/pxxI7SnKi/rHYfjco2Xvke+M+Bbm2OzvuSN7dYZvwLTkZCiJmBccTNVPCpSUQ==} + engines: {node: '>=18'} + + '@walletconnect/environment@1.0.1': + resolution: {integrity: sha512-T426LLZtHj8e8rYnKfzsw1aG6+M0BT1ZxayMdv/p8yM0MU+eJDISqNY3/bccxRr4LrF9csq02Rhqt08Ibl0VRg==} + + '@walletconnect/events@1.0.1': + resolution: {integrity: sha512-NPTqaoi0oPBVNuLv7qPaJazmGHs5JGyO8eEAk5VGKmJzDR7AHzD4k6ilox5kxk1iwiOnFopBOOMLs86Oa76HpQ==} + + '@walletconnect/heartbeat@1.2.2': + resolution: {integrity: sha512-uASiRmC5MwhuRuf05vq4AT48Pq8RMi876zV8rr8cV969uTOzWdB/k+Lj5yI2PBtB1bGQisGen7MM1GcZlQTBXw==} + + '@walletconnect/jsonrpc-provider@1.0.14': + resolution: {integrity: sha512-rtsNY1XqHvWj0EtITNeuf8PHMvlCLiS3EjQL+WOkxEOA4KPxsohFnBDeyPYiNm4ZvkQdLnece36opYidmtbmow==} + + '@walletconnect/jsonrpc-types@1.0.4': + resolution: {integrity: sha512-P6679fG/M+wuWg9TY8mh6xFSdYnFyFjwFelxyISxMDrlbXokorEVXYOxiqEbrU3x1BmBoCAJJ+vtEaEoMlpCBQ==} + + '@walletconnect/jsonrpc-utils@1.0.8': + resolution: {integrity: sha512-vdeb03bD8VzJUL6ZtzRYsFMq1eZQcM3EAzT0a3st59dyLfJ0wq+tKMpmGH7HlB7waD858UWgfIcudbPFsbzVdw==} + + '@walletconnect/jsonrpc-ws-connection@1.0.16': + resolution: {integrity: sha512-G81JmsMqh5nJheE1mPst1W0WfVv0SG3N7JggwLLGnI7iuDZJq8cRJvQwLGKHn5H1WTW7DEPCo00zz5w62AbL3Q==} + + '@walletconnect/keyvaluestorage@1.1.1': + resolution: {integrity: sha512-V7ZQq2+mSxAq7MrRqDxanTzu2RcElfK1PfNYiaVnJgJ7Q7G7hTVwF8voIBx92qsRyGHZihrwNPHuZd1aKkd0rA==} + peerDependencies: + '@react-native-async-storage/async-storage': 1.x + peerDependenciesMeta: + '@react-native-async-storage/async-storage': + optional: true + + '@walletconnect/logger@2.1.2': + resolution: {integrity: sha512-aAb28I3S6pYXZHQm5ESB+V6rDqIYfsnHaQyzFbwUUBFY4H0OXx/YtTl8lvhUNhMMfb9UxbwEBS253TlXUYJWSw==} + + '@walletconnect/relay-api@1.0.11': + resolution: {integrity: sha512-tLPErkze/HmC9aCmdZOhtVmYZq1wKfWTJtygQHoWtgg722Jd4homo54Cs4ak2RUFUZIGO2RsOpIcWipaua5D5Q==} + + '@walletconnect/relay-auth@1.1.0': + resolution: {integrity: sha512-qFw+a9uRz26jRCDgL7Q5TA9qYIgcNY8jpJzI1zAWNZ8i7mQjaijRnWFKsCHAU9CyGjvt6RKrRXyFtFOpWTVmCQ==} + + '@walletconnect/safe-json@1.0.2': + resolution: {integrity: sha512-Ogb7I27kZ3LPC3ibn8ldyUr5544t3/STow9+lzz7Sfo808YD7SBWk7SAsdBFlYgP2zDRy2hS3sKRcuSRM0OTmA==} + + '@walletconnect/sign-client@2.21.8': + resolution: {integrity: sha512-lTcUbMjQ0YUZ5wzCLhpBeS9OkWYgLLly6BddEp2+pm4QxiwCCU2Nao0nBJXgzKbZYQOgrEGqtdm/7ze67gjzRA==} + deprecated: 'Reliability and performance improvements. See: https://github.com/WalletConnect/walletconnect-monorepo/releases' + + '@walletconnect/time@1.0.2': + resolution: {integrity: sha512-uzdd9woDcJ1AaBZRhqy5rNC9laqWGErfc4dxA9a87mPdKOgWMD85mcFo9dIYIts/Jwocfwn07EC6EzclKubk/g==} + + '@walletconnect/types@2.21.8': + resolution: {integrity: sha512-xuLIPrLxe6viMu8Uk28Nf0sgyMy+4oT0mroOjBe5Vqyft8GTiwUBKZXmrGU9uDzZsYVn1FXLO9CkuNHXda3ODA==} + + '@walletconnect/utils@2.21.8': + resolution: {integrity: sha512-HtMraGJ9qXo55l4wGSM1aZvyz0XVv460iWhlRGAyRl9Yz8RQeKyXavDhwBfcTFha/6kwLxPExqQ+MURtKeVVXw==} + + '@walletconnect/window-getters@1.0.1': + resolution: {integrity: sha512-vHp+HqzGxORPAN8gY03qnbTMnhqIwjeRJNOMOAzePRg4xVEEE2WvYsI9G2NMjOknA8hnuYbU3/hwLcKbjhc8+Q==} + + '@walletconnect/window-metadata@1.0.1': + resolution: {integrity: sha512-9koTqyGrM2cqFRW517BPY/iEtUDx2r1+Pwwu5m7sJ7ka79wi3EyqhqcICk/yDmv6jAS1rjKgTKXlEhanYjijcA==} + + abitype@1.0.6: + resolution: {integrity: sha512-MMSqYh4+C/aVqI2RQaWqbvI4Kxo5cQV40WQ4QFtDnNzCkqChm8MuENhElmynZlO0qUy/ObkEUaXtKqYnx1Kp3A==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abitype@1.0.8: + resolution: {integrity: sha512-ZeiI6h3GnW06uYDLx0etQtX/p8E24UaHHBj57RSjK7YBFe7iuVn07EDpOeP451D06sF27VOz9JJPlIKJmXgkEg==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abitype@1.1.0: + resolution: {integrity: sha512-6Vh4HcRxNMLA0puzPjM5GBgT4aAcFGKZzSgAXvuZ27shJP6NEpielTuqbBmZILR5/xd0PizkBGy5hReKz9jl5A==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3.22.0 || ^4.0.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abitype@1.2.3: + resolution: {integrity: sha512-Ofer5QUnuUdTFsBRwARMoWKOH1ND5ehwYhJ3OJ/BQO+StkwQjHw0XyVh4vDttzHB7QOFhPHa/o413PJ82gU/Tg==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3.22.0 || ^4.0.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abitype@1.3.0: + resolution: {integrity: sha512-fk6Te+bojIFrMvMZrnOO+SxCB+RUksTGOzq/60ZRvs1L+BVzvi2bqt9L3W/17ZLdZsyM1FuYf65P5nlmoiH1Bg==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3.22.0 || ^4.0.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + ably@2.17.1: + resolution: {integrity: sha512-70yfXHoM7JtJD/8FCtPD1gkWW0f+AJqbJp0PsqDAqiyxFB8cPFY+FuKHgNTYb8eRHKXq8hT1xiDphUcY0+GHnA==} + engines: {node: '>=16'} + peerDependencies: + react: '>=16.8.0' + react-dom: '>=16.8.0' + peerDependenciesMeta: + react: + optional: true + react-dom: + optional: true + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn@8.18.0: + resolution: {integrity: sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==} + engines: {node: '>=0.4.0'} + hasBin: true + + ajv@6.15.0: + resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==} + + ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + + anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} + + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + aria-query@5.3.2: + resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==} + engines: {node: '>= 0.4'} + + array-buffer-byte-length@1.0.2: + resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==} + engines: {node: '>= 0.4'} + + array-includes@3.1.9: + resolution: {integrity: sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==} + engines: {node: '>= 0.4'} + + array.prototype.findlast@1.2.5: + resolution: {integrity: sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==} + engines: {node: '>= 0.4'} + + array.prototype.findlastindex@1.2.6: + resolution: {integrity: sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==} + engines: {node: '>= 0.4'} + + array.prototype.flat@1.3.3: + resolution: {integrity: sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==} + engines: {node: '>= 0.4'} + + array.prototype.flatmap@1.3.3: + resolution: {integrity: sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==} + engines: {node: '>= 0.4'} + + array.prototype.tosorted@1.1.4: + resolution: {integrity: sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==} + engines: {node: '>= 0.4'} + + arraybuffer.prototype.slice@1.0.4: + resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==} + engines: {node: '>= 0.4'} + + ast-types-flow@0.0.8: + resolution: {integrity: sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==} + + async-function@1.0.0: + resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==} + engines: {node: '>= 0.4'} + + async-mutex@0.5.0: + resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==} + + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + + atomic-sleep@1.0.0: + resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} + engines: {node: '>=8.0.0'} + + available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} + + aws4fetch@1.0.20: + resolution: {integrity: sha512-/djoAN709iY65ETD6LKCtyyEI04XIBP5xVvfmNxsEP0uJB5tyaGBztSryRr4HqMStr9R06PisQE7m9zDTXKu6g==} + + axe-core@4.13.0: + resolution: {integrity: sha512-UzGt8zg7Ny8djbYMhxl2zuEevVa7r2gJjYY5Lwr1xM7+XU2nd6CkIWFTVcCIbAP63vSz71NaVyyuSk9lHKcy0A==} + engines: {node: '>=4'} + + axios-retry@4.5.0: + resolution: {integrity: sha512-aR99oXhpEDGo0UuAlYcn2iGRds30k366Zfa05XWScR9QaQD4JYiP3/1Qt1u7YlefUOK+cn0CcwoL1oefavQUlQ==} + peerDependencies: + axios: 0.x || 1.x + + axios@1.16.0: + resolution: {integrity: sha512-6hp5CwvTPlN2A31g5dxnwAX0orzM7pmCRDLnZSX772mv8WDqICwFjowHuPs04Mc8deIld1+ejhtaMn5vp6b+1w==} + + axobject-query@4.1.0: + resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==} + engines: {node: '>= 0.4'} + + balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + + balanced-match@4.0.4: + resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==} + engines: {node: 18 || 20 || >=22} + + base-x@5.0.1: + resolution: {integrity: sha512-M7uio8Zt++eg3jPj+rHMfCC+IuygQHHCOU+IYsVtik6FWjuYpVt/+MRKcgsAMHh8mMFAwnB+Bs+mTrFiXjMzKg==} + + base64-js@1.0.2: + resolution: {integrity: sha512-ZXBDPMt/v/8fsIqn+Z5VwrhdR6jVka0bYobHdGia0Nxi7BJ9i/Uvml3AocHIBtIIBhZjBw5MR0aR4ROs/8+SNg==} + engines: {node: '>= 0.4'} + + base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + + blakejs@1.2.1: + resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==} + + bops@1.0.1: + resolution: {integrity: sha512-qCMBuZKP36tELrrgXpAfM+gHzqa0nLsWZ+L37ncsb8txYlnAoxOPpVp+g7fK0sGkMXfA0wl8uQkESqw3v4HNag==} + + bowser@2.14.1: + resolution: {integrity: sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==} + + brace-expansion@1.1.18: + resolution: {integrity: sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==} + + brace-expansion@5.0.9: + resolution: {integrity: sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==} + engines: {node: 20 || >=22} + + braces@3.0.3: + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} + + brotli-wasm@3.0.1: + resolution: {integrity: sha512-U3K72/JAi3jITpdhZBqzSUq+DUY697tLxOuFXB+FpAE/Ug+5C3VZrv4uA674EUZHxNAuQ9wETXNqQkxZD6oL4A==} + engines: {node: '>=v18.0.0'} + + bs58@6.0.0: + resolution: {integrity: sha512-PD0wEnEYg6ijszw/u8s+iI3H17cTymlrwkKhDhPZq+Sokl3AU4htyBFTjAeNAlCCmg0f53g6ih3jATyCKftTfw==} + + buffer@6.0.3: + resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + + cacheable-lookup@5.0.4: + resolution: {integrity: sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==} + engines: {node: '>=10.6.0'} + + cacheable-request@7.0.4: + resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==} + engines: {node: '>=8'} + + call-bind-apply-helpers@1.0.2: + resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} + engines: {node: '>= 0.4'} + + call-bind@1.0.9: + resolution: {integrity: sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==} + engines: {node: '>= 0.4'} + + call-bound@1.0.4: + resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} + engines: {node: '>= 0.4'} + + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + + caniuse-lite@1.0.30001809: + resolution: {integrity: sha512-xxWVywk6a6Arlk+hymeycyn/VgqEfLDxupvhH/xiY5SJ/18kmi9o6MiO320DCUzypORHLtvh0I4i04tUhCNHNQ==} + + centrifuge@5.7.0: + resolution: {integrity: sha512-Ptx7ELyVc7/KgzpadVlISTtdTWsuzumze5/vo9sH4RsvtFulJJMhmKr/cNDg6se1eKKbS6ZywIBl4eSZxqY3fw==} + + chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + + chalk@5.6.2: + resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==} + engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} + + charenc@0.0.2: + resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} + + chokidar@5.0.0: + resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==} + engines: {node: '>= 20.19.0'} + + client-only@0.0.1: + resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==} + + clone-response@1.0.3: + resolution: {integrity: sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==} + + clsx@1.2.1: + resolution: {integrity: sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==} + engines: {node: '>=6'} + + clsx@2.1.1: + resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==} + engines: {node: '>=6'} + + color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + + color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + + commander@14.0.2: + resolution: {integrity: sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==} + engines: {node: '>=20'} + + concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + + cookie-es@1.2.3: + resolution: {integrity: sha512-lXVyvUvrNXblMqzIRrxHb57UUVmqsSWlxqt3XIjCkUP0wDAf6uicO6KMbEgYrMNtEvWgWHwe42CKxPu9MYAnWw==} + + crc-32@1.2.2: + resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} + engines: {node: '>=0.8'} + hasBin: true + + cross-fetch@4.1.0: + resolution: {integrity: sha512-uKm5PU+MHTootlWEY+mZ4vvXoCn4fLQxT9dSc1sXVMSFkINTJVN8cAQROpwcKm8bJ/c7rgZVIBWzH5T78sNZZw==} + + cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} + + crossws@0.3.5: + resolution: {integrity: sha512-ojKiDvcmByhwa8YYqbQI/hg7MEU0NC03+pSdEq4ZUnZR9xXpwk7E43SMNGkn+JxJGPFtNvQ48+vV2p+P1ml5PA==} + + crypt@0.0.2: + resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} + + csstype@3.2.3: + resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==} + + damerau-levenshtein@1.0.8: + resolution: {integrity: sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==} + + data-view-buffer@1.0.2: + resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==} + engines: {node: '>= 0.4'} + + data-view-byte-length@1.0.2: + resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==} + engines: {node: '>= 0.4'} + + data-view-byte-offset@1.0.1: + resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==} + engines: {node: '>= 0.4'} + + debug@3.2.7: + resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + decode-uri-component@0.2.2: + resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} + engines: {node: '>=0.10'} + + decompress-response@6.0.0: + resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} + engines: {node: '>=10'} + + deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + + defer-to-connect@2.0.1: + resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==} + engines: {node: '>=10'} + + define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} + engines: {node: '>= 0.4'} + + define-properties@1.2.1: + resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} + engines: {node: '>= 0.4'} + + defu@6.1.7: + resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==} + + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} + + destr@2.0.5: + resolution: {integrity: sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==} + + detect-browser@5.3.0: + resolution: {integrity: sha512-53rsFbGdwMwlF7qvCt0ypLM5V5/Mbl0szB7GPN8y9NCcbknYOeVVXdrXEq+90IwAfrrzt6Hd+u2E2ntakICU8w==} + + detect-libc@2.1.2: + resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==} + engines: {node: '>=8'} + + doctrine@2.1.0: + resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} + engines: {node: '>=0.10.0'} + + dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} + + duplexify@4.1.3: + resolution: {integrity: sha512-M3BmBhwJRZsSx38lZyhE53Csddgzl5R7xGJNk7CVddZD6CcmwMCH8J+7AprIrQKH7TonKxaCjcv27Qmf+sQ+oA==} + + eciesjs@0.4.17: + resolution: {integrity: sha512-TOOURki4G7sD1wDCjj7NfLaXZZ49dFOeEb5y39IXpb8p0hRzVvfvzZHOi5JcT+PpyAbi/Y+lxPb8eTag2WYH8w==} + engines: {bun: '>=1', deno: '>=2', node: '>=16'} + + emoji-regex@9.2.2: + resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} + + end-of-stream@1.4.5: + resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} + + enhanced-resolve@5.24.5: + resolution: {integrity: sha512-L1l8TNvomm6UVW5B253AGxQagSQr+vGwhMlrrfRS2qmhx46AMpMVJKQYLvWYbysTMY8VoicOvzHzoHMbyzB+4A==} + engines: {node: '>=10.13.0'} + + es-abstract-get@1.0.0: + resolution: {integrity: sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg==} + engines: {node: '>= 0.4'} + + es-abstract@1.24.2: + resolution: {integrity: sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==} + engines: {node: '>= 0.4'} + + es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} + + es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} + + es-iterator-helpers@1.4.0: + resolution: {integrity: sha512-c/A0P0oxkACDc+cKWw8evLXK83oBKgn0qPOqCYT4x9uolpCIJAcYvJC9QYKNDRPsTeGyCrQ326jrvgZWdCdK5Q==} + engines: {node: '>= 0.4'} + + es-object-atoms@1.1.2: + resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==} + engines: {node: '>= 0.4'} + + es-set-tostringtag@2.1.0: + resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} + engines: {node: '>= 0.4'} + + es-shim-unscopables@1.1.0: + resolution: {integrity: sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==} + engines: {node: '>= 0.4'} + + es-to-primitive@1.3.4: + resolution: {integrity: sha512-yPDz7wqpg1/mmHLmS3tcfTfbw5f1eryXvyghYBffGdERwe+mV7ZcWzTR8LR17Kvqt3qfPurjlonmnq3MKXIOXw==} + engines: {node: '>= 0.4'} + + es-toolkit@1.39.3: + resolution: {integrity: sha512-Qb/TCFCldgOy8lZ5uC7nLGdqJwSabkQiYQShmw4jyiPk1pZzaYWTwaYKYP7EgLccWYgZocMrtItrwh683voaww==} + + escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + + eslint-config-next@15.5.9: + resolution: {integrity: sha512-852JYI3NkFNzW8CqsMhI0K2CDRxTObdZ2jQJj5CtpEaOkYHn13107tHpNuD/h0WRpU4FAbCdUaxQsrfBtNK9Kw==} + peerDependencies: + eslint: ^7.23.0 || ^8.0.0 || ^9.0.0 + typescript: '>=3.3.1' + peerDependenciesMeta: + typescript: + optional: true + + eslint-import-resolver-node@0.3.10: + resolution: {integrity: sha512-tRrKqFyCaKict5hOd244sL6EQFNycnMQnBe+j8uqGNXYzsImGbGUU4ibtoaBmv5FLwJwcFJNeg1GeVjQfbMrDQ==} + + eslint-import-resolver-typescript@3.10.1: + resolution: {integrity: sha512-A1rHYb06zjMGAxdLSkN2fXPBwuSaQ0iO5M/hdyS0Ajj1VBaRp0sPD3dn1FhME3c/JluGFbwSxyCfqdSbtQLAHQ==} + engines: {node: ^14.18.0 || >=16.0.0} + peerDependencies: + eslint: '*' + eslint-plugin-import: '*' + eslint-plugin-import-x: '*' + peerDependenciesMeta: + eslint-plugin-import: + optional: true + eslint-plugin-import-x: + optional: true + + eslint-module-utils@2.14.0: + resolution: {integrity: sha512-W2WCRZ9Dqntd+2u8jJcVMV2PKulc6RdLgUUoh/yQr3uB6lo/ZOeGx11sv60/8S4QFFKNslAlWhr9u0Ef7ZW6Ig==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: '*' + eslint-import-resolver-node: '*' + eslint-import-resolver-typescript: '*' + eslint-import-resolver-webpack: '*' + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + eslint: + optional: true + eslint-import-resolver-node: + optional: true + eslint-import-resolver-typescript: + optional: true + eslint-import-resolver-webpack: + optional: true + + eslint-plugin-import@2.32.0: + resolution: {integrity: sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9 + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + + eslint-plugin-jsx-a11y@6.10.2: + resolution: {integrity: sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==} + engines: {node: '>=4.0'} + peerDependencies: + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9 + + eslint-plugin-react-hooks@5.2.0: + resolution: {integrity: sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==} + engines: {node: '>=10'} + peerDependencies: + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 + + eslint-plugin-react@7.37.5: + resolution: {integrity: sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==} + engines: {node: '>=4'} + peerDependencies: + eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7 + + eslint-scope@8.4.0: + resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + eslint-visitor-keys@4.2.1: + resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint-visitor-keys@5.0.1: + resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==} + engines: {node: ^20.19.0 || ^22.13.0 || >=24} + + eslint@9.39.2: + resolution: {integrity: sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + hasBin: true + peerDependencies: + jiti: '*' + peerDependenciesMeta: + jiti: + optional: true + + espree@10.4.0: + resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + esquery@1.7.0: + resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==} + engines: {node: '>=0.10'} + + esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + + estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + + esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + + ethereum-cryptography@2.2.1: + resolution: {integrity: sha512-r/W8lkHSiTLxUxW8Rf3u4HGB0xQweG2RyETjywylKZSzLWoWAijRz8WCuOtJ6wah+avllXBqZuk29HCCvhEIRg==} + + eventemitter3@5.0.1: + resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} + + eventemitter3@5.0.4: + resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==} + + events@3.3.0: + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} + + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + + fast-glob@3.3.1: + resolution: {integrity: sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==} + engines: {node: '>=8.6.0'} + + fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + + fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + + fast-redact@3.5.0: + resolution: {integrity: sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A==} + engines: {node: '>=6'} + + fast-safe-stringify@2.1.1: + resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} + + fastestsmallesttextencoderdecoder@1.0.22: + resolution: {integrity: sha512-Pb8d48e+oIuY4MaM64Cd7OW1gt4nxCHs7/ddPPZ/Ic3sg8yVGM7O9wDvZ7us6ScaUupzM+pfBolwtYhN1IxBIw==} + + fastq@1.20.1: + resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==} + + fdir@6.5.0: + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + + file-entry-cache@8.0.0: + resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==} + engines: {node: '>=16.0.0'} + + fill-range@7.1.1: + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} + engines: {node: '>=8'} + + filter-obj@1.1.0: + resolution: {integrity: sha512-8rXg1ZnX7xzy2NGDVkBVaAy+lSlPNwad13BtgSlLuxfIslyt5Vg64U7tFcCt4WS1R0hvtnQybT/IyCkGZ3DpXQ==} + engines: {node: '>=0.10.0'} + + find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + + flat-cache@4.0.1: + resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==} + engines: {node: '>=16'} + + flatted@3.4.4: + resolution: {integrity: sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==} + + follow-redirects@1.16.0: + resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + + for-each@0.3.5: + resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==} + engines: {node: '>= 0.4'} + + form-data@4.0.6: + resolution: {integrity: sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==} + engines: {node: '>= 6'} + + fp-ts@2.16.11: + resolution: {integrity: sha512-LaI+KaX2NFkfn1ZGHoKCmcfv7yrZsC3b8NtWsTVQeHkq4F27vI5igUuO53sxqDEa2gNQMHFPmpojDw/1zmUK7w==} + + function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + + function.prototype.name@1.2.0: + resolution: {integrity: sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew==} + engines: {node: '>= 0.4'} + + functions-have-names@1.2.3: + resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + + generator-function@2.0.1: + resolution: {integrity: sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==} + engines: {node: '>= 0.4'} + + get-intrinsic@1.3.0: + resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} + engines: {node: '>= 0.4'} + + get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} + + get-stream@5.2.0: + resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==} + engines: {node: '>=8'} + + get-symbol-description@1.1.0: + resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==} + engines: {node: '>= 0.4'} + + get-tsconfig@4.14.1: + resolution: {integrity: sha512-Dz/6HxkrxgNehhxLVeyv8sad9UzF2xBVeaKBQNDfJ5XiSXmp2gTR0eO0RWiT2NCKS5aGP9jjkOMggTN90qU50A==} + + glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} + + glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} + + globals@14.0.0: + resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==} + engines: {node: '>=18'} + + globalthis@1.0.4: + resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} + engines: {node: '>= 0.4'} + + gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} + + got@11.8.6: + resolution: {integrity: sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==} + engines: {node: '>=10.19.0'} + + graceful-fs@4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + + h3@1.15.11: + resolution: {integrity: sha512-L3THSe2MPeBwgIZVSH5zLdBBU90TOxarvhK9d04IDY2AmVS8j2Jz2LIWtwsGOU3lu2I5jCN7FNvVfY2+XyF+mg==} + + has-bigints@1.1.0: + resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==} + engines: {node: '>= 0.4'} + + has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + + has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} + + has-proto@1.2.0: + resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==} + engines: {node: '>= 0.4'} + + has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} + + has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} + + hasown@2.0.4: + resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==} + engines: {node: '>= 0.4'} + + http-cache-semantics@4.2.0: + resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==} + + http2-wrapper@1.0.3: + resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} + engines: {node: '>=10.19.0'} + + idb-keyval@6.2.1: + resolution: {integrity: sha512-8Sb3veuYCyrZL+VBt9LJfZjLUPWVvqn8tG28VqYNFCo43KHcKuq+b4EiXGeuaLAQWL2YmyDgMp2aSpH9JHsEQg==} + + idb-keyval@6.3.0: + resolution: {integrity: sha512-um+2dgAWmYsu615EXpWVwSmapJhON0G43t3Ka/EVaohzPQXSMqKEqeDK/oIW3Ow+BXaF2PvSc+oBTFp793A5Ow==} + + ieee754@1.2.1: + resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + + ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + + ignore@7.0.6: + resolution: {integrity: sha512-BAg6QkE8W+TuQLrrw0Ugr7HegXduRuuj8/ti2kSOc+jz1dmx8/WNcjr6XGnq5YpDWxFwwaavqD0+jIUOKelTsw==} + engines: {node: '>= 4'} + + import-fresh@3.3.1: + resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} + engines: {node: '>=6'} + + imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + + inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + internal-slot@1.1.0: + resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==} + engines: {node: '>= 0.4'} + + io-ts@2.2.22: + resolution: {integrity: sha512-FHCCztTkHoV9mdBsHpocLpdTAfh956ZQcIkWQxxS0U5HT53vtrcuYdQneEJKH6xILaLNzXVl2Cvwtoy8XNN0AA==} + peerDependencies: + fp-ts: ^2.5.0 + + iron-webcrypto@1.2.1: + resolution: {integrity: sha512-feOM6FaSr6rEABp/eDfVseKyTMDt+KGpeB35SkVn9Tyn0CqvVsY3EwI0v5i8nMHyJnzCIQf7nsy3p41TPkJZhg==} + + is-array-buffer@3.0.5: + resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==} + engines: {node: '>= 0.4'} + + is-async-function@2.1.1: + resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==} + engines: {node: '>= 0.4'} + + is-bigint@1.1.0: + resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==} + engines: {node: '>= 0.4'} + + is-boolean-object@1.2.2: + resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==} + engines: {node: '>= 0.4'} + + is-buffer@1.1.6: + resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} + + is-bun-module@2.0.0: + resolution: {integrity: sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ==} + + is-callable@1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} + engines: {node: '>= 0.4'} + + is-core-module@2.16.2: + resolution: {integrity: sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==} + engines: {node: '>= 0.4'} + + is-data-view@1.0.2: + resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==} + engines: {node: '>= 0.4'} + + is-date-object@1.1.0: + resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==} + engines: {node: '>= 0.4'} + + is-document.all@1.0.0: + resolution: {integrity: sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g==} + engines: {node: '>= 0.4'} + + is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + is-finalizationregistry@1.1.1: + resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==} + engines: {node: '>= 0.4'} + + is-generator-function@1.1.2: + resolution: {integrity: sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==} + engines: {node: '>= 0.4'} + + is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + + is-map@2.0.3: + resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==} + engines: {node: '>= 0.4'} + + is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} + engines: {node: '>= 0.4'} + + is-number-object@1.1.1: + resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==} + engines: {node: '>= 0.4'} + + is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + is-regex@1.2.1: + resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==} + engines: {node: '>= 0.4'} + + is-retry-allowed@2.2.0: + resolution: {integrity: sha512-XVm7LOeLpTW4jV19QSH38vkswxoLud8sQ57YwJVTPWdiaI9I8keEhGFpBlslyVsgdQy4Opg8QOLb8YRgsyZiQg==} + engines: {node: '>=10'} + + is-set@2.0.3: + resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==} + engines: {node: '>= 0.4'} + + is-shared-array-buffer@1.0.4: + resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==} + engines: {node: '>= 0.4'} + + is-string@1.1.1: + resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==} + engines: {node: '>= 0.4'} + + is-symbol@1.1.1: + resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==} + engines: {node: '>= 0.4'} + + is-typed-array@1.1.15: + resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==} + engines: {node: '>= 0.4'} + + is-weakmap@2.0.2: + resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==} + engines: {node: '>= 0.4'} + + is-weakref@1.1.1: + resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==} + engines: {node: '>= 0.4'} + + is-weakset@2.0.4: + resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==} + engines: {node: '>= 0.4'} + + isarray@2.0.5: + resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + + isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + + isows@1.0.7: + resolution: {integrity: sha512-I1fSfDCZL5P0v33sVqeTDSpcstAg/N+wF5HS033mogOVIp4B+oHC7oOCsA3axAbBSGTJ8QubbNmnIRN/h8U7hg==} + peerDependencies: + ws: '*' + + iterator.prototype@1.1.5: + resolution: {integrity: sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==} + engines: {node: '>= 0.4'} + + jiti@2.7.0: + resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==} + hasBin: true + + jose@6.2.8: + resolution: {integrity: sha512-Bsdjwm3Qsd/P0jR+BHDe3LytDfY7WBq2HmCCLIwuVRHMuEC9ae7/R474GIUdF1NgCyZjzVo/A9DOiOBtXq8ZoQ==} + + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + + js-yaml@4.3.1: + resolution: {integrity: sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==} + hasBin: true + + json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + + json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + + json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + + json5@1.0.2: + resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} + hasBin: true + + jsx-ast-utils@3.3.5: + resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==} + engines: {node: '>=4.0'} + + keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + + keyvaluestorage-interface@1.0.0: + resolution: {integrity: sha512-8t6Q3TclQ4uZynJY9IGr2+SsIGwK9JHcO6ootkHCGA0CrQCRy+VkouYNO2xicET6b9al7QKzpebNow+gkpCL8g==} + + language-subtag-registry@0.3.23: + resolution: {integrity: sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==} + + language-tags@1.0.9: + resolution: {integrity: sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==} + engines: {node: '>=0.10'} + + levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} + + lightningcss-android-arm64@1.30.2: + resolution: {integrity: sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==} + engines: {node: '>= 12.0.0'} + cpu: [arm64] + os: [android] + + lightningcss-darwin-arm64@1.30.2: + resolution: {integrity: sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==} + engines: {node: '>= 12.0.0'} + cpu: [arm64] + os: [darwin] + + lightningcss-darwin-x64@1.30.2: + resolution: {integrity: sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==} + engines: {node: '>= 12.0.0'} + cpu: [x64] + os: [darwin] + + lightningcss-freebsd-x64@1.30.2: + resolution: {integrity: sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==} + engines: {node: '>= 12.0.0'} + cpu: [x64] + os: [freebsd] + + lightningcss-linux-arm-gnueabihf@1.30.2: + resolution: {integrity: sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==} + engines: {node: '>= 12.0.0'} + cpu: [arm] + os: [linux] + + lightningcss-linux-arm64-gnu@1.30.2: + resolution: {integrity: sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==} + engines: {node: '>= 12.0.0'} + cpu: [arm64] + os: [linux] + libc: [glibc] + + lightningcss-linux-arm64-musl@1.30.2: + resolution: {integrity: sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==} + engines: {node: '>= 12.0.0'} + cpu: [arm64] + os: [linux] + libc: [musl] + + lightningcss-linux-x64-gnu@1.30.2: + resolution: {integrity: sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==} + engines: {node: '>= 12.0.0'} + cpu: [x64] + os: [linux] + libc: [glibc] + + lightningcss-linux-x64-musl@1.30.2: + resolution: {integrity: sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==} + engines: {node: '>= 12.0.0'} + cpu: [x64] + os: [linux] + libc: [musl] + + lightningcss-win32-arm64-msvc@1.30.2: + resolution: {integrity: sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==} + engines: {node: '>= 12.0.0'} + cpu: [arm64] + os: [win32] + + lightningcss-win32-x64-msvc@1.30.2: + resolution: {integrity: sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==} + engines: {node: '>= 12.0.0'} + cpu: [x64] + os: [win32] + + lightningcss@1.30.2: + resolution: {integrity: sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==} + engines: {node: '>= 12.0.0'} + + locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + + lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + + lodash@4.18.1: + resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==} + + long@5.3.2: + resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==} + + loose-envify@1.4.0: + resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} + hasBin: true + + lowercase-keys@2.0.0: + resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==} + engines: {node: '>=8'} + + lru-cache@11.5.2: + resolution: {integrity: sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==} + engines: {node: 20 || >=22} + + lucide-react@0.542.0: + resolution: {integrity: sha512-w3hD8/SQB7+lzU2r4VdFyzzOzKnUjTZIF/MQJGSSvni7Llewni4vuViRppfRAa2guOsY5k4jZyxw/i9DQHv+dw==} + peerDependencies: + react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0 + + magic-string@0.30.21: + resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + + math-intrinsics@1.1.0: + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} + + md5@2.3.0: + resolution: {integrity: sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==} + + merge2@1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} + + micro-ftch@0.3.1: + resolution: {integrity: sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg==} + + micromatch@4.0.8: + resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} + engines: {node: '>=8.6'} + + mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + + mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + + mimic-response@1.0.1: + resolution: {integrity: sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==} + engines: {node: '>=4'} + + mimic-response@3.1.0: + resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} + engines: {node: '>=10'} + + minimatch@10.2.6: + resolution: {integrity: sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==} + engines: {node: 18 || 20 || >=22} + + minimatch@3.1.5: + resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==} + + minimist@1.2.8: + resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + multiformats@9.9.0: + resolution: {integrity: sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==} + + nanoid@3.3.18: + resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + napi-postinstall@0.3.4: + resolution: {integrity: sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==} + engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0} + hasBin: true + + natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + + next@15.5.9: + resolution: {integrity: sha512-agNLK89seZEtC5zUHwtut0+tNrc0Xw4FT/Dg+B/VLEo9pAcS9rtTKpek3V6kVcVwsB2YlqMaHdfZL4eLEVYuCg==} + engines: {node: ^18.18.0 || ^19.8.0 || >= 20.0.0} + hasBin: true + peerDependencies: + '@opentelemetry/api': ^1.1.0 + '@playwright/test': ^1.51.1 + babel-plugin-react-compiler: '*' + react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0 + react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0 + sass: ^1.3.0 + peerDependenciesMeta: + '@opentelemetry/api': + optional: true + '@playwright/test': + optional: true + babel-plugin-react-compiler: + optional: true + sass: + optional: true + + node-exports-info@1.6.2: + resolution: {integrity: sha512-kXs9Go0cah0qHVV2v389IXQLdLCeE1xfFtjOAF+iobu0OIoG1pje8At2vMHyaPMiPMnG/LWP50twML21eMcAag==} + engines: {node: '>= 0.4'} + + node-fetch-native@1.6.7: + resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==} + + node-fetch@2.7.0: + resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} + engines: {node: 4.x || >=6.0.0} + peerDependencies: + encoding: ^0.1.0 + peerDependenciesMeta: + encoding: + optional: true + + node-mock-http@1.0.5: + resolution: {integrity: sha512-KQyt/wLjG3TAc7DOUhpqWzgd4ERxR80JOlTK5VE5R1S12IaPVN5qkj4klBce9HPG1Njuup4Sb5bljaT34lIyjw==} + + normalize-path@3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} + + normalize-url@6.1.0: + resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==} + engines: {node: '>=10'} + + object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} + + object-inspect@1.13.4: + resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==} + engines: {node: '>= 0.4'} + + object-keys@1.1.1: + resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} + engines: {node: '>= 0.4'} + + object.assign@4.1.7: + resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==} + engines: {node: '>= 0.4'} + + object.entries@1.1.9: + resolution: {integrity: sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==} + engines: {node: '>= 0.4'} + + object.fromentries@2.0.8: + resolution: {integrity: sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==} + engines: {node: '>= 0.4'} + + object.groupby@1.0.3: + resolution: {integrity: sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==} + engines: {node: '>= 0.4'} + + object.values@1.2.1: + resolution: {integrity: sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==} + engines: {node: '>= 0.4'} + + ofetch@1.5.1: + resolution: {integrity: sha512-2W4oUZlVaqAPAil6FUg/difl6YhqhUR7x2eZY4bQCko22UXg3hptq9KLQdqFClV+Wu85UX7hNtdGTngi/1BxcA==} + + on-exit-leak-free@0.2.0: + resolution: {integrity: sha512-dqaz3u44QbRXQooZLTUKU41ZrzYrcvLISVgbrzbyCMxpmSLJvZ3ZamIJIZ29P6OhZIkNIQKosdeM6t1LYbA9hg==} + + once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + + openapi-fetch@0.13.8: + resolution: {integrity: sha512-yJ4QKRyNxE44baQ9mY5+r/kAzZ8yXMemtNAOFwOzRXJscdjSxxzWSNlyBAr+o5JjkUw9Lc3W7OIoca0cY3PYnQ==} + + openapi-typescript-helpers@0.0.15: + resolution: {integrity: sha512-opyTPaunsklCBpTK8JGef6mfPhLSnyy5a0IN9vKtx3+4aExf+KxEqYwIy3hqkedXIB97u357uLMJsOnm3GVjsw==} + + optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} + + own-keys@1.0.2: + resolution: {integrity: sha512-19YVAg7T+WTrxggPukVq7DjTv6+PJ867TmhCvBsYwmbFCsZd344rq2Ld1p0wo8f8Qrrhgp82c6FJRqdXWtSEhg==} + engines: {node: '>= 0.4'} + + ox@0.14.33: + resolution: {integrity: sha512-rooA/4o7bBof4Ge2VH/eovfNPb/AEEYyrNj03wggc55g5HZD8Pjs/OeWhttgjic3dDcqn0r29bDuvQEdTiUemQ==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + + ox@0.6.9: + resolution: {integrity: sha512-wi5ShvzE4eOcTwQVsIPdFr+8ycyX+5le/96iAJutaZAvCes1J0+RvpEPg5QDPDiaR0XQQAvZVl7AwqQcINuUug==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + + ox@0.7.1: + resolution: {integrity: sha512-+k9fY9PRNuAMHRFIUbiK9Nt5seYHHzSQs9Bj+iMETcGtlpS7SmBzcGSVUQO3+nqGLEiNK4598pHNFlVRaZbRsg==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + + ox@0.9.6: + resolution: {integrity: sha512-8SuCbHPvv2eZLYXrNmC0EC12rdzXQLdhnOMlHDW2wiCPLxBrOOJwX5L5E61by+UjTPOryqQiRSnjIKCI+GykKg==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + + p-cancelable@2.1.1: + resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==} + engines: {node: '>=8'} + + p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} + + p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + + pako@2.2.0: + resolution: {integrity: sha512-zJq6RP/5q+TO2OpFV3FHzlPnFjmkb7Nc99a5SNjJE+uu/PkpChs+NIZSSzbBoD+6kjiISXjfYdwj1ZRQ81dz/w==} + + parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + + path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} + + path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + + path-parse@1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + + picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + + picomatch@2.3.2: + resolution: {integrity: sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==} + engines: {node: '>=8.6'} + + picomatch@4.0.5: + resolution: {integrity: sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==} + engines: {node: '>=12'} + + pino-abstract-transport@0.5.0: + resolution: {integrity: sha512-+KAgmVeqXYbTtU2FScx1XS3kNyfZ5TrXY07V96QnUSFqo2gAqlvmaxH67Lj7SWazqsMabf+58ctdTcBgnOLUOQ==} + + pino-std-serializers@4.0.0: + resolution: {integrity: sha512-cK0pekc1Kjy5w9V2/n+8MkZwusa6EyyxfeQCB799CQRhRt/CqYKiWs5adeu8Shve2ZNffvfC/7J64A2PJo1W/Q==} + + pino@7.11.0: + resolution: {integrity: sha512-dMACeu63HtRLmCG8VKdy4cShCPKaYDR4youZqoSWLxl5Gu99HUw8bw75thbPv9Nip+H+QYX8o3ZJbTdVZZ2TVg==} + hasBin: true + + pony-cause@2.1.11: + resolution: {integrity: sha512-M7LhCsdNbNgiLYiP4WjsfLUuFmCfnjdF6jKe2R9NKl4WFN+HZPGHJZ9lnLP7f9ZnKe3U9nuWD0szirmj+migUg==} + engines: {node: '>=12.0.0'} + + possible-typed-array-names@1.1.0: + resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==} + engines: {node: '>= 0.4'} + + postcss@8.4.31: + resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==} + engines: {node: ^10 || ^12 || >=14} + + postcss@8.5.6: + resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==} + engines: {node: ^10 || ^12 || >=14} + + preact@10.24.2: + resolution: {integrity: sha512-1cSoF0aCC8uaARATfrlz4VCBqE8LwZwRfLgkxJOQwAlQt6ayTmi0D9OF7nXid1POI5SZidFuG9CnlXbDfLqY/Q==} + + prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} + + process-warning@1.0.0: + resolution: {integrity: sha512-du4wfLyj4yCZq1VupnVSZmRsPJsNuxoDQFdCFHLaYiEbFBD7QE0a+I4D7hOxrVnh78QE/YipFAj9lXHiXocV+Q==} + + prop-types@15.8.1: + resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==} + + protobufjs@7.6.5: + resolution: {integrity: sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw==} + engines: {node: '>=12.0.0'} + + proxy-from-env@2.1.0: + resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==} + engines: {node: '>=10'} + + pump@3.0.4: + resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==} + + punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + + qr-code-styling@1.9.2: + resolution: {integrity: sha512-RgJaZJ1/RrXJ6N0j7a+pdw3zMBmzZU4VN2dtAZf8ZggCfRB5stEQ3IoDNGaNhYY3nnZKYlYSLl5YkfWN5dPutg==} + engines: {node: '>=18.18.0'} + + qrcode-generator@1.5.2: + resolution: {integrity: sha512-pItrW0Z9HnDBnFmgiNrY1uxRdri32Uh9EjNYLPVC2zZ3ZRIIEqBoDgm4DkvDwNNDHTK7FNkmr8zAa77BYc9xNw==} + + query-string@7.1.3: + resolution: {integrity: sha512-hh2WYhq4fi8+b+/2Kg9CEge4fDPvHS534aOOvOZeQ3+Vf2mCFsaFBYj0i+iXcAq6I9Vzp5fjMFBlONvayDC1qg==} + engines: {node: '>=6'} + + queue-microtask@1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + + quick-format-unescaped@4.0.4: + resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==} + + quick-lru@5.1.1: + resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} + engines: {node: '>=10'} + + radix3@1.1.2: + resolution: {integrity: sha512-b484I/7b8rDEdSDKckSSBA8knMpcdsXudlE/LNL639wFoHKwLbEkQFZHWEYwDC0wa0FKUcCY+GAF73Z7wxNVFA==} + + react-dom@19.1.2: + resolution: {integrity: sha512-dEoydsCp50i7kS1xHOmPXq4zQYoGWedUsvqv9H6zdif2r7yLHygyfP9qou71TulRN0d6ng9EbRVsQhSqfUc19g==} + peerDependencies: + react: ^19.1.2 + + react-is@16.13.1: + resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==} + + react@19.1.2: + resolution: {integrity: sha512-MdWVitvLbQULD+4DP8GYjZUrepGW7d+GQkNVqJEzNxE+e9WIa4egVFE/RDfVb1u9u/Jw7dNMmPB4IqxzbFYJ0w==} + engines: {node: '>=0.10.0'} + + readable-stream@3.6.2: + resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} + engines: {node: '>= 6'} + + readdirp@5.1.1: + resolution: {integrity: sha512-Kko+Y5XQ6fM+Ce3dq3m9YGxnacYZYl9cA1wZjaF3Vbry2L3i1qVg8+CAgNPsXRArPMUMCaOR7oa9Nqntc43JKA==} + engines: {node: '>= 20.19.0'} + + real-require@0.1.0: + resolution: {integrity: sha512-r/H9MzAWtrv8aSVjPCMFpDMl5q66GqtmmRkRjpHTsp4zBAa+snZyiQNlMONiUmEJcsnaw0wCauJ2GWODr/aFkg==} + engines: {node: '>= 12.13.0'} + + reflect.getprototypeof@1.0.10: + resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==} + engines: {node: '>= 0.4'} + + regexp.prototype.flags@1.5.4: + resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==} + engines: {node: '>= 0.4'} + + resolve-alpn@1.2.1: + resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} + + resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + + resolve-pkg-maps@1.0.0: + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + + resolve@2.0.0-next.7: + resolution: {integrity: sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ==} + engines: {node: '>= 0.4'} + hasBin: true + + responselike@2.0.1: + resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==} + + reusify@1.1.0: + resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + + run-parallel@1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + + safe-array-concat@1.1.4: + resolution: {integrity: sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==} + engines: {node: '>=0.4'} + + safe-buffer@5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + + safe-push-apply@1.0.0: + resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==} + engines: {node: '>= 0.4'} + + safe-regex-test@1.1.0: + resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==} + engines: {node: '>= 0.4'} + + safe-stable-stringify@2.5.0: + resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==} + engines: {node: '>=10'} + + scheduler@0.26.0: + resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==} + + semver@6.3.1: + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + hasBin: true + + semver@7.8.5: + resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==} + engines: {node: '>=10'} + hasBin: true + + set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} + + set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} + + set-proto@1.0.0: + resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==} + engines: {node: '>= 0.4'} + + sharp@0.34.5: + resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} + engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + + shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + + shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + + side-channel-list@1.0.1: + resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==} + engines: {node: '>= 0.4'} + + side-channel-map@1.0.1: + resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} + engines: {node: '>= 0.4'} + + side-channel-weakmap@1.0.2: + resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} + engines: {node: '>= 0.4'} + + side-channel@1.1.1: + resolution: {integrity: sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==} + engines: {node: '>= 0.4'} + + sonic-boom@2.8.0: + resolution: {integrity: sha512-kuonw1YOYYNOve5iHdSahXPOK49GqwA+LZhI6Wz/l0rP57iKyXXIHaRagOBHAPmGwJC6od2Z9zgvZ5loSgMlVg==} + + source-map-js@1.2.1: + resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} + engines: {node: '>=0.10.0'} + + split-on-first@1.1.0: + resolution: {integrity: sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==} + engines: {node: '>=6'} + + split2@4.2.0: + resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} + engines: {node: '>= 10.x'} + + stable-hash@0.0.5: + resolution: {integrity: sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==} + + stop-iteration-iterator@1.1.0: + resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==} + engines: {node: '>= 0.4'} + + stream-shift@1.0.3: + resolution: {integrity: sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==} + + strict-uri-encode@2.0.0: + resolution: {integrity: sha512-QwiXZgpRcKkhTj2Scnn++4PKtWsH0kpzZ62L2R6c/LUVYv7hVnZqcg2+sMuT6R7Jusu1vviK/MFsu6kNJfWlEQ==} + engines: {node: '>=4'} + + string.prototype.includes@2.0.1: + resolution: {integrity: sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==} + engines: {node: '>= 0.4'} + + string.prototype.matchall@4.0.12: + resolution: {integrity: sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==} + engines: {node: '>= 0.4'} + + string.prototype.repeat@1.0.0: + resolution: {integrity: sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==} + + string.prototype.trim@1.2.11: + resolution: {integrity: sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w==} + engines: {node: '>= 0.4'} + + string.prototype.trimend@1.0.10: + resolution: {integrity: sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw==} + engines: {node: '>= 0.4'} + + string.prototype.trimstart@1.0.8: + resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} + engines: {node: '>= 0.4'} + + string_decoder@1.3.0: + resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + + strip-bom@3.0.0: + resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} + engines: {node: '>=4'} + + strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} + + styled-jsx@5.1.6: + resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==} + engines: {node: '>= 12.0.0'} + peerDependencies: + '@babel/core': '*' + babel-plugin-macros: '*' + react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0' + peerDependenciesMeta: + '@babel/core': + optional: true + babel-plugin-macros: + optional: true + + supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + + supports-preserve-symlinks-flag@1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} + + tailwind-merge@3.4.0: + resolution: {integrity: sha512-uSaO4gnW+b3Y2aWoWfFpX62vn2sR3skfhbjsEnaBI81WD1wBLlHZe5sWf0AqjksNdYTbGBEd0UasQMT3SNV15g==} + + tailwindcss@4.1.18: + resolution: {integrity: sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==} + + tapable@2.3.3: + resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==} + engines: {node: '>=6'} + + thread-stream@0.15.2: + resolution: {integrity: sha512-UkEhKIg2pD+fjkHQKyJO3yoIvAP3N6RlNFt2dUhcS1FGvCD1cQa1M/PGknCLFIyZdtJOWQjejp7bdNqmN7zwdA==} + + tinyglobby@0.2.17: + resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==} + engines: {node: '>=12.0.0'} + + tldts-core@6.1.86: + resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==} + + tldts@6.0.16: + resolution: {integrity: sha512-TkEq38COU640mzOKPk4D1oH3FFVvwEtMaKIfw/+F/umVsy7ONWu8PPQH0c11qJ/Jq/zbcQGprXGsT8GcaDSmJg==} + hasBin: true + + to-regex-range@5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} + + to-utf8@0.0.1: + resolution: {integrity: sha512-zks18/TWT1iHO3v0vFp5qLKOG27m67ycq/Y7a7cTiRuUNlc4gf3HGnkRgMv0NyhnfTamtkYBJl+YeD1/j07gBQ==} + + tr46@0.0.3: + resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + + ts-api-utils@2.5.0: + resolution: {integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==} + engines: {node: '>=18.12'} + peerDependencies: + typescript: '>=4.8.4' + + tsconfig-paths@3.15.0: + resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} + + tslib@1.14.1: + resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} + + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + + type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} + + typed-array-buffer@1.0.3: + resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==} + engines: {node: '>= 0.4'} + + typed-array-byte-length@1.0.3: + resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==} + engines: {node: '>= 0.4'} + + typed-array-byte-offset@1.0.4: + resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==} + engines: {node: '>= 0.4'} + + typed-array-length@1.0.8: + resolution: {integrity: sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==} + engines: {node: '>= 0.4'} + + typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + ufo@1.6.4: + resolution: {integrity: sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==} + + uint8arrays@3.1.1: + resolution: {integrity: sha512-+QJa8QRnbdXVpHYjLoTpJIdCTiw9Ir62nocClWuXIq2JIh4Uta0cQsTSpFL678p2CN8B+XSApwcU+pQEqVpKWg==} + + ulid@2.4.0: + resolution: {integrity: sha512-fIRiVTJNcSRmXKPZtGzFQv9WRrZ3M9eoptl/teFJvjOzmpU+/K/JH6HZ8deBfb5vMEpicJcLn7JmvdknlMq7Zg==} + hasBin: true + + unbox-primitive@1.1.0: + resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==} + engines: {node: '>= 0.4'} + + uncrypto@0.1.3: + resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==} + + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + + undici-types@7.29.0: + resolution: {integrity: sha512-vamA8dGlzMwhpyYpQp9d8vka3o4D/yn5I7ez7Or+msDA4bZ8Uh+Zy91WvWf3I73gDAkFha9JcYRqm2li0Npfgg==} + + unrs-resolver@1.12.2: + resolution: {integrity: sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==} + + unstorage@1.17.5: + resolution: {integrity: sha512-0i3iqvRfx29hkNntHyQvJTpf5W9dQ9ZadSoRU8+xVlhVtT7jAX57fazYO9EHvcRCfBCyi5YRya7XCDOsbTgkPg==} + peerDependencies: + '@azure/app-configuration': ^1.8.0 + '@azure/cosmos': ^4.2.0 + '@azure/data-tables': ^13.3.0 + '@azure/identity': ^4.6.0 + '@azure/keyvault-secrets': ^4.9.0 + '@azure/storage-blob': ^12.26.0 + '@capacitor/preferences': ^6 || ^7 || ^8 + '@deno/kv': '>=0.9.0' + '@netlify/blobs': ^6.5.0 || ^7.0.0 || ^8.1.0 || ^9.0.0 || ^10.0.0 + '@planetscale/database': ^1.19.0 + '@upstash/redis': ^1.34.3 + '@vercel/blob': '>=0.27.1' + '@vercel/functions': ^2.2.12 || ^3.0.0 + '@vercel/kv': ^1 || ^2 || ^3 + aws4fetch: ^1.0.20 + db0: '>=0.2.1' + idb-keyval: ^6.2.1 + ioredis: ^5.4.2 + uploadthing: ^7.4.4 + peerDependenciesMeta: + '@azure/app-configuration': + optional: true + '@azure/cosmos': + optional: true + '@azure/data-tables': + optional: true + '@azure/identity': + optional: true + '@azure/keyvault-secrets': + optional: true + '@azure/storage-blob': + optional: true + '@capacitor/preferences': + optional: true + '@deno/kv': + optional: true + '@netlify/blobs': + optional: true + '@planetscale/database': + optional: true + '@upstash/redis': + optional: true + '@vercel/blob': + optional: true + '@vercel/functions': + optional: true + '@vercel/kv': + optional: true + aws4fetch: + optional: true + db0: + optional: true + idb-keyval: + optional: true + ioredis: + optional: true + uploadthing: + optional: true + + uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + + util-deprecate@1.0.2: + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + + uuid@11.1.0: + resolution: {integrity: sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==} + hasBin: true + + uuid@11.1.1: + resolution: {integrity: sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ==} + hasBin: true + + uuid@9.0.1: + resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} + deprecated: uuid@10 and below is no longer supported. For ESM codebases, update to uuid@latest. For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028). + hasBin: true + + viem@2.31.0: + resolution: {integrity: sha512-U7OMQ6yqK+bRbEIarf2vqxL7unSEQvNxvML/1zG7suAmKuJmipqdVTVJGKBCJiYsm/EremyO2FS4dHIPpGv+eA==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true + + viem@2.42.1: + resolution: {integrity: sha512-NzT/f54jT+b0Um6pYzN/uAGMLg+3twhricAzXS+XH8pVIREzPEh7P25rlhPQnLYiPWzQd9mrFcvnm73Sc8bx+A==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true + + viem@2.55.11: + resolution: {integrity: sha512-RR5MwtdUnFfqw6ZGoFptizywyLOkLuhTL7UafoP3Irf2upXpANakQkLgGqY4H7A7+8JBxjUs6lElGF5zuGjMEw==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true + + webidl-conversions@3.0.1: + resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + + whatwg-url@5.0.0: + resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + + which-boxed-primitive@1.1.1: + resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==} + engines: {node: '>= 0.4'} + + which-builtin-type@1.2.1: + resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==} + engines: {node: '>= 0.4'} + + which-collection@1.0.2: + resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==} + engines: {node: '>= 0.4'} + + which-typed-array@1.1.22: + resolution: {integrity: sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==} + engines: {node: '>= 0.4'} + + which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + + word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} + + wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + + ws@7.5.13: + resolution: {integrity: sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.18.2: + resolution: {integrity: sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.18.3: + resolution: {integrity: sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.21.0: + resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.21.3: + resolution: {integrity: sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} + + zod@3.25.76: + resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==} + + zod@4.0.5: + resolution: {integrity: sha512-/5UuuRPStvHXu7RS+gmvRf4NXrNxpSllGwDnCBcJZtQsKrviYXm54yDGV2KYNLT5kq0lHGcl7lqWJLgSaG+tgA==} + + zustand@5.0.3: + resolution: {integrity: sha512-14fwWQtU3pH4dE0dOpdMiWjddcH+QzKIgk1cl8epwSE7yag43k/AD/m4L6+K7DytAOr9gGBe3/EXj9g7cdostg==} + engines: {node: '>=12.20.0'} + peerDependencies: + '@types/react': '>=18.0.0' + immer: '>=9.0.6' + react: '>=18.0.0' + use-sync-external-store: '>=1.2.0' + peerDependenciesMeta: + '@types/react': + optional: true + immer: + optional: true + react: + optional: true + use-sync-external-store: + optional: true + +snapshots: + + '@ably/msgpack-js@0.4.1': + dependencies: + bops: 1.0.1 + + '@adraffy/ens-normalize@1.11.1': {} + + '@alloc/quick-lru@5.2.0': {} + + '@base-org/account@2.5.2(@types/react@19.1.12)(fastestsmallesttextencoderdecoder@1.0.22)(react@19.1.2)(typescript@5.9.3)(zod@3.25.76)': + dependencies: + '@coinbase/cdp-sdk': 1.55.0(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + brotli-wasm: 3.0.1 + clsx: 1.2.1 + eventemitter3: 5.0.1 + idb-keyval: 6.2.1 + ox: 0.6.9(typescript@5.9.3)(zod@3.25.76) + preact: 10.24.2 + viem: 2.42.1(typescript@5.9.3)(zod@3.25.76) + zustand: 5.0.3(@types/react@19.1.12)(react@19.1.2) + transitivePeerDependencies: + - '@types/react' + - '@x402/core' + - '@x402/evm' + - '@x402/extensions' + - '@x402/svm' + - bufferutil + - debug + - fastestsmallesttextencoderdecoder + - immer + - react + - typescript + - use-sync-external-store + - utf-8-validate + - zod + + '@coinbase/cdp-sdk@1.55.0(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana-program/system': 0.10.0(@solana/kit@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)) + '@solana-program/token': 0.9.0(@solana/kit@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)) + '@solana/kit': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + abitype: 1.0.6(typescript@5.9.3)(zod@3.25.76) + axios: 1.16.0 + axios-retry: 4.5.0(axios@1.16.0) + bs58: 6.0.0 + jose: 6.2.8 + md5: 2.3.0 + uncrypto: 0.1.3 + viem: 2.55.11(typescript@5.9.3)(zod@3.25.76) + zod: 3.25.76 + transitivePeerDependencies: + - bufferutil + - debug + - fastestsmallesttextencoderdecoder + - typescript + - utf-8-validate + + '@dynamic-labs-sdk/assert-package-version@1.26.0': {} + + '@dynamic-labs-sdk/client@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)': + dependencies: + '@dynamic-labs-sdk/assert-package-version': 1.26.0 + '@dynamic-labs-wallet/browser-wallet-client': 1.0.79(@dynamic-labs-wallet/forward-mpc-client@1.0.1(@dynamic-labs-wallet/primitives@1.0.79)) + '@dynamic-labs-wallet/forward-mpc-client': 1.0.1(@dynamic-labs-wallet/primitives@1.0.79) + '@dynamic-labs/sdk-api-core': 0.0.1122 + '@simplewebauthn/browser': 13.1.0 + ably: 2.17.1(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + buffer: 6.0.3 + eventemitter3: 5.0.1 + zod: 4.0.5 + transitivePeerDependencies: + - '@dynamic-labs-wallet/primitives' + - bufferutil + - debug + - react + - react-dom + - utf-8-validate + + '@dynamic-labs-sdk/evm@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(@types/react@19.1.12)(aws4fetch@1.0.20)(fastestsmallesttextencoderdecoder@1.0.22)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)(typescript@5.9.3)(viem@2.42.1(typescript@5.9.3)(zod@3.25.76))(zod@3.25.76)': + dependencies: + '@base-org/account': 2.5.2(@types/react@19.1.12)(fastestsmallesttextencoderdecoder@1.0.22)(react@19.1.2)(typescript@5.9.3)(zod@3.25.76) + '@dynamic-labs-sdk/assert-package-version': 1.26.0 + '@dynamic-labs-sdk/client': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@dynamic-labs-sdk/metamask': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@dynamic-labs-sdk/wallet-connect': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(aws4fetch@1.0.20)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)(typescript@5.9.3) + '@dynamic-labs/sdk-api-core': 0.0.1122 + '@metamask/connect-evm': 1.3.0 + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/utils': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@3.25.76) + viem: 2.42.1(typescript@5.9.3)(zod@3.25.76) + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@dynamic-labs-wallet/primitives' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@types/react' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - '@x402/core' + - '@x402/evm' + - '@x402/extensions' + - '@x402/svm' + - aws4fetch + - bufferutil + - db0 + - debug + - encoding + - fastestsmallesttextencoderdecoder + - immer + - ioredis + - react + - react-dom + - react-native + - react-native-inappbrowser-reborn + - react-native-keychain + - react-native-passkey + - supports-color + - typescript + - uploadthing + - use-sync-external-store + - utf-8-validate + - zod + + '@dynamic-labs-sdk/metamask@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)': + dependencies: + '@dynamic-labs-sdk/assert-package-version': 1.26.0 + '@dynamic-labs-sdk/client': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@dynamic-labs/sdk-api-core': 0.0.1122 + transitivePeerDependencies: + - '@dynamic-labs-wallet/primitives' + - '@react-native-async-storage/async-storage' + - bufferutil + - debug + - react + - react-dom + - react-native + - react-native-inappbrowser-reborn + - react-native-keychain + - react-native-passkey + - utf-8-validate + + '@dynamic-labs-sdk/react-hooks@1.26.0(@dynamic-labs-sdk/client@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2))(@tanstack/react-query@5.90.12(react@19.1.2))(react@19.1.2)': + dependencies: + '@dynamic-labs-sdk/assert-package-version': 1.26.0 + '@dynamic-labs-sdk/client': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@tanstack/react-query': 5.90.12(react@19.1.2) + react: 19.1.2 + + '@dynamic-labs-sdk/wallet-connect@1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(aws4fetch@1.0.20)(react-dom@19.1.2(react@19.1.2))(react@19.1.2)(typescript@5.9.3)': + dependencies: + '@dynamic-labs-sdk/assert-package-version': 1.26.0 + '@dynamic-labs-sdk/client': 1.26.0(@dynamic-labs-wallet/primitives@1.0.79)(react-dom@19.1.2(react@19.1.2))(react@19.1.2) + '@dynamic-labs/sdk-api-core': 0.0.1122 + '@walletconnect/sign-client': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5) + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/utils': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5) + zod: 4.0.5 + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@dynamic-labs-wallet/primitives' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - bufferutil + - db0 + - debug + - ioredis + - react + - react-dom + - react-native + - react-native-inappbrowser-reborn + - react-native-keychain + - react-native-passkey + - typescript + - uploadthing + - utf-8-validate + + '@dynamic-labs-wallet/browser-wallet-client@1.0.79(@dynamic-labs-wallet/forward-mpc-client@1.0.1(@dynamic-labs-wallet/primitives@1.0.79))': + dependencies: + '@dynamic-labs-wallet/core': 1.0.79(@dynamic-labs-wallet/forward-mpc-client@1.0.1(@dynamic-labs-wallet/primitives@1.0.79)) + '@dynamic-labs/logger': 4.96.0 + '@dynamic-labs/message-transport': 4.96.0 + transitivePeerDependencies: + - '@dynamic-labs-wallet/forward-mpc-client' + - debug + + '@dynamic-labs-wallet/core@1.0.79(@dynamic-labs-wallet/forward-mpc-client@1.0.1(@dynamic-labs-wallet/primitives@1.0.79))': + dependencies: + '@dynamic-labs-wallet/forward-mpc-client': 1.0.1(@dynamic-labs-wallet/primitives@1.0.79) + '@dynamic-labs-wallet/primitives': 1.0.79 + '@dynamic-labs/sdk-api-core': 0.0.1083 + axios: 1.16.0 + uuid: 11.1.0 + transitivePeerDependencies: + - debug + + '@dynamic-labs-wallet/forward-mpc-client@1.0.1(@dynamic-labs-wallet/primitives@1.0.79)': + dependencies: + '@dynamic-labs-wallet/forward-mpc-shared': 0.7.1(@dynamic-labs-wallet/primitives@1.0.79) + '@dynamic-labs-wallet/primitives': 1.0.79 + '@evervault/wasm-attestation-bindings': 0.3.1 + '@noble/hashes': 2.3.0 + eventemitter3: 5.0.1 + fp-ts: 2.16.11 + isows: 1.0.7(ws@8.21.3) + ws: 8.21.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + + '@dynamic-labs-wallet/forward-mpc-shared@0.7.1(@dynamic-labs-wallet/primitives@1.0.79)': + dependencies: + '@dynamic-labs-wallet/primitives': 1.0.79 + '@noble/ciphers': 0.4.1 + '@noble/hashes': 2.3.0 + '@noble/post-quantum': 0.5.4 + fp-ts: 2.16.11 + io-ts: 2.2.22(fp-ts@2.16.11) + + '@dynamic-labs-wallet/primitives@1.0.79': {} + + '@dynamic-labs/assert-package-version@4.96.0': + dependencies: + '@dynamic-labs/logger': 4.96.0 + + '@dynamic-labs/logger@4.96.0': + dependencies: + eventemitter3: 5.0.1 + + '@dynamic-labs/message-transport@4.96.0': + dependencies: + '@dynamic-labs/assert-package-version': 4.96.0 + '@dynamic-labs/logger': 4.96.0 + '@dynamic-labs/utils': 4.96.0 + '@vue/reactivity': 3.5.41 + eventemitter3: 5.0.1 + + '@dynamic-labs/sdk-api-core@0.0.1083': {} + + '@dynamic-labs/sdk-api-core@0.0.1093': {} + + '@dynamic-labs/sdk-api-core@0.0.1122': {} + + '@dynamic-labs/types@4.96.0': + dependencies: + '@dynamic-labs/assert-package-version': 4.96.0 + '@dynamic-labs/sdk-api-core': 0.0.1093 + + '@dynamic-labs/utils@4.96.0': + dependencies: + '@dynamic-labs/assert-package-version': 4.96.0 + '@dynamic-labs/logger': 4.96.0 + '@dynamic-labs/sdk-api-core': 0.0.1093 + '@dynamic-labs/types': 4.96.0 + buffer: 6.0.3 + eventemitter3: 5.0.1 + tldts: 6.0.16 + + '@ecies/ciphers@0.2.6(@noble/ciphers@1.3.0)': + dependencies: + '@noble/ciphers': 1.3.0 + + '@emnapi/core@1.10.0': + dependencies: + '@emnapi/wasi-threads': 1.2.1 + tslib: 2.8.1 + optional: true + + '@emnapi/runtime@1.10.0': + dependencies: + tslib: 2.8.1 + optional: true + + '@emnapi/runtime@1.11.3': + dependencies: + tslib: 2.8.1 + optional: true + + '@emnapi/wasi-threads@1.2.1': + dependencies: + tslib: 2.8.1 + optional: true + + '@eslint-community/eslint-utils@4.10.1(eslint@9.39.2(jiti@2.7.0))': + dependencies: + eslint: 9.39.2(jiti@2.7.0) + eslint-visitor-keys: 3.4.3 + + '@eslint-community/regexpp@4.12.2': {} + + '@eslint/config-array@0.21.2': + dependencies: + '@eslint/object-schema': 2.1.7 + debug: 4.4.3 + minimatch: 3.1.5 + transitivePeerDependencies: + - supports-color + + '@eslint/config-helpers@0.4.2': + dependencies: + '@eslint/core': 0.17.0 + + '@eslint/core@0.17.0': + dependencies: + '@types/json-schema': 7.0.15 + + '@eslint/eslintrc@3.3.1': + dependencies: + ajv: 6.15.0 + debug: 4.4.3 + espree: 10.4.0 + globals: 14.0.0 + ignore: 5.3.2 + import-fresh: 3.3.1 + js-yaml: 4.3.1 + minimatch: 3.1.5 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color + + '@eslint/js@9.39.2': {} + + '@eslint/object-schema@2.1.7': {} + + '@eslint/plugin-kit@0.4.1': + dependencies: + '@eslint/core': 0.17.0 + levn: 0.4.1 + + '@ethereumjs/common@3.2.0': + dependencies: + '@ethereumjs/util': 8.1.0 + crc-32: 1.2.2 + + '@ethereumjs/rlp@4.0.1': {} + + '@ethereumjs/tx@4.2.0': + dependencies: + '@ethereumjs/common': 3.2.0 + '@ethereumjs/rlp': 4.0.1 + '@ethereumjs/util': 8.1.0 + ethereum-cryptography: 2.2.1 + + '@ethereumjs/util@8.1.0': + dependencies: + '@ethereumjs/rlp': 4.0.1 + ethereum-cryptography: 2.2.1 + micro-ftch: 0.3.1 + + '@evervault/wasm-attestation-bindings@0.3.1': {} + + '@humanfs/core@0.19.2': + dependencies: + '@humanfs/types': 0.15.0 + + '@humanfs/node@0.16.8': + dependencies: + '@humanfs/core': 0.19.2 + '@humanfs/types': 0.15.0 + '@humanwhocodes/retry': 0.4.3 + + '@humanfs/types@0.15.0': {} + + '@humanwhocodes/module-importer@1.0.1': {} + + '@humanwhocodes/retry@0.4.3': {} + + '@img/colour@1.1.0': + optional: true + + '@img/sharp-darwin-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-arm64': 1.2.4 + optional: true + + '@img/sharp-darwin-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-darwin-x64': 1.2.4 + optional: true + + '@img/sharp-libvips-darwin-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-darwin-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-arm@1.2.4': + optional: true + + '@img/sharp-libvips-linux-ppc64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-riscv64@1.2.4': + optional: true + + '@img/sharp-libvips-linux-s390x@1.2.4': + optional: true + + '@img/sharp-libvips-linux-x64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-arm64@1.2.4': + optional: true + + '@img/sharp-libvips-linuxmusl-x64@1.2.4': + optional: true + + '@img/sharp-linux-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm64': 1.2.4 + optional: true + + '@img/sharp-linux-arm@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-arm': 1.2.4 + optional: true + + '@img/sharp-linux-ppc64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-ppc64': 1.2.4 + optional: true + + '@img/sharp-linux-riscv64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-riscv64': 1.2.4 + optional: true + + '@img/sharp-linux-s390x@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-s390x': 1.2.4 + optional: true + + '@img/sharp-linux-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linux-x64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-arm64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + optional: true + + '@img/sharp-linuxmusl-x64@0.34.5': + optionalDependencies: + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + optional: true + + '@img/sharp-wasm32@0.34.5': + dependencies: + '@emnapi/runtime': 1.11.3 + optional: true + + '@img/sharp-win32-arm64@0.34.5': + optional: true + + '@img/sharp-win32-ia32@0.34.5': + optional: true + + '@img/sharp-win32-x64@0.34.5': + optional: true + + '@jridgewell/gen-mapping@0.3.13': + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + '@jridgewell/trace-mapping': 0.3.31 + + '@jridgewell/remapping@2.3.5': + dependencies: + '@jridgewell/gen-mapping': 0.3.13 + '@jridgewell/trace-mapping': 0.3.31 + + '@jridgewell/resolve-uri@3.1.2': {} + + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@jridgewell/trace-mapping@0.3.31': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.5 + + '@metamask/analytics@0.5.0': + dependencies: + openapi-fetch: 0.13.8 + + '@metamask/connect-evm@1.3.0': + dependencies: + '@metamask/analytics': 0.5.0 + '@metamask/connect-multichain': 0.14.0 + '@metamask/utils': 11.11.0 + transitivePeerDependencies: + - '@react-native-async-storage/async-storage' + - bufferutil + - encoding + - supports-color + - utf-8-validate + + '@metamask/connect-multichain@0.14.0': + dependencies: + '@metamask/analytics': 0.5.0 + '@metamask/mobile-wallet-protocol-core': 0.4.0 + '@metamask/mobile-wallet-protocol-dapp-client': 0.3.0 + '@metamask/multichain-api-client': 0.10.1 + '@metamask/multichain-ui': 0.4.1 + '@metamask/onboarding': 1.0.1 + '@metamask/rpc-errors': 7.0.3 + '@metamask/utils': 11.11.0 + '@paulmillr/qr': 0.2.1 + bowser: 2.14.1 + buffer: 6.0.3 + cross-fetch: 4.1.0 + eciesjs: 0.4.17 + eventemitter3: 5.0.4 + pako: 2.2.0 + uuid: 11.1.1 + ws: 8.21.3 + transitivePeerDependencies: + - bufferutil + - encoding + - supports-color + - utf-8-validate + + '@metamask/mobile-wallet-protocol-core@0.4.0': + dependencies: + async-mutex: 0.5.0 + centrifuge: 5.7.0 + eventemitter3: 5.0.4 + uuid: 11.1.1 + + '@metamask/mobile-wallet-protocol-dapp-client@0.3.0': + dependencies: + '@metamask/mobile-wallet-protocol-core': 0.4.0 + '@metamask/utils': 9.3.0 + uuid: 11.1.1 + transitivePeerDependencies: + - supports-color + + '@metamask/multichain-api-client@0.10.1': {} + + '@metamask/multichain-ui@0.4.1': + dependencies: + '@paulmillr/qr': 0.2.1 + qr-code-styling: 1.9.2 + + '@metamask/onboarding@1.0.1': + dependencies: + bowser: 2.14.1 + + '@metamask/rpc-errors@7.0.3': + dependencies: + '@metamask/utils': 11.11.0 + fast-safe-stringify: 2.1.1 + transitivePeerDependencies: + - supports-color + + '@metamask/superstruct@3.4.1': {} + + '@metamask/utils@11.11.0': + dependencies: + '@ethereumjs/tx': 4.2.0 + '@metamask/superstruct': 3.4.1 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + '@types/debug': 4.1.13 + '@types/lodash': 4.17.25 + debug: 4.4.3 + lodash: 4.18.1 + pony-cause: 2.1.11 + semver: 7.8.5 + uuid: 9.0.1 + transitivePeerDependencies: + - supports-color + + '@metamask/utils@9.3.0': + dependencies: + '@ethereumjs/tx': 4.2.0 + '@metamask/superstruct': 3.4.1 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + '@types/debug': 4.1.13 + debug: 4.4.3 + pony-cause: 2.1.11 + semver: 7.8.5 + uuid: 9.0.1 + transitivePeerDependencies: + - supports-color + + '@msgpack/msgpack@3.1.2': {} + + '@napi-rs/wasm-runtime@1.2.2(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)': + dependencies: + '@emnapi/core': 1.10.0 + '@emnapi/runtime': 1.10.0 + '@tybys/wasm-util': 0.10.3 + optional: true + + '@next/env@15.5.9': {} + + '@next/eslint-plugin-next@15.5.9': + dependencies: + fast-glob: 3.3.1 + + '@next/swc-darwin-arm64@15.5.7': + optional: true + + '@next/swc-darwin-x64@15.5.7': + optional: true + + '@next/swc-linux-arm64-gnu@15.5.7': + optional: true + + '@next/swc-linux-arm64-musl@15.5.7': + optional: true + + '@next/swc-linux-x64-gnu@15.5.7': + optional: true + + '@next/swc-linux-x64-musl@15.5.7': + optional: true + + '@next/swc-win32-arm64-msvc@15.5.7': + optional: true + + '@next/swc-win32-x64-msvc@15.5.7': + optional: true + + '@noble/ciphers@0.4.1': {} + + '@noble/ciphers@1.3.0': {} + + '@noble/curves@1.4.2': + dependencies: + '@noble/hashes': 1.4.0 + + '@noble/curves@1.8.0': + dependencies: + '@noble/hashes': 1.7.0 + + '@noble/curves@1.9.1': + dependencies: + '@noble/hashes': 1.8.0 + + '@noble/curves@1.9.2': + dependencies: + '@noble/hashes': 1.8.0 + + '@noble/curves@1.9.7': + dependencies: + '@noble/hashes': 1.8.0 + + '@noble/curves@2.0.1': + dependencies: + '@noble/hashes': 2.0.1 + + '@noble/hashes@1.4.0': {} + + '@noble/hashes@1.7.0': {} + + '@noble/hashes@1.8.0': {} + + '@noble/hashes@2.0.1': {} + + '@noble/hashes@2.3.0': {} + + '@noble/post-quantum@0.5.4': + dependencies: + '@noble/curves': 2.0.1 + '@noble/hashes': 2.0.1 + + '@nodelib/fs.scandir@2.1.5': + dependencies: + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 + + '@nodelib/fs.stat@2.0.5': {} + + '@nodelib/fs.walk@1.2.8': + dependencies: + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.20.1 + + '@nolyfill/is-core-module@1.0.39': {} + + '@paulmillr/qr@0.2.1': {} + + '@protobufjs/aspromise@1.1.2': {} + + '@protobufjs/base64@1.1.2': {} + + '@protobufjs/codegen@2.0.5': {} + + '@protobufjs/eventemitter@1.1.1': {} + + '@protobufjs/fetch@1.1.1': + dependencies: + '@protobufjs/aspromise': 1.1.2 + + '@protobufjs/float@1.0.2': {} + + '@protobufjs/path@1.1.2': {} + + '@protobufjs/pool@1.1.0': {} + + '@protobufjs/utf8@1.1.2': {} + + '@rtsao/scc@1.1.0': {} + + '@rushstack/eslint-patch@1.16.1': {} + + '@scure/base@1.1.9': {} + + '@scure/base@1.2.6': {} + + '@scure/bip32@1.4.0': + dependencies: + '@noble/curves': 1.4.2 + '@noble/hashes': 1.4.0 + '@scure/base': 1.1.9 + + '@scure/bip32@1.7.0': + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + + '@scure/bip39@1.3.0': + dependencies: + '@noble/hashes': 1.4.0 + '@scure/base': 1.1.9 + + '@scure/bip39@1.6.0': + dependencies: + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + + '@simplewebauthn/browser@13.1.0': {} + + '@sindresorhus/is@4.6.0': {} + + '@solana-program/system@0.10.0(@solana/kit@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3))': + dependencies: + '@solana/kit': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + + '@solana-program/token@0.9.0(@solana/kit@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3))': + dependencies: + '@solana/kit': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + + '@solana/accounts@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/addresses@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/assertions': 5.5.1(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/assertions@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/codecs-core@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/codecs-data-structures@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/codecs-numbers@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/codecs-strings@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + fastestsmallesttextencoderdecoder: 1.0.22 + typescript: 5.9.3 + + '@solana/codecs@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-data-structures': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/options': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/errors@5.5.1(typescript@5.9.3)': + dependencies: + chalk: 5.6.2 + commander: 14.0.2 + optionalDependencies: + typescript: 5.9.3 + + '@solana/fast-stable-stringify@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/functional@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/instruction-plans@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/instructions': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/promises': 5.5.1(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/instructions@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/keys@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/assertions': 5.5.1(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/kit@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/accounts': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/instruction-plans': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/instructions': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/offchain-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/plugin-core': 5.5.1(typescript@5.9.3) + '@solana/programs': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-api': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-parsed-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-subscriptions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/signers': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/sysvars': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-confirmation': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - fastestsmallesttextencoderdecoder + - utf-8-validate + + '@solana/nominal-types@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/offchain-messages@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-data-structures': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/options@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-data-structures': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/plugin-core@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/programs@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/promises@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-api@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-parsed-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-transformers': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/rpc-parsed-types@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-spec-types@5.5.1(typescript@5.9.3)': + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-spec@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-subscriptions-api@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-subscriptions-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-transformers': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/rpc-subscriptions-channel-websocket@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/rpc-subscriptions-spec': 5.5.1(typescript@5.9.3) + '@solana/subscribable': 5.5.1(typescript@5.9.3) + ws: 8.21.3 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + + '@solana/rpc-subscriptions-spec@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/promises': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + '@solana/subscribable': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-subscriptions@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/fast-stable-stringify': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/promises': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-subscriptions-api': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-subscriptions-channel-websocket': 5.5.1(typescript@5.9.3) + '@solana/rpc-subscriptions-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-transformers': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/subscribable': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - fastestsmallesttextencoderdecoder + - utf-8-validate + + '@solana/rpc-transformers@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/rpc-transport-http@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + undici-types: 7.29.0 + optionalDependencies: + typescript: 5.9.3 + + '@solana/rpc-types@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/rpc@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/fast-stable-stringify': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/rpc-api': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-spec': 5.5.1(typescript@5.9.3) + '@solana/rpc-spec-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-transformers': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-transport-http': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/signers@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/instructions': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + '@solana/offchain-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/subscribable@5.5.1(typescript@5.9.3)': + dependencies: + '@solana/errors': 5.5.1(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + + '@solana/sysvars@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/accounts': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/transaction-confirmation@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/promises': 5.5.1(typescript@5.9.3) + '@solana/rpc': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-subscriptions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transactions': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - fastestsmallesttextencoderdecoder + - utf-8-validate + + '@solana/transaction-messages@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-data-structures': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/instructions': 5.5.1(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@solana/transactions@5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3)': + dependencies: + '@solana/addresses': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/codecs-core': 5.5.1(typescript@5.9.3) + '@solana/codecs-data-structures': 5.5.1(typescript@5.9.3) + '@solana/codecs-numbers': 5.5.1(typescript@5.9.3) + '@solana/codecs-strings': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/errors': 5.5.1(typescript@5.9.3) + '@solana/functional': 5.5.1(typescript@5.9.3) + '@solana/instructions': 5.5.1(typescript@5.9.3) + '@solana/keys': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/nominal-types': 5.5.1(typescript@5.9.3) + '@solana/rpc-types': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + '@solana/transaction-messages': 5.5.1(fastestsmallesttextencoderdecoder@1.0.22)(typescript@5.9.3) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - fastestsmallesttextencoderdecoder + + '@swc/helpers@0.5.15': + dependencies: + tslib: 2.8.1 + + '@szmarczak/http-timer@4.0.6': + dependencies: + defer-to-connect: 2.0.1 + + '@tailwindcss/node@4.1.18': + dependencies: + '@jridgewell/remapping': 2.3.5 + enhanced-resolve: 5.24.5 + jiti: 2.7.0 + lightningcss: 1.30.2 + magic-string: 0.30.21 + source-map-js: 1.2.1 + tailwindcss: 4.1.18 + + '@tailwindcss/oxide-android-arm64@4.1.18': + optional: true + + '@tailwindcss/oxide-darwin-arm64@4.1.18': + optional: true + + '@tailwindcss/oxide-darwin-x64@4.1.18': + optional: true + + '@tailwindcss/oxide-freebsd-x64@4.1.18': + optional: true + + '@tailwindcss/oxide-linux-arm-gnueabihf@4.1.18': + optional: true + + '@tailwindcss/oxide-linux-arm64-gnu@4.1.18': + optional: true + + '@tailwindcss/oxide-linux-arm64-musl@4.1.18': + optional: true + + '@tailwindcss/oxide-linux-x64-gnu@4.1.18': + optional: true + + '@tailwindcss/oxide-linux-x64-musl@4.1.18': + optional: true + + '@tailwindcss/oxide-wasm32-wasi@4.1.18': + optional: true + + '@tailwindcss/oxide-win32-arm64-msvc@4.1.18': + optional: true + + '@tailwindcss/oxide-win32-x64-msvc@4.1.18': + optional: true + + '@tailwindcss/oxide@4.1.18': + optionalDependencies: + '@tailwindcss/oxide-android-arm64': 4.1.18 + '@tailwindcss/oxide-darwin-arm64': 4.1.18 + '@tailwindcss/oxide-darwin-x64': 4.1.18 + '@tailwindcss/oxide-freebsd-x64': 4.1.18 + '@tailwindcss/oxide-linux-arm-gnueabihf': 4.1.18 + '@tailwindcss/oxide-linux-arm64-gnu': 4.1.18 + '@tailwindcss/oxide-linux-arm64-musl': 4.1.18 + '@tailwindcss/oxide-linux-x64-gnu': 4.1.18 + '@tailwindcss/oxide-linux-x64-musl': 4.1.18 + '@tailwindcss/oxide-wasm32-wasi': 4.1.18 + '@tailwindcss/oxide-win32-arm64-msvc': 4.1.18 + '@tailwindcss/oxide-win32-x64-msvc': 4.1.18 + + '@tailwindcss/postcss@4.1.18': + dependencies: + '@alloc/quick-lru': 5.2.0 + '@tailwindcss/node': 4.1.18 + '@tailwindcss/oxide': 4.1.18 + postcss: 8.5.6 + tailwindcss: 4.1.18 + + '@tanstack/query-core@5.90.12': {} + + '@tanstack/react-query@5.90.12(react@19.1.2)': + dependencies: + '@tanstack/query-core': 5.90.12 + react: 19.1.2 + + '@tybys/wasm-util@0.10.3': + dependencies: + tslib: 2.8.1 + optional: true + + '@types/cacheable-request@6.0.3': + dependencies: + '@types/http-cache-semantics': 4.2.0 + '@types/keyv': 3.1.4 + '@types/node': 20.19.27 + '@types/responselike': 1.0.3 + + '@types/debug@4.1.13': + dependencies: + '@types/ms': 2.1.0 + + '@types/estree@1.0.9': {} + + '@types/http-cache-semantics@4.2.0': {} + + '@types/json-schema@7.0.15': {} + + '@types/json5@0.0.29': {} + + '@types/keyv@3.1.4': + dependencies: + '@types/node': 20.19.27 + + '@types/lodash@4.17.25': {} + + '@types/ms@2.1.0': {} + + '@types/node@20.19.27': + dependencies: + undici-types: 6.21.0 + + '@types/react-dom@19.1.9(@types/react@19.1.12)': + dependencies: + '@types/react': 19.1.12 + + '@types/react@19.1.12': + dependencies: + csstype: 3.2.3 + + '@types/responselike@1.0.3': + dependencies: + '@types/node': 20.19.27 + + '@typescript-eslint/eslint-plugin@8.66.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3)': + dependencies: + '@eslint-community/regexpp': 4.12.2 + '@typescript-eslint/parser': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + '@typescript-eslint/scope-manager': 8.66.0 + '@typescript-eslint/type-utils': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + '@typescript-eslint/utils': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 8.66.0 + eslint: 9.39.2(jiti@2.7.0) + ignore: 7.0.6 + natural-compare: 1.4.0 + ts-api-utils: 2.5.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3)': + dependencies: + '@typescript-eslint/scope-manager': 8.66.0 + '@typescript-eslint/types': 8.66.0 + '@typescript-eslint/typescript-estree': 8.66.0(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 8.66.0 + debug: 4.4.3 + eslint: 9.39.2(jiti@2.7.0) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/project-service@8.66.0(typescript@5.9.3)': + dependencies: + '@typescript-eslint/tsconfig-utils': 8.66.0(typescript@5.9.3) + '@typescript-eslint/types': 8.66.0 + debug: 4.4.3 + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/scope-manager@8.66.0': + dependencies: + '@typescript-eslint/types': 8.66.0 + '@typescript-eslint/visitor-keys': 8.66.0 + + '@typescript-eslint/tsconfig-utils@8.66.0(typescript@5.9.3)': + dependencies: + typescript: 5.9.3 + + '@typescript-eslint/type-utils@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3)': + dependencies: + '@typescript-eslint/types': 8.66.0 + '@typescript-eslint/typescript-estree': 8.66.0(typescript@5.9.3) + '@typescript-eslint/utils': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + debug: 4.4.3 + eslint: 9.39.2(jiti@2.7.0) + ts-api-utils: 2.5.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/types@8.66.0': {} + + '@typescript-eslint/typescript-estree@8.66.0(typescript@5.9.3)': + dependencies: + '@typescript-eslint/project-service': 8.66.0(typescript@5.9.3) + '@typescript-eslint/tsconfig-utils': 8.66.0(typescript@5.9.3) + '@typescript-eslint/types': 8.66.0 + '@typescript-eslint/visitor-keys': 8.66.0 + debug: 4.4.3 + minimatch: 10.2.6 + semver: 7.8.5 + tinyglobby: 0.2.17 + ts-api-utils: 2.5.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/utils@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3)': + dependencies: + '@eslint-community/eslint-utils': 4.10.1(eslint@9.39.2(jiti@2.7.0)) + '@typescript-eslint/scope-manager': 8.66.0 + '@typescript-eslint/types': 8.66.0 + '@typescript-eslint/typescript-estree': 8.66.0(typescript@5.9.3) + eslint: 9.39.2(jiti@2.7.0) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/visitor-keys@8.66.0': + dependencies: + '@typescript-eslint/types': 8.66.0 + eslint-visitor-keys: 5.0.1 + + '@unrs/resolver-binding-android-arm-eabi@1.12.2': + optional: true + + '@unrs/resolver-binding-android-arm64@1.12.2': + optional: true + + '@unrs/resolver-binding-darwin-arm64@1.12.2': + optional: true + + '@unrs/resolver-binding-darwin-x64@1.12.2': + optional: true + + '@unrs/resolver-binding-freebsd-x64@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-arm-gnueabihf@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-arm-musleabihf@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-arm64-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-arm64-musl@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-loong64-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-loong64-musl@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-ppc64-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-riscv64-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-riscv64-musl@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-s390x-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-x64-gnu@1.12.2': + optional: true + + '@unrs/resolver-binding-linux-x64-musl@1.12.2': + optional: true + + '@unrs/resolver-binding-openharmony-arm64@1.12.2': + optional: true + + '@unrs/resolver-binding-wasm32-wasi@1.12.2': + dependencies: + '@emnapi/core': 1.10.0 + '@emnapi/runtime': 1.10.0 + '@napi-rs/wasm-runtime': 1.2.2(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0) + optional: true + + '@unrs/resolver-binding-win32-arm64-msvc@1.12.2': + optional: true + + '@unrs/resolver-binding-win32-ia32-msvc@1.12.2': + optional: true + + '@unrs/resolver-binding-win32-x64-msvc@1.12.2': + optional: true + + '@vue/reactivity@3.5.41': + dependencies: + '@vue/shared': 3.5.41 + + '@vue/shared@3.5.41': {} + + '@walletconnect/core@2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5)': + dependencies: + '@walletconnect/heartbeat': 1.2.2 + '@walletconnect/jsonrpc-provider': 1.0.14 + '@walletconnect/jsonrpc-types': 1.0.4 + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/jsonrpc-ws-connection': 1.0.16 + '@walletconnect/keyvaluestorage': 1.1.1(aws4fetch@1.0.20) + '@walletconnect/logger': 2.1.2 + '@walletconnect/relay-api': 1.0.11 + '@walletconnect/relay-auth': 1.1.0 + '@walletconnect/safe-json': 1.0.2 + '@walletconnect/time': 1.0.2 + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/utils': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5) + '@walletconnect/window-getters': 1.0.1 + es-toolkit: 1.39.3 + events: 3.3.0 + uint8arrays: 3.1.1 + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - bufferutil + - db0 + - ioredis + - typescript + - uploadthing + - utf-8-validate + - zod + + '@walletconnect/environment@1.0.1': + dependencies: + tslib: 1.14.1 + + '@walletconnect/events@1.0.1': + dependencies: + keyvaluestorage-interface: 1.0.0 + tslib: 1.14.1 + + '@walletconnect/heartbeat@1.2.2': + dependencies: + '@walletconnect/events': 1.0.1 + '@walletconnect/time': 1.0.2 + events: 3.3.0 + + '@walletconnect/jsonrpc-provider@1.0.14': + dependencies: + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/safe-json': 1.0.2 + events: 3.3.0 + + '@walletconnect/jsonrpc-types@1.0.4': + dependencies: + events: 3.3.0 + keyvaluestorage-interface: 1.0.0 + + '@walletconnect/jsonrpc-utils@1.0.8': + dependencies: + '@walletconnect/environment': 1.0.1 + '@walletconnect/jsonrpc-types': 1.0.4 + tslib: 1.14.1 + + '@walletconnect/jsonrpc-ws-connection@1.0.16': + dependencies: + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/safe-json': 1.0.2 + events: 3.3.0 + ws: 7.5.13 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + + '@walletconnect/keyvaluestorage@1.1.1(aws4fetch@1.0.20)': + dependencies: + '@walletconnect/safe-json': 1.0.2 + idb-keyval: 6.3.0 + unstorage: 1.17.5(aws4fetch@1.0.20)(idb-keyval@6.3.0) + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - db0 + - ioredis + - uploadthing + + '@walletconnect/logger@2.1.2': + dependencies: + '@walletconnect/safe-json': 1.0.2 + pino: 7.11.0 + + '@walletconnect/relay-api@1.0.11': + dependencies: + '@walletconnect/jsonrpc-types': 1.0.4 + + '@walletconnect/relay-auth@1.1.0': + dependencies: + '@noble/curves': 1.8.0 + '@noble/hashes': 1.7.0 + '@walletconnect/safe-json': 1.0.2 + '@walletconnect/time': 1.0.2 + uint8arrays: 3.1.1 + + '@walletconnect/safe-json@1.0.2': + dependencies: + tslib: 1.14.1 + + '@walletconnect/sign-client@2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5)': + dependencies: + '@walletconnect/core': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5) + '@walletconnect/events': 1.0.1 + '@walletconnect/heartbeat': 1.2.2 + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/logger': 2.1.2 + '@walletconnect/time': 1.0.2 + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/utils': 2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5) + events: 3.3.0 + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - bufferutil + - db0 + - ioredis + - typescript + - uploadthing + - utf-8-validate + - zod + + '@walletconnect/time@1.0.2': + dependencies: + tslib: 1.14.1 + + '@walletconnect/types@2.21.8(aws4fetch@1.0.20)': + dependencies: + '@walletconnect/events': 1.0.1 + '@walletconnect/heartbeat': 1.2.2 + '@walletconnect/jsonrpc-types': 1.0.4 + '@walletconnect/keyvaluestorage': 1.1.1(aws4fetch@1.0.20) + '@walletconnect/logger': 2.1.2 + events: 3.3.0 + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - db0 + - ioredis + - uploadthing + + '@walletconnect/utils@2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@3.25.76)': + dependencies: + '@msgpack/msgpack': 3.1.2 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.2 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/keyvaluestorage': 1.1.1(aws4fetch@1.0.20) + '@walletconnect/relay-api': 1.0.11 + '@walletconnect/relay-auth': 1.1.0 + '@walletconnect/safe-json': 1.0.2 + '@walletconnect/time': 1.0.2 + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/window-getters': 1.0.1 + '@walletconnect/window-metadata': 1.0.1 + blakejs: 1.2.1 + bs58: 6.0.0 + detect-browser: 5.3.0 + query-string: 7.1.3 + uint8arrays: 3.1.1 + viem: 2.31.0(typescript@5.9.3)(zod@3.25.76) + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - bufferutil + - db0 + - ioredis + - typescript + - uploadthing + - utf-8-validate + - zod + + '@walletconnect/utils@2.21.8(aws4fetch@1.0.20)(typescript@5.9.3)(zod@4.0.5)': + dependencies: + '@msgpack/msgpack': 3.1.2 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.2 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + '@walletconnect/jsonrpc-utils': 1.0.8 + '@walletconnect/keyvaluestorage': 1.1.1(aws4fetch@1.0.20) + '@walletconnect/relay-api': 1.0.11 + '@walletconnect/relay-auth': 1.1.0 + '@walletconnect/safe-json': 1.0.2 + '@walletconnect/time': 1.0.2 + '@walletconnect/types': 2.21.8(aws4fetch@1.0.20) + '@walletconnect/window-getters': 1.0.1 + '@walletconnect/window-metadata': 1.0.1 + blakejs: 1.2.1 + bs58: 6.0.0 + detect-browser: 5.3.0 + query-string: 7.1.3 + uint8arrays: 3.1.1 + viem: 2.31.0(typescript@5.9.3)(zod@4.0.5) + transitivePeerDependencies: + - '@azure/app-configuration' + - '@azure/cosmos' + - '@azure/data-tables' + - '@azure/identity' + - '@azure/keyvault-secrets' + - '@azure/storage-blob' + - '@capacitor/preferences' + - '@deno/kv' + - '@netlify/blobs' + - '@planetscale/database' + - '@react-native-async-storage/async-storage' + - '@upstash/redis' + - '@vercel/blob' + - '@vercel/functions' + - '@vercel/kv' + - aws4fetch + - bufferutil + - db0 + - ioredis + - typescript + - uploadthing + - utf-8-validate + - zod + + '@walletconnect/window-getters@1.0.1': + dependencies: + tslib: 1.14.1 + + '@walletconnect/window-metadata@1.0.1': + dependencies: + '@walletconnect/window-getters': 1.0.1 + tslib: 1.14.1 + + abitype@1.0.6(typescript@5.9.3)(zod@3.25.76): + optionalDependencies: + typescript: 5.9.3 + zod: 3.25.76 + + abitype@1.0.8(typescript@5.9.3)(zod@3.25.76): + optionalDependencies: + typescript: 5.9.3 + zod: 3.25.76 + + abitype@1.0.8(typescript@5.9.3)(zod@4.0.5): + optionalDependencies: + typescript: 5.9.3 + zod: 4.0.5 + + abitype@1.1.0(typescript@5.9.3)(zod@3.25.76): + optionalDependencies: + typescript: 5.9.3 + zod: 3.25.76 + + abitype@1.2.3(typescript@5.9.3)(zod@3.25.76): + optionalDependencies: + typescript: 5.9.3 + zod: 3.25.76 + + abitype@1.3.0(typescript@5.9.3)(zod@3.25.76): + optionalDependencies: + typescript: 5.9.3 + zod: 3.25.76 + + ably@2.17.1(react-dom@19.1.2(react@19.1.2))(react@19.1.2): + dependencies: + '@ably/msgpack-js': 0.4.1 + dequal: 2.0.3 + fastestsmallesttextencoderdecoder: 1.0.22 + got: 11.8.6 + ulid: 2.4.0 + ws: 8.21.3 + optionalDependencies: + react: 19.1.2 + react-dom: 19.1.2(react@19.1.2) + transitivePeerDependencies: + - bufferutil + - utf-8-validate + + acorn-jsx@5.3.2(acorn@8.18.0): + dependencies: + acorn: 8.18.0 + + acorn@8.18.0: {} + + ajv@6.15.0: + dependencies: + fast-deep-equal: 3.1.3 + fast-json-stable-stringify: 2.1.0 + json-schema-traverse: 0.4.1 + uri-js: 4.4.1 + + ansi-styles@4.3.0: + dependencies: + color-convert: 2.0.1 + + anymatch@3.1.3: + dependencies: + normalize-path: 3.0.0 + picomatch: 2.3.2 + + argparse@2.0.1: {} + + aria-query@5.3.2: {} + + array-buffer-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + is-array-buffer: 3.0.5 + + array-includes@3.1.9: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-object-atoms: 1.1.2 + get-intrinsic: 1.3.0 + is-string: 1.1.1 + math-intrinsics: 1.1.0 + + array.prototype.findlast@1.2.5: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + es-shim-unscopables: 1.1.0 + + array.prototype.findlastindex@1.2.6: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + es-shim-unscopables: 1.1.0 + + array.prototype.flat@1.3.3: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-shim-unscopables: 1.1.0 + + array.prototype.flatmap@1.3.3: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-shim-unscopables: 1.1.0 + + array.prototype.tosorted@1.1.4: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-shim-unscopables: 1.1.0 + + arraybuffer.prototype.slice@1.0.4: + dependencies: + array-buffer-byte-length: 1.0.2 + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + is-array-buffer: 3.0.5 + + ast-types-flow@0.0.8: {} + + async-function@1.0.0: {} + + async-mutex@0.5.0: + dependencies: + tslib: 2.8.1 + + asynckit@0.4.0: {} + + atomic-sleep@1.0.0: {} + + available-typed-arrays@1.0.7: + dependencies: + possible-typed-array-names: 1.1.0 + + aws4fetch@1.0.20: + optional: true + + axe-core@4.13.0: {} + + axios-retry@4.5.0(axios@1.16.0): + dependencies: + axios: 1.16.0 + is-retry-allowed: 2.2.0 + + axios@1.16.0: + dependencies: + follow-redirects: 1.16.0 + form-data: 4.0.6 + proxy-from-env: 2.1.0 + transitivePeerDependencies: + - debug + + axobject-query@4.1.0: {} + + balanced-match@1.0.2: {} + + balanced-match@4.0.4: {} + + base-x@5.0.1: {} + + base64-js@1.0.2: {} + + base64-js@1.5.1: {} + + blakejs@1.2.1: {} + + bops@1.0.1: + dependencies: + base64-js: 1.0.2 + to-utf8: 0.0.1 + + bowser@2.14.1: {} + + brace-expansion@1.1.18: + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + + brace-expansion@5.0.9: + dependencies: + balanced-match: 4.0.4 + + braces@3.0.3: + dependencies: + fill-range: 7.1.1 + + brotli-wasm@3.0.1: {} + + bs58@6.0.0: + dependencies: + base-x: 5.0.1 + + buffer@6.0.3: + dependencies: + base64-js: 1.5.1 + ieee754: 1.2.1 + + cacheable-lookup@5.0.4: {} + + cacheable-request@7.0.4: + dependencies: + clone-response: 1.0.3 + get-stream: 5.2.0 + http-cache-semantics: 4.2.0 + keyv: 4.5.4 + lowercase-keys: 2.0.0 + normalize-url: 6.1.0 + responselike: 2.0.1 + + call-bind-apply-helpers@1.0.2: + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + + call-bind@1.0.9: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + get-intrinsic: 1.3.0 + set-function-length: 1.2.2 + + call-bound@1.0.4: + dependencies: + call-bind-apply-helpers: 1.0.2 + get-intrinsic: 1.3.0 + + callsites@3.1.0: {} + + caniuse-lite@1.0.30001809: {} + + centrifuge@5.7.0: + dependencies: + events: 3.3.0 + protobufjs: 7.6.5 + + chalk@4.1.2: + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + + chalk@5.6.2: {} + + charenc@0.0.2: {} + + chokidar@5.0.0: + dependencies: + readdirp: 5.1.1 + + client-only@0.0.1: {} + + clone-response@1.0.3: + dependencies: + mimic-response: 1.0.1 + + clsx@1.2.1: {} + + clsx@2.1.1: {} + + color-convert@2.0.1: + dependencies: + color-name: 1.1.4 + + color-name@1.1.4: {} + + combined-stream@1.0.8: + dependencies: + delayed-stream: 1.0.0 + + commander@14.0.2: {} + + concat-map@0.0.1: {} + + cookie-es@1.2.3: {} + + crc-32@1.2.2: {} + + cross-fetch@4.1.0: + dependencies: + node-fetch: 2.7.0 + transitivePeerDependencies: + - encoding + + cross-spawn@7.0.6: + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + + crossws@0.3.5: + dependencies: + uncrypto: 0.1.3 + + crypt@0.0.2: {} + + csstype@3.2.3: {} + + damerau-levenshtein@1.0.8: {} + + data-view-buffer@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-length@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + data-view-byte-offset@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-data-view: 1.0.2 + + debug@3.2.7: + dependencies: + ms: 2.1.3 + + debug@4.4.3: + dependencies: + ms: 2.1.3 + + decode-uri-component@0.2.2: {} + + decompress-response@6.0.0: + dependencies: + mimic-response: 3.1.0 + + deep-is@0.1.4: {} + + defer-to-connect@2.0.1: {} + + define-data-property@1.1.4: + dependencies: + es-define-property: 1.0.1 + es-errors: 1.3.0 + gopd: 1.2.0 + + define-properties@1.2.1: + dependencies: + define-data-property: 1.1.4 + has-property-descriptors: 1.0.2 + object-keys: 1.1.1 + + defu@6.1.7: {} + + delayed-stream@1.0.0: {} + + dequal@2.0.3: {} + + destr@2.0.5: {} + + detect-browser@5.3.0: {} + + detect-libc@2.1.2: {} + + doctrine@2.1.0: + dependencies: + esutils: 2.0.3 + + dunder-proto@1.0.1: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-errors: 1.3.0 + gopd: 1.2.0 + + duplexify@4.1.3: + dependencies: + end-of-stream: 1.4.5 + inherits: 2.0.4 + readable-stream: 3.6.2 + stream-shift: 1.0.3 + + eciesjs@0.4.17: + dependencies: + '@ecies/ciphers': 0.2.6(@noble/ciphers@1.3.0) + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.7 + '@noble/hashes': 1.8.0 + + emoji-regex@9.2.2: {} + + end-of-stream@1.4.5: + dependencies: + once: 1.4.0 + + enhanced-resolve@5.24.5: + dependencies: + graceful-fs: 4.2.11 + tapable: 2.3.3 + + es-abstract-get@1.0.0: + dependencies: + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + is-callable: 1.2.7 + object-inspect: 1.13.4 + + es-abstract@1.24.2: + dependencies: + array-buffer-byte-length: 1.0.2 + arraybuffer.prototype.slice: 1.0.4 + available-typed-arrays: 1.0.7 + call-bind: 1.0.9 + call-bound: 1.0.4 + data-view-buffer: 1.0.2 + data-view-byte-length: 1.0.2 + data-view-byte-offset: 1.0.1 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + es-set-tostringtag: 2.1.0 + es-to-primitive: 1.3.4 + function.prototype.name: 1.2.0 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + get-symbol-description: 1.1.0 + globalthis: 1.0.4 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + has-proto: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.4 + internal-slot: 1.1.0 + is-array-buffer: 3.0.5 + is-callable: 1.2.7 + is-data-view: 1.0.2 + is-negative-zero: 2.0.3 + is-regex: 1.2.1 + is-set: 2.0.3 + is-shared-array-buffer: 1.0.4 + is-string: 1.1.1 + is-typed-array: 1.1.15 + is-weakref: 1.1.1 + math-intrinsics: 1.1.0 + object-inspect: 1.13.4 + object-keys: 1.1.1 + object.assign: 4.1.7 + own-keys: 1.0.2 + regexp.prototype.flags: 1.5.4 + safe-array-concat: 1.1.4 + safe-push-apply: 1.0.0 + safe-regex-test: 1.1.0 + set-proto: 1.0.0 + stop-iteration-iterator: 1.1.0 + string.prototype.trim: 1.2.11 + string.prototype.trimend: 1.0.10 + string.prototype.trimstart: 1.0.8 + typed-array-buffer: 1.0.3 + typed-array-byte-length: 1.0.3 + typed-array-byte-offset: 1.0.4 + typed-array-length: 1.0.8 + unbox-primitive: 1.1.0 + which-typed-array: 1.1.22 + + es-define-property@1.0.1: {} + + es-errors@1.3.0: {} + + es-iterator-helpers@1.4.0: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-set-tostringtag: 2.1.0 + function-bind: 1.1.2 + get-intrinsic: 1.3.0 + globalthis: 1.0.4 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + has-proto: 1.2.0 + has-symbols: 1.1.0 + internal-slot: 1.1.0 + iterator.prototype: 1.1.5 + math-intrinsics: 1.1.0 + + es-object-atoms@1.1.2: + dependencies: + es-errors: 1.3.0 + + es-set-tostringtag@2.1.0: + dependencies: + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + has-tostringtag: 1.0.2 + hasown: 2.0.4 + + es-shim-unscopables@1.1.0: + dependencies: + hasown: 2.0.4 + + es-to-primitive@1.3.4: + dependencies: + es-abstract-get: 1.0.0 + es-define-property: 1.0.1 + es-errors: 1.3.0 + is-callable: 1.2.7 + is-date-object: 1.1.0 + is-symbol: 1.1.1 + + es-toolkit@1.39.3: {} + + escape-string-regexp@4.0.0: {} + + eslint-config-next@15.5.9(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3): + dependencies: + '@next/eslint-plugin-next': 15.5.9 + '@rushstack/eslint-patch': 1.16.1 + '@typescript-eslint/eslint-plugin': 8.66.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + '@typescript-eslint/parser': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + eslint: 9.39.2(jiti@2.7.0) + eslint-import-resolver-node: 0.3.10 + eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.2(jiti@2.7.0)) + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.2(jiti@2.7.0)) + eslint-plugin-jsx-a11y: 6.10.2(eslint@9.39.2(jiti@2.7.0)) + eslint-plugin-react: 7.37.5(eslint@9.39.2(jiti@2.7.0)) + eslint-plugin-react-hooks: 5.2.0(eslint@9.39.2(jiti@2.7.0)) + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - eslint-import-resolver-webpack + - eslint-plugin-import-x + - supports-color + + eslint-import-resolver-node@0.3.10: + dependencies: + debug: 3.2.7 + is-core-module: 2.16.2 + resolve: 2.0.0-next.7 + transitivePeerDependencies: + - supports-color + + eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.2(jiti@2.7.0)): + dependencies: + '@nolyfill/is-core-module': 1.0.39 + debug: 4.4.3 + eslint: 9.39.2(jiti@2.7.0) + get-tsconfig: 4.14.1 + is-bun-module: 2.0.0 + stable-hash: 0.0.5 + tinyglobby: 0.2.17 + unrs-resolver: 1.12.2 + optionalDependencies: + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.2(jiti@2.7.0)) + transitivePeerDependencies: + - supports-color + + eslint-module-utils@2.14.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.2(jiti@2.7.0)): + dependencies: + debug: 3.2.7 + optionalDependencies: + '@typescript-eslint/parser': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + eslint: 9.39.2(jiti@2.7.0) + eslint-import-resolver-node: 0.3.10 + eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.2(jiti@2.7.0)) + transitivePeerDependencies: + - supports-color + + eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.2(jiti@2.7.0)): + dependencies: + '@rtsao/scc': 1.1.0 + array-includes: 3.1.9 + array.prototype.findlastindex: 1.2.6 + array.prototype.flat: 1.3.3 + array.prototype.flatmap: 1.3.3 + debug: 3.2.7 + doctrine: 2.1.0 + eslint: 9.39.2(jiti@2.7.0) + eslint-import-resolver-node: 0.3.10 + eslint-module-utils: 2.14.0(@typescript-eslint/parser@8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.2(jiti@2.7.0)) + hasown: 2.0.4 + is-core-module: 2.16.2 + is-glob: 4.0.3 + minimatch: 3.1.5 + object.fromentries: 2.0.8 + object.groupby: 1.0.3 + object.values: 1.2.1 + semver: 6.3.1 + string.prototype.trimend: 1.0.10 + tsconfig-paths: 3.15.0 + optionalDependencies: + '@typescript-eslint/parser': 8.66.0(eslint@9.39.2(jiti@2.7.0))(typescript@5.9.3) + transitivePeerDependencies: + - eslint-import-resolver-typescript + - eslint-import-resolver-webpack + - supports-color + + eslint-plugin-jsx-a11y@6.10.2(eslint@9.39.2(jiti@2.7.0)): + dependencies: + aria-query: 5.3.2 + array-includes: 3.1.9 + array.prototype.flatmap: 1.3.3 + ast-types-flow: 0.0.8 + axe-core: 4.13.0 + axobject-query: 4.1.0 + damerau-levenshtein: 1.0.8 + emoji-regex: 9.2.2 + eslint: 9.39.2(jiti@2.7.0) + hasown: 2.0.4 + jsx-ast-utils: 3.3.5 + language-tags: 1.0.9 + minimatch: 3.1.5 + object.fromentries: 2.0.8 + safe-regex-test: 1.1.0 + string.prototype.includes: 2.0.1 + + eslint-plugin-react-hooks@5.2.0(eslint@9.39.2(jiti@2.7.0)): + dependencies: + eslint: 9.39.2(jiti@2.7.0) + + eslint-plugin-react@7.37.5(eslint@9.39.2(jiti@2.7.0)): + dependencies: + array-includes: 3.1.9 + array.prototype.findlast: 1.2.5 + array.prototype.flatmap: 1.3.3 + array.prototype.tosorted: 1.1.4 + doctrine: 2.1.0 + es-iterator-helpers: 1.4.0 + eslint: 9.39.2(jiti@2.7.0) + estraverse: 5.3.0 + hasown: 2.0.4 + jsx-ast-utils: 3.3.5 + minimatch: 3.1.5 + object.entries: 1.1.9 + object.fromentries: 2.0.8 + object.values: 1.2.1 + prop-types: 15.8.1 + resolve: 2.0.0-next.7 + semver: 6.3.1 + string.prototype.matchall: 4.0.12 + string.prototype.repeat: 1.0.0 + + eslint-scope@8.4.0: + dependencies: + esrecurse: 4.3.0 + estraverse: 5.3.0 + + eslint-visitor-keys@3.4.3: {} + + eslint-visitor-keys@4.2.1: {} + + eslint-visitor-keys@5.0.1: {} + + eslint@9.39.2(jiti@2.7.0): + dependencies: + '@eslint-community/eslint-utils': 4.10.1(eslint@9.39.2(jiti@2.7.0)) + '@eslint-community/regexpp': 4.12.2 + '@eslint/config-array': 0.21.2 + '@eslint/config-helpers': 0.4.2 + '@eslint/core': 0.17.0 + '@eslint/eslintrc': 3.3.1 + '@eslint/js': 9.39.2 + '@eslint/plugin-kit': 0.4.1 + '@humanfs/node': 0.16.8 + '@humanwhocodes/module-importer': 1.0.1 + '@humanwhocodes/retry': 0.4.3 + '@types/estree': 1.0.9 + ajv: 6.15.0 + chalk: 4.1.2 + cross-spawn: 7.0.6 + debug: 4.4.3 + escape-string-regexp: 4.0.0 + eslint-scope: 8.4.0 + eslint-visitor-keys: 4.2.1 + espree: 10.4.0 + esquery: 1.7.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 8.0.0 + find-up: 5.0.0 + glob-parent: 6.0.2 + ignore: 5.3.2 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + json-stable-stringify-without-jsonify: 1.0.1 + lodash.merge: 4.6.2 + minimatch: 3.1.5 + natural-compare: 1.4.0 + optionator: 0.9.4 + optionalDependencies: + jiti: 2.7.0 + transitivePeerDependencies: + - supports-color + + espree@10.4.0: + dependencies: + acorn: 8.18.0 + acorn-jsx: 5.3.2(acorn@8.18.0) + eslint-visitor-keys: 4.2.1 + + esquery@1.7.0: + dependencies: + estraverse: 5.3.0 + + esrecurse@4.3.0: + dependencies: + estraverse: 5.3.0 + + estraverse@5.3.0: {} + + esutils@2.0.3: {} + + ethereum-cryptography@2.2.1: + dependencies: + '@noble/curves': 1.4.2 + '@noble/hashes': 1.4.0 + '@scure/bip32': 1.4.0 + '@scure/bip39': 1.3.0 + + eventemitter3@5.0.1: {} + + eventemitter3@5.0.4: {} + + events@3.3.0: {} + + fast-deep-equal@3.1.3: {} + + fast-glob@3.3.1: + dependencies: + '@nodelib/fs.stat': 2.0.5 + '@nodelib/fs.walk': 1.2.8 + glob-parent: 5.1.2 + merge2: 1.4.1 + micromatch: 4.0.8 + + fast-json-stable-stringify@2.1.0: {} + + fast-levenshtein@2.0.6: {} + + fast-redact@3.5.0: {} + + fast-safe-stringify@2.1.1: {} + + fastestsmallesttextencoderdecoder@1.0.22: {} + + fastq@1.20.1: + dependencies: + reusify: 1.1.0 + + fdir@6.5.0(picomatch@4.0.5): + optionalDependencies: + picomatch: 4.0.5 + + file-entry-cache@8.0.0: + dependencies: + flat-cache: 4.0.1 + + fill-range@7.1.1: + dependencies: + to-regex-range: 5.0.1 + + filter-obj@1.1.0: {} + + find-up@5.0.0: + dependencies: + locate-path: 6.0.0 + path-exists: 4.0.0 + + flat-cache@4.0.1: + dependencies: + flatted: 3.4.4 + keyv: 4.5.4 + + flatted@3.4.4: {} + + follow-redirects@1.16.0: {} + + for-each@0.3.5: + dependencies: + is-callable: 1.2.7 + + form-data@4.0.6: + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + es-set-tostringtag: 2.1.0 + hasown: 2.0.4 + mime-types: 2.1.35 + + fp-ts@2.16.11: {} + + function-bind@1.1.2: {} + + function.prototype.name@1.2.0: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + es-define-property: 1.0.1 + es-errors: 1.3.0 + functions-have-names: 1.2.3 + has-property-descriptors: 1.0.2 + hasown: 2.0.4 + is-callable: 1.2.7 + is-document.all: 1.0.0 + + functions-have-names@1.2.3: {} + + generator-function@2.0.1: {} + + get-intrinsic@1.3.0: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + function-bind: 1.1.2 + get-proto: 1.0.1 + gopd: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.4 + math-intrinsics: 1.1.0 + + get-proto@1.0.1: + dependencies: + dunder-proto: 1.0.1 + es-object-atoms: 1.1.2 + + get-stream@5.2.0: + dependencies: + pump: 3.0.4 + + get-symbol-description@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + + get-tsconfig@4.14.1: + dependencies: + resolve-pkg-maps: 1.0.0 + + glob-parent@5.1.2: + dependencies: + is-glob: 4.0.3 + + glob-parent@6.0.2: + dependencies: + is-glob: 4.0.3 + + globals@14.0.0: {} + + globalthis@1.0.4: + dependencies: + define-properties: 1.2.1 + gopd: 1.2.0 + + gopd@1.2.0: {} + + got@11.8.6: + dependencies: + '@sindresorhus/is': 4.6.0 + '@szmarczak/http-timer': 4.0.6 + '@types/cacheable-request': 6.0.3 + '@types/responselike': 1.0.3 + cacheable-lookup: 5.0.4 + cacheable-request: 7.0.4 + decompress-response: 6.0.0 + http2-wrapper: 1.0.3 + lowercase-keys: 2.0.0 + p-cancelable: 2.1.1 + responselike: 2.0.1 + + graceful-fs@4.2.11: {} + + h3@1.15.11: + dependencies: + cookie-es: 1.2.3 + crossws: 0.3.5 + defu: 6.1.7 + destr: 2.0.5 + iron-webcrypto: 1.2.1 + node-mock-http: 1.0.5 + radix3: 1.1.2 + ufo: 1.6.4 + uncrypto: 0.1.3 + + has-bigints@1.1.0: {} + + has-flag@4.0.0: {} + + has-property-descriptors@1.0.2: + dependencies: + es-define-property: 1.0.1 + + has-proto@1.2.0: + dependencies: + dunder-proto: 1.0.1 + + has-symbols@1.1.0: {} + + has-tostringtag@1.0.2: + dependencies: + has-symbols: 1.1.0 + + hasown@2.0.4: + dependencies: + function-bind: 1.1.2 + + http-cache-semantics@4.2.0: {} + + http2-wrapper@1.0.3: + dependencies: + quick-lru: 5.1.1 + resolve-alpn: 1.2.1 + + idb-keyval@6.2.1: {} + + idb-keyval@6.3.0: {} + + ieee754@1.2.1: {} + + ignore@5.3.2: {} + + ignore@7.0.6: {} + + import-fresh@3.3.1: + dependencies: + parent-module: 1.0.1 + resolve-from: 4.0.0 + + imurmurhash@0.1.4: {} + + inherits@2.0.4: {} + + internal-slot@1.1.0: + dependencies: + es-errors: 1.3.0 + hasown: 2.0.4 + side-channel: 1.1.1 + + io-ts@2.2.22(fp-ts@2.16.11): + dependencies: + fp-ts: 2.16.11 + + iron-webcrypto@1.2.1: {} + + is-array-buffer@3.0.5: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + + is-async-function@2.1.1: + dependencies: + async-function: 1.0.0 + call-bound: 1.0.4 + get-proto: 1.0.1 + has-tostringtag: 1.0.2 + safe-regex-test: 1.1.0 + + is-bigint@1.1.0: + dependencies: + has-bigints: 1.1.0 + + is-boolean-object@1.2.2: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-buffer@1.1.6: {} + + is-bun-module@2.0.0: + dependencies: + semver: 7.8.5 + + is-callable@1.2.7: {} + + is-core-module@2.16.2: + dependencies: + hasown: 2.0.4 + + is-data-view@1.0.2: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + is-typed-array: 1.1.15 + + is-date-object@1.1.0: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-document.all@1.0.0: + dependencies: + call-bound: 1.0.4 + + is-extglob@2.1.1: {} + + is-finalizationregistry@1.1.1: + dependencies: + call-bound: 1.0.4 + + is-generator-function@1.1.2: + dependencies: + call-bound: 1.0.4 + generator-function: 2.0.1 + get-proto: 1.0.1 + has-tostringtag: 1.0.2 + safe-regex-test: 1.1.0 + + is-glob@4.0.3: + dependencies: + is-extglob: 2.1.1 + + is-map@2.0.3: {} + + is-negative-zero@2.0.3: {} + + is-number-object@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-number@7.0.0: {} + + is-regex@1.2.1: + dependencies: + call-bound: 1.0.4 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + hasown: 2.0.4 + + is-retry-allowed@2.2.0: {} + + is-set@2.0.3: {} + + is-shared-array-buffer@1.0.4: + dependencies: + call-bound: 1.0.4 + + is-string@1.1.1: + dependencies: + call-bound: 1.0.4 + has-tostringtag: 1.0.2 + + is-symbol@1.1.1: + dependencies: + call-bound: 1.0.4 + has-symbols: 1.1.0 + safe-regex-test: 1.1.0 + + is-typed-array@1.1.15: + dependencies: + which-typed-array: 1.1.22 + + is-weakmap@2.0.2: {} + + is-weakref@1.1.1: + dependencies: + call-bound: 1.0.4 + + is-weakset@2.0.4: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + + isarray@2.0.5: {} + + isexe@2.0.0: {} + + isows@1.0.7(ws@8.18.2): + dependencies: + ws: 8.18.2 + + isows@1.0.7(ws@8.18.3): + dependencies: + ws: 8.18.3 + + isows@1.0.7(ws@8.21.0): + dependencies: + ws: 8.21.0 + + isows@1.0.7(ws@8.21.3): + dependencies: + ws: 8.21.3 + + iterator.prototype@1.1.5: + dependencies: + define-data-property: 1.1.4 + es-object-atoms: 1.1.2 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + has-symbols: 1.1.0 + set-function-name: 2.0.2 + + jiti@2.7.0: {} + + jose@6.2.8: {} + + js-tokens@4.0.0: {} + + js-yaml@4.3.1: + dependencies: + argparse: 2.0.1 + + json-buffer@3.0.1: {} + + json-schema-traverse@0.4.1: {} + + json-stable-stringify-without-jsonify@1.0.1: {} + + json5@1.0.2: + dependencies: + minimist: 1.2.8 + + jsx-ast-utils@3.3.5: + dependencies: + array-includes: 3.1.9 + array.prototype.flat: 1.3.3 + object.assign: 4.1.7 + object.values: 1.2.1 + + keyv@4.5.4: + dependencies: + json-buffer: 3.0.1 + + keyvaluestorage-interface@1.0.0: {} + + language-subtag-registry@0.3.23: {} + + language-tags@1.0.9: + dependencies: + language-subtag-registry: 0.3.23 + + levn@0.4.1: + dependencies: + prelude-ls: 1.2.1 + type-check: 0.4.0 + + lightningcss-android-arm64@1.30.2: + optional: true + + lightningcss-darwin-arm64@1.30.2: + optional: true + + lightningcss-darwin-x64@1.30.2: + optional: true + + lightningcss-freebsd-x64@1.30.2: + optional: true + + lightningcss-linux-arm-gnueabihf@1.30.2: + optional: true + + lightningcss-linux-arm64-gnu@1.30.2: + optional: true + + lightningcss-linux-arm64-musl@1.30.2: + optional: true + + lightningcss-linux-x64-gnu@1.30.2: + optional: true + + lightningcss-linux-x64-musl@1.30.2: + optional: true + + lightningcss-win32-arm64-msvc@1.30.2: + optional: true + + lightningcss-win32-x64-msvc@1.30.2: + optional: true + + lightningcss@1.30.2: + dependencies: + detect-libc: 2.1.2 + optionalDependencies: + lightningcss-android-arm64: 1.30.2 + lightningcss-darwin-arm64: 1.30.2 + lightningcss-darwin-x64: 1.30.2 + lightningcss-freebsd-x64: 1.30.2 + lightningcss-linux-arm-gnueabihf: 1.30.2 + lightningcss-linux-arm64-gnu: 1.30.2 + lightningcss-linux-arm64-musl: 1.30.2 + lightningcss-linux-x64-gnu: 1.30.2 + lightningcss-linux-x64-musl: 1.30.2 + lightningcss-win32-arm64-msvc: 1.30.2 + lightningcss-win32-x64-msvc: 1.30.2 + + locate-path@6.0.0: + dependencies: + p-locate: 5.0.0 + + lodash.merge@4.6.2: {} + + lodash@4.18.1: {} + + long@5.3.2: {} + + loose-envify@1.4.0: + dependencies: + js-tokens: 4.0.0 + + lowercase-keys@2.0.0: {} + + lru-cache@11.5.2: {} + + lucide-react@0.542.0(react@19.1.2): + dependencies: + react: 19.1.2 + + magic-string@0.30.21: + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + + math-intrinsics@1.1.0: {} + + md5@2.3.0: + dependencies: + charenc: 0.0.2 + crypt: 0.0.2 + is-buffer: 1.1.6 + + merge2@1.4.1: {} + + micro-ftch@0.3.1: {} + + micromatch@4.0.8: + dependencies: + braces: 3.0.3 + picomatch: 2.3.2 + + mime-db@1.52.0: {} + + mime-types@2.1.35: + dependencies: + mime-db: 1.52.0 + + mimic-response@1.0.1: {} + + mimic-response@3.1.0: {} + + minimatch@10.2.6: + dependencies: + brace-expansion: 5.0.9 + + minimatch@3.1.5: + dependencies: + brace-expansion: 1.1.18 + + minimist@1.2.8: {} + + ms@2.1.3: {} + + multiformats@9.9.0: {} + + nanoid@3.3.18: {} + + napi-postinstall@0.3.4: {} + + natural-compare@1.4.0: {} + + next@15.5.9(react-dom@19.1.2(react@19.1.2))(react@19.1.2): + dependencies: + '@next/env': 15.5.9 + '@swc/helpers': 0.5.15 + caniuse-lite: 1.0.30001809 + postcss: 8.4.31 + react: 19.1.2 + react-dom: 19.1.2(react@19.1.2) + styled-jsx: 5.1.6(react@19.1.2) + optionalDependencies: + '@next/swc-darwin-arm64': 15.5.7 + '@next/swc-darwin-x64': 15.5.7 + '@next/swc-linux-arm64-gnu': 15.5.7 + '@next/swc-linux-arm64-musl': 15.5.7 + '@next/swc-linux-x64-gnu': 15.5.7 + '@next/swc-linux-x64-musl': 15.5.7 + '@next/swc-win32-arm64-msvc': 15.5.7 + '@next/swc-win32-x64-msvc': 15.5.7 + sharp: 0.34.5 + transitivePeerDependencies: + - '@babel/core' + - babel-plugin-macros + + node-exports-info@1.6.2: + dependencies: + array.prototype.flatmap: 1.3.3 + es-errors: 1.3.0 + object.entries: 1.1.9 + semver: 6.3.1 + + node-fetch-native@1.6.7: {} + + node-fetch@2.7.0: + dependencies: + whatwg-url: 5.0.0 + + node-mock-http@1.0.5: {} + + normalize-path@3.0.0: {} + + normalize-url@6.1.0: {} + + object-assign@4.1.1: {} + + object-inspect@1.13.4: {} + + object-keys@1.1.1: {} + + object.assign@4.1.7: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.2 + has-symbols: 1.1.0 + object-keys: 1.1.1 + + object.entries@1.1.9: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.2 + + object.fromentries@2.0.8: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-object-atoms: 1.1.2 + + object.groupby@1.0.3: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + + object.values@1.2.1: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.2 + + ofetch@1.5.1: + dependencies: + destr: 2.0.5 + node-fetch-native: 1.6.7 + ufo: 1.6.4 + + on-exit-leak-free@0.2.0: {} + + once@1.4.0: + dependencies: + wrappy: 1.0.2 + + openapi-fetch@0.13.8: + dependencies: + openapi-typescript-helpers: 0.0.15 + + openapi-typescript-helpers@0.0.15: {} + + optionator@0.9.4: + dependencies: + deep-is: 0.1.4 + fast-levenshtein: 2.0.6 + levn: 0.4.1 + prelude-ls: 1.2.1 + type-check: 0.4.0 + word-wrap: 1.2.5 + + own-keys@1.0.2: + dependencies: + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + object-keys: 1.1.1 + safe-push-apply: 1.0.0 + + ox@0.14.33(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.2.3(typescript@5.9.3)(zod@3.25.76) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - zod + + ox@0.6.9(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/curves': 1.9.7 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.3.0(typescript@5.9.3)(zod@3.25.76) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - zod + + ox@0.7.1(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.2 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.0.8(typescript@5.9.3)(zod@3.25.76) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - zod + + ox@0.7.1(typescript@5.9.3)(zod@4.0.5): + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.2 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.0.8(typescript@5.9.3)(zod@4.0.5) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - zod + + ox@0.9.6(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.1.0(typescript@5.9.3)(zod@3.25.76) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - zod + + p-cancelable@2.1.1: {} + + p-limit@3.1.0: + dependencies: + yocto-queue: 0.1.0 + + p-locate@5.0.0: + dependencies: + p-limit: 3.1.0 + + pako@2.2.0: {} + + parent-module@1.0.1: + dependencies: + callsites: 3.1.0 + + path-exists@4.0.0: {} + + path-key@3.1.1: {} + + path-parse@1.0.7: {} + + picocolors@1.1.1: {} + + picomatch@2.3.2: {} + + picomatch@4.0.5: {} + + pino-abstract-transport@0.5.0: + dependencies: + duplexify: 4.1.3 + split2: 4.2.0 + + pino-std-serializers@4.0.0: {} + + pino@7.11.0: + dependencies: + atomic-sleep: 1.0.0 + fast-redact: 3.5.0 + on-exit-leak-free: 0.2.0 + pino-abstract-transport: 0.5.0 + pino-std-serializers: 4.0.0 + process-warning: 1.0.0 + quick-format-unescaped: 4.0.4 + real-require: 0.1.0 + safe-stable-stringify: 2.5.0 + sonic-boom: 2.8.0 + thread-stream: 0.15.2 + + pony-cause@2.1.11: {} + + possible-typed-array-names@1.1.0: {} + + postcss@8.4.31: + dependencies: + nanoid: 3.3.18 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + postcss@8.5.6: + dependencies: + nanoid: 3.3.18 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + preact@10.24.2: {} + + prelude-ls@1.2.1: {} + + process-warning@1.0.0: {} + + prop-types@15.8.1: + dependencies: + loose-envify: 1.4.0 + object-assign: 4.1.1 + react-is: 16.13.1 + + protobufjs@7.6.5: + dependencies: + '@protobufjs/aspromise': 1.1.2 + '@protobufjs/base64': 1.1.2 + '@protobufjs/codegen': 2.0.5 + '@protobufjs/eventemitter': 1.1.1 + '@protobufjs/fetch': 1.1.1 + '@protobufjs/float': 1.0.2 + '@protobufjs/path': 1.1.2 + '@protobufjs/pool': 1.1.0 + '@protobufjs/utf8': 1.1.2 + '@types/node': 20.19.27 + long: 5.3.2 + + proxy-from-env@2.1.0: {} + + pump@3.0.4: + dependencies: + end-of-stream: 1.4.5 + once: 1.4.0 + + punycode@2.3.1: {} + + qr-code-styling@1.9.2: + dependencies: + qrcode-generator: 1.5.2 + + qrcode-generator@1.5.2: {} + + query-string@7.1.3: + dependencies: + decode-uri-component: 0.2.2 + filter-obj: 1.1.0 + split-on-first: 1.1.0 + strict-uri-encode: 2.0.0 + + queue-microtask@1.2.3: {} + + quick-format-unescaped@4.0.4: {} + + quick-lru@5.1.1: {} + + radix3@1.1.2: {} + + react-dom@19.1.2(react@19.1.2): + dependencies: + react: 19.1.2 + scheduler: 0.26.0 + + react-is@16.13.1: {} + + react@19.1.2: {} + + readable-stream@3.6.2: + dependencies: + inherits: 2.0.4 + string_decoder: 1.3.0 + util-deprecate: 1.0.2 + + readdirp@5.1.1: {} + + real-require@0.1.0: {} + + reflect.getprototypeof@1.0.10: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + get-intrinsic: 1.3.0 + get-proto: 1.0.1 + which-builtin-type: 1.2.1 + + regexp.prototype.flags@1.5.4: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-errors: 1.3.0 + get-proto: 1.0.1 + gopd: 1.2.0 + set-function-name: 2.0.2 + + resolve-alpn@1.2.1: {} + + resolve-from@4.0.0: {} + + resolve-pkg-maps@1.0.0: {} + + resolve@2.0.0-next.7: + dependencies: + es-errors: 1.3.0 + is-core-module: 2.16.2 + node-exports-info: 1.6.2 + object-keys: 1.1.1 + path-parse: 1.0.7 + supports-preserve-symlinks-flag: 1.0.0 + + responselike@2.0.1: + dependencies: + lowercase-keys: 2.0.0 + + reusify@1.1.0: {} + + run-parallel@1.2.0: + dependencies: + queue-microtask: 1.2.3 + + safe-array-concat@1.1.4: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + get-intrinsic: 1.3.0 + has-symbols: 1.1.0 + isarray: 2.0.5 + + safe-buffer@5.2.1: {} + + safe-push-apply@1.0.0: + dependencies: + es-errors: 1.3.0 + isarray: 2.0.5 + + safe-regex-test@1.1.0: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-regex: 1.2.1 + + safe-stable-stringify@2.5.0: {} + + scheduler@0.26.0: {} + + semver@6.3.1: {} + + semver@7.8.5: {} + + set-function-length@1.2.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + function-bind: 1.1.2 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-property-descriptors: 1.0.2 + + set-function-name@2.0.2: + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + functions-have-names: 1.2.3 + has-property-descriptors: 1.0.2 + + set-proto@1.0.0: + dependencies: + dunder-proto: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + + sharp@0.34.5: + dependencies: + '@img/colour': 1.1.0 + detect-libc: 2.1.2 + semver: 7.8.5 + optionalDependencies: + '@img/sharp-darwin-arm64': 0.34.5 + '@img/sharp-darwin-x64': 0.34.5 + '@img/sharp-libvips-darwin-arm64': 1.2.4 + '@img/sharp-libvips-darwin-x64': 1.2.4 + '@img/sharp-libvips-linux-arm': 1.2.4 + '@img/sharp-libvips-linux-arm64': 1.2.4 + '@img/sharp-libvips-linux-ppc64': 1.2.4 + '@img/sharp-libvips-linux-riscv64': 1.2.4 + '@img/sharp-libvips-linux-s390x': 1.2.4 + '@img/sharp-libvips-linux-x64': 1.2.4 + '@img/sharp-libvips-linuxmusl-arm64': 1.2.4 + '@img/sharp-libvips-linuxmusl-x64': 1.2.4 + '@img/sharp-linux-arm': 0.34.5 + '@img/sharp-linux-arm64': 0.34.5 + '@img/sharp-linux-ppc64': 0.34.5 + '@img/sharp-linux-riscv64': 0.34.5 + '@img/sharp-linux-s390x': 0.34.5 + '@img/sharp-linux-x64': 0.34.5 + '@img/sharp-linuxmusl-arm64': 0.34.5 + '@img/sharp-linuxmusl-x64': 0.34.5 + '@img/sharp-wasm32': 0.34.5 + '@img/sharp-win32-arm64': 0.34.5 + '@img/sharp-win32-ia32': 0.34.5 + '@img/sharp-win32-x64': 0.34.5 + optional: true + + shebang-command@2.0.0: + dependencies: + shebang-regex: 3.0.0 + + shebang-regex@3.0.0: {} + + side-channel-list@1.0.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + + side-channel-map@1.0.1: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + + side-channel-weakmap@1.0.2: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + object-inspect: 1.13.4 + side-channel-map: 1.0.1 + + side-channel@1.1.1: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.4 + side-channel-list: 1.0.1 + side-channel-map: 1.0.1 + side-channel-weakmap: 1.0.2 + + sonic-boom@2.8.0: + dependencies: + atomic-sleep: 1.0.0 + + source-map-js@1.2.1: {} + + split-on-first@1.1.0: {} + + split2@4.2.0: {} + + stable-hash@0.0.5: {} + + stop-iteration-iterator@1.1.0: + dependencies: + es-errors: 1.3.0 + internal-slot: 1.1.0 + + stream-shift@1.0.3: {} + + strict-uri-encode@2.0.0: {} + + string.prototype.includes@2.0.1: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-abstract: 1.24.2 + + string.prototype.matchall@4.0.12: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-errors: 1.3.0 + es-object-atoms: 1.1.2 + get-intrinsic: 1.3.0 + gopd: 1.2.0 + has-symbols: 1.1.0 + internal-slot: 1.1.0 + regexp.prototype.flags: 1.5.4 + set-function-name: 2.0.2 + side-channel: 1.1.1 + + string.prototype.repeat@1.0.0: + dependencies: + define-properties: 1.2.1 + es-abstract: 1.24.2 + + string.prototype.trim@1.2.11: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-data-property: 1.1.4 + define-properties: 1.2.1 + es-abstract: 1.24.2 + es-object-atoms: 1.1.2 + has-property-descriptors: 1.0.2 + safe-regex-test: 1.1.0 + + string.prototype.trimend@1.0.10: + dependencies: + call-bind: 1.0.9 + call-bound: 1.0.4 + define-properties: 1.2.1 + es-object-atoms: 1.1.2 + + string.prototype.trimstart@1.0.8: + dependencies: + call-bind: 1.0.9 + define-properties: 1.2.1 + es-object-atoms: 1.1.2 + + string_decoder@1.3.0: + dependencies: + safe-buffer: 5.2.1 + + strip-bom@3.0.0: {} + + strip-json-comments@3.1.1: {} + + styled-jsx@5.1.6(react@19.1.2): + dependencies: + client-only: 0.0.1 + react: 19.1.2 + + supports-color@7.2.0: + dependencies: + has-flag: 4.0.0 + + supports-preserve-symlinks-flag@1.0.0: {} + + tailwind-merge@3.4.0: {} + + tailwindcss@4.1.18: {} + + tapable@2.3.3: {} + + thread-stream@0.15.2: + dependencies: + real-require: 0.1.0 + + tinyglobby@0.2.17: + dependencies: + fdir: 6.5.0(picomatch@4.0.5) + picomatch: 4.0.5 + + tldts-core@6.1.86: {} + + tldts@6.0.16: + dependencies: + tldts-core: 6.1.86 + + to-regex-range@5.0.1: + dependencies: + is-number: 7.0.0 + + to-utf8@0.0.1: {} + + tr46@0.0.3: {} + + ts-api-utils@2.5.0(typescript@5.9.3): + dependencies: + typescript: 5.9.3 + + tsconfig-paths@3.15.0: + dependencies: + '@types/json5': 0.0.29 + json5: 1.0.2 + minimist: 1.2.8 + strip-bom: 3.0.0 + + tslib@1.14.1: {} + + tslib@2.8.1: {} + + type-check@0.4.0: + dependencies: + prelude-ls: 1.2.1 + + typed-array-buffer@1.0.3: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-typed-array: 1.1.15 + + typed-array-byte-length@1.0.3: + dependencies: + call-bind: 1.0.9 + for-each: 0.3.5 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + + typed-array-byte-offset@1.0.4: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.9 + for-each: 0.3.5 + gopd: 1.2.0 + has-proto: 1.2.0 + is-typed-array: 1.1.15 + reflect.getprototypeof: 1.0.10 + + typed-array-length@1.0.8: + dependencies: + call-bind: 1.0.9 + for-each: 0.3.5 + gopd: 1.2.0 + is-typed-array: 1.1.15 + possible-typed-array-names: 1.1.0 + reflect.getprototypeof: 1.0.10 + + typescript@5.9.3: {} + + ufo@1.6.4: {} + + uint8arrays@3.1.1: + dependencies: + multiformats: 9.9.0 + + ulid@2.4.0: {} + + unbox-primitive@1.1.0: + dependencies: + call-bound: 1.0.4 + has-bigints: 1.1.0 + has-symbols: 1.1.0 + which-boxed-primitive: 1.1.1 + + uncrypto@0.1.3: {} + + undici-types@6.21.0: {} + + undici-types@7.29.0: {} + + unrs-resolver@1.12.2: + dependencies: + napi-postinstall: 0.3.4 + optionalDependencies: + '@unrs/resolver-binding-android-arm-eabi': 1.12.2 + '@unrs/resolver-binding-android-arm64': 1.12.2 + '@unrs/resolver-binding-darwin-arm64': 1.12.2 + '@unrs/resolver-binding-darwin-x64': 1.12.2 + '@unrs/resolver-binding-freebsd-x64': 1.12.2 + '@unrs/resolver-binding-linux-arm-gnueabihf': 1.12.2 + '@unrs/resolver-binding-linux-arm-musleabihf': 1.12.2 + '@unrs/resolver-binding-linux-arm64-gnu': 1.12.2 + '@unrs/resolver-binding-linux-arm64-musl': 1.12.2 + '@unrs/resolver-binding-linux-loong64-gnu': 1.12.2 + '@unrs/resolver-binding-linux-loong64-musl': 1.12.2 + '@unrs/resolver-binding-linux-ppc64-gnu': 1.12.2 + '@unrs/resolver-binding-linux-riscv64-gnu': 1.12.2 + '@unrs/resolver-binding-linux-riscv64-musl': 1.12.2 + '@unrs/resolver-binding-linux-s390x-gnu': 1.12.2 + '@unrs/resolver-binding-linux-x64-gnu': 1.12.2 + '@unrs/resolver-binding-linux-x64-musl': 1.12.2 + '@unrs/resolver-binding-openharmony-arm64': 1.12.2 + '@unrs/resolver-binding-wasm32-wasi': 1.12.2 + '@unrs/resolver-binding-win32-arm64-msvc': 1.12.2 + '@unrs/resolver-binding-win32-ia32-msvc': 1.12.2 + '@unrs/resolver-binding-win32-x64-msvc': 1.12.2 + + unstorage@1.17.5(aws4fetch@1.0.20)(idb-keyval@6.3.0): + dependencies: + anymatch: 3.1.3 + chokidar: 5.0.0 + destr: 2.0.5 + h3: 1.15.11 + lru-cache: 11.5.2 + node-fetch-native: 1.6.7 + ofetch: 1.5.1 + ufo: 1.6.4 + optionalDependencies: + aws4fetch: 1.0.20 + idb-keyval: 6.3.0 + + uri-js@4.4.1: + dependencies: + punycode: 2.3.1 + + util-deprecate@1.0.2: {} + + uuid@11.1.0: {} + + uuid@11.1.1: {} + + uuid@9.0.1: {} + + viem@2.31.0(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.0.8(typescript@5.9.3)(zod@3.25.76) + isows: 1.0.7(ws@8.18.2) + ox: 0.7.1(typescript@5.9.3)(zod@3.25.76) + ws: 8.18.2 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + - zod + + viem@2.31.0(typescript@5.9.3)(zod@4.0.5): + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.0.8(typescript@5.9.3)(zod@4.0.5) + isows: 1.0.7(ws@8.18.2) + ox: 0.7.1(typescript@5.9.3)(zod@4.0.5) + ws: 8.18.2 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + - zod + + viem@2.42.1(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.1.0(typescript@5.9.3)(zod@3.25.76) + isows: 1.0.7(ws@8.18.3) + ox: 0.9.6(typescript@5.9.3)(zod@3.25.76) + ws: 8.18.3 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + - zod + + viem@2.55.11(typescript@5.9.3)(zod@3.25.76): + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.2.3(typescript@5.9.3)(zod@3.25.76) + isows: 1.0.7(ws@8.21.0) + ox: 0.14.33(typescript@5.9.3)(zod@3.25.76) + ws: 8.21.0 + optionalDependencies: + typescript: 5.9.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + - zod + + webidl-conversions@3.0.1: {} + + whatwg-url@5.0.0: + dependencies: + tr46: 0.0.3 + webidl-conversions: 3.0.1 + + which-boxed-primitive@1.1.1: + dependencies: + is-bigint: 1.1.0 + is-boolean-object: 1.2.2 + is-number-object: 1.1.1 + is-string: 1.1.1 + is-symbol: 1.1.1 + + which-builtin-type@1.2.1: + dependencies: + call-bound: 1.0.4 + function.prototype.name: 1.2.0 + has-tostringtag: 1.0.2 + is-async-function: 2.1.1 + is-date-object: 1.1.0 + is-finalizationregistry: 1.1.1 + is-generator-function: 1.1.2 + is-regex: 1.2.1 + is-weakref: 1.1.1 + isarray: 2.0.5 + which-boxed-primitive: 1.1.1 + which-collection: 1.0.2 + which-typed-array: 1.1.22 + + which-collection@1.0.2: + dependencies: + is-map: 2.0.3 + is-set: 2.0.3 + is-weakmap: 2.0.2 + is-weakset: 2.0.4 + + which-typed-array@1.1.22: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.9 + call-bound: 1.0.4 + for-each: 0.3.5 + get-proto: 1.0.1 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + + which@2.0.2: + dependencies: + isexe: 2.0.0 + + word-wrap@1.2.5: {} + + wrappy@1.0.2: {} + + ws@7.5.13: {} + + ws@8.18.2: {} + + ws@8.18.3: {} + + ws@8.21.0: {} + + ws@8.21.3: {} + + yocto-queue@0.1.0: {} + + zod@3.25.76: {} + + zod@4.0.5: {} + + zustand@5.0.3(@types/react@19.1.12)(react@19.1.2): + optionalDependencies: + '@types/react': 19.1.12 + react: 19.1.2 diff --git a/examples/nextjs-defi-lending-moonwell/pnpm-workspace.yaml b/examples/nextjs-defi-lending-moonwell/pnpm-workspace.yaml new file mode 100644 index 0000000..4ca44b2 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/pnpm-workspace.yaml @@ -0,0 +1,6 @@ +allowBuilds: + esbuild: set this to true or false + protobufjs: true + sharp: true + unrs-resolver: true + workerd: set this to true or false diff --git a/examples/nextjs-defi-lending-moonwell/postcss.config.mjs b/examples/nextjs-defi-lending-moonwell/postcss.config.mjs new file mode 100644 index 0000000..c7bcb4b --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/postcss.config.mjs @@ -0,0 +1,5 @@ +const config = { + plugins: ["@tailwindcss/postcss"], +}; + +export default config; diff --git a/examples/nextjs-defi-lending-moonwell/public/favicon.ico b/examples/nextjs-defi-lending-moonwell/public/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..97ecfed8f228e564a53471821aee6e69c83e9740 GIT binary patch literal 10117 zcmcI~2Uk-~*Y=@ECv>ERA}R_9s3;HwLQ#rRr1v6C0g*r`g7gvrDc(qvmZ(4oU3%ys zpdc7EH0eErW}_2$5BKvv-}eh%*2-d?Ip@smx%RcMy=Ugc8yRS`G6^sN0KlrNqh$;L zRNLV1F9RLea-O@k7W~KPqhsX<0L)ycKPupLE+5!PzSZ>awgu~=%Hxp@VgI8v{I?^TrJnQ zvg#P!{xKJ|q$0kPeo1%ELNxe{{zgQ;3zM}%OA7s2PTixX@N@IRYQHF1X7R6d{LS4j zg^hj@3FH6={=fetAk-r=RHg|{^Y`2a&K(y^)Z9+BI@~v2dYAPN*CGDW(&Ds=()0|2 z1U0cEzxlW6^2SrC!dzzSquUxvhm_rtkL{Yzc+C==LxjU$XNc!(2B~A;av0u3?hIID zkJ>AV6ufsZ?SA%b%x!_$&mb<4`()ag^`PKQ&wY&V-?acm-dVbxBTASg^RK3T&ljst zS+9wF4>rFOC=_1#b}xj&Ta@tD;Y3`BDOFShTKDvb&5n?N)EXS0Agxn_%k<*!4>w3R zLB-s{=^fq6r%U?c^!;(sFrxu#3-m@3?=1R}G6_UlR0i_8!GG3`owU9hG-y_$4$My}|AtL)PbT~wK zsN2>-|GlIL0UB@6 zfy8qMvw`(&(aF$~ozGtulRRwQc9VRxr5OBeJrQ;eg?M-S=(McOCu%K_oG6zoh5Fj%hN?CBKeh81DY771UWj+aj2|`HSWF^7A&uvDd*;9nTrIA-If*yHjgH zu1E>{szIlL6}K{8C!v_&KIFRSx3Q?026~&hSoBS=eU_Nvb1!0yww}Lu9dxhj{$NR6uD%h8vnU&j1AnG2b4WDC)HrfL0i|Ww60^Rc`qs53=(iIz3@mb`pI5^h5 zV&-Evb*O=yOjM|j-DbFvM17>(B@Gp4#MbY4+E7D()6%q6cH!eSe?`v81fDlPpi>2m zY)Wv{1b3A5_|%Lg6w%chR^wo%M!8ZE!Qky8a%n(AjXBc3cz?!lyC&3=^Du+DE8L`mY>Fym*Q+ zu$Rcx9N*NX=24d6ASYKZX6G*K`Gyi=Go>a}9>vT4?v5^>$DsdMh6VQ1J*Wb2D>1`9 z*@ic-T#w9$90pd`PKU^nZfQ)3c{W+?JV5)oUQ!w!sI&fO=zIF%ieJ<_Y#dJ%GzNct z_*I>8Anm7bjeSQ!`UQG!IQNvp6PQP8bRcjKXHy*=QC!w++~Lg>wa@ZZho80lx>xmC-y`tiV;E+N`qHy zE|NGUw_~m@^(zfeu}zpr%^UgK87scXJ|nqffH5{CrWakK#cSho>}jUFEohT?V3GOs z;4LvCmx~#v-Mo-8+h111^9i2pgwD3wkp;9febrGupQofrhOMCQfFIhgOC=;WCf%W- zt3uQ!CRoF3JWcXbWg|Uh-qEvvN+`s-Er7W*UqM5KV^V!rzs{D@sM0DvYKncGt4BzP^L)ZW*Q(!(H4ZWtd`*Am7Cj7g6~P*%B0g#Iguh%N)DKFU zRPWoy)$r_ib2e&Y8=gn&ZbB)y7W{q-fKSp#sc^*v-z9Ob*pw02w!Xxmge5A*W7Mdj zG}sD-A3NxdD?3D+j?VKdxezx@3CkVi;x>&mmMG{>pVlw@y`qH)w{?py_+-6Tf*LBG z)xZ`_oyo9GhmiZEG&~r+aXCh$12Tv{(J-sWajk288=oRu1y^js== zxL@2BZCuG{H=oPwdrrVy%_}w(aWO3QSrKmYPFokhWWZU5Z2`HqZ%Td9R*KD$H?JnD zgvK0Xfn(>a)mP?DbT_T*<4$b(1v~wDvI<=wOgKLhw^}(rVtBcKrsHI&opKoJI z#nD!{a^Z4si_eUy`Ji{4z6;$iVS5hW9o%rtNGunohOXkwU-FH=rqc)oXz_jq^fgt( zG}^e52-?F%4ssy&M;j+8Olf0bC`L`uMcgKP{if4;$qYK&|D!NLf;w~l{dQt>`Q^Y3 z6D$5GcQMjX=URzbrxrVTbXKM+{ASkD!p`4hMa@h_mq^uLT$S*N^q#U!9=11PnX_!W93TUI}ghjscVltK7#yMiF>gF^D3I5|? z@Db!p(%Mn_&4b2Myf&g;tV}~ES7<-l9{t4cHtc<778qSMDsDoB$k5kFSFCcW>b!CG z0zM0e&gYDd8#!2yy36nW900*O6utZ=gcb&S2#zqgwwMnaRLS*&WyP*QutI%oi)<~S zqPuVW(qXdZGc6Fexh5K!uM%zQc}&|lo3pa!?H~)C!hoMN2OkvPT_4!mc~EGR=?tN- zF}0gF@Hf28OWVOl;&NzT*UURx8ZJy<^LGoq1+pY!;;Vm!xfKewp+Nbgm=#-ets|9T z=ZA|Rxy3T?Kg08}Zn&(ybjAL8;6JqL$oqqpW&xA8zV}|4Vt_t$d+gvGd)#4zwlU$S zhVrp(xb$V3VJ#@NjL3$T9Yp)OfexBx;Z5Fp)_bck_tozTm5~M}{AiB8*zR3*ruSGP zf9hQRmriL~7~vIJ?~>h0+=}XHTh3^wG%}t>z};?ThgK8OdgL9FjU(eOGgkP3R=VAR zHwp;ODaWl*Vy-ZgV#Eis$pjxdi^_DMg%1#7d zf-?JZo_LN=yt@J3`1HDNLoSLE{7JT5wqiBMaz*9r-U7%Kk#kgMlR=%JpANQ_zp|>= z>hV(@-Mkne#~cX>x^H*2aBZ^TA69>6q?sK@<3f-ev)w%4uzaE@HNzltq3LMopJoSP znmidq#1r+diRkj58mab$Vbe;_;eq6jHt6pcAU_SA-3b1hw#MnO!|V#^Q^C&~Cj6qZ z^2NHBh>XZSA&8q8A@Y`gtCBt^2K0<;v=yYj*!FQI;R5924_%fW`e_Jx#C1LdoVPPB zXPO!u3%&!J%5{5_4*NrZ`hmEvu##RG+$_$vEcE8#lC>-rqQjRn{A!`fGoJE#nVhXt zXut6Y7slJ@9BtLIjc`w-CsnW`S7x_~IHcBEI)1~?H01Tqo-IdS5GQDnfH@wCY8}?g z^VBj>0zG6mKmTnaXhcGBG4S7)`b=&HJW9I za{49V@-;o%-cVVeP8-w(x;3@^Sb6p_)`-fe#uyQ|zg$oOqU|9SeSC;$xA#WW;JsedTR_;h@*GcQO@$G)Gix=1`(pVDAr;;)LIwt|EaT zDp|GcH&ww(cK)MfI&Amr_m!)JL%Vs!w^WYrO%;SIS4|Kui~ow&q_*Mo*Du%SB1``@ zA|^<16!z`6^62QdvnM^my>N#e`LYNZ1i-npjGNHGv^AO^XI8D}%YaznG%pJ^(x#Rz z93qykZ)-dvEd|;HoTXN=0)z2`J6R%&{^sV;*8zLRS-i5jUf9Y6#k>`27FIV*I~B0S#3P+Nep?JfZnrW(_u)d6Fvpn{=nz%zy;!{^>An5Zo%UNf*|n zv^u^4t*@pLuW$cAs|G;*uR*)I!}Up%-;>gVF>P)i-E{qT9ZQ2qmkH%}g(4y7Za0ai z!y7;JT4zKT+iAJL$ONN)l0^wDNq}byq~m)JTQ4=&8&?LmIQyC^Fd_k;$Hyr(@3*;r zjiT`6D93BLtZpUv4;&=mXS6O$_`VqN>}Z=RhdqJIDcZ_b-}(?G1DY9R56lMR1n+vb zj+onrGiV2y_v@rF$?~@6DW(}|WgAj}qbOL# z*CEaw=NL6CnMzjjf?}-!V#(LzCD`rI#^`?~wt4l+FU2g^ufc*`BtQ<=i)w!+Nd9NK zV^`?u+Jbk1bZLF%8}Ev7DtN+c;bY(NXK``YH-7SwMlQ&NeWF(du<=s?9`inbT?_5w zgk?9Dn*=^T5c&H69nMP)1w33O<`YIv%3}wM4~+lj1-K`u+2v2B^?1lB zBTC!T4DO+m<#%m)NPi`Ph!HI558nEdIYzivK?0ju13%60W~USdtcyAAhpXGe+Kz<5 z+AXOprMZ;pKU8V^1EgX+!tHuZWAPcL?sZl5l~)N<+XyhYfp?B!h}H%%XRJnE+SU!y zE@GFP^q>B|VdjPvxu%M~gr``RlsamST&Q?ewO*LgY*$cq+>Q7Y3T}|-?&C%>Y=l2D z4DAwcR2`|lNvyB5r*56Ou*qe?Ms;}fXfW`S4;pPIM!|3eA`ENV3(`k40-RHyxb24;4S|86?4ztKm?L|MWF)n zn%3qgco=LFD%1tKhaQ$o5dW4`ny|NO< z4E|5<{;Uu8*0gF_FUV;`9mm1x0pe=-I|a2+itK7LUuNZb*I&`viZg0~UyXV#M+?-3 z7Fka*@=uf+Q8Ops;c|#-cv(_Exml>0TMe)LS280ma{tcs`Ce%j+GpZrB2emQh?-;3 zcLf0b8h)9cq;{;6$v5A3Vz#55 z<|G6k7-lwnA-U)p5Rn1qAU8yL16TWYiTvjx+?gxRS%-XS!Fh%Lp+z`vgC!c^_f?gT z3VDOvU$*jAWfA;sFZpMbVw$RD5PD$u9WgAXB{{LId98uCt%Xd(cNgnF3uo@kgpM%@ z+k6juOXidyyQQ)KqRJ99sDs#^%vM%LXJk%|fluKk-Q}Iu&1{F;VD!MxC8Hqzeqp=# zNe0eiT(s@zd(pE~Y_8RZ-wl0h+c}=41a7R&s5eM?CVAZj068op%y0`=D}z3vA9V@}g!r2uRo$0@v@81YsNaSs9shx)F|v_OQ` zy+;TwEL&$qnVG)ptJ6TLjggyIZ<3ks7XU}gz zRA1ilnx6y!l`@&r`o&WIHr^@2`-gm_ zx}>x-0Q!m;N#X5)a>xPYml{%x?!dhSp?V7d9=~5Lo;j*RvQNzcz;q9w1{;$Uwxu)~ zTxqunRAfao*(pvzfS*?$?r)+B(vq=|?s#vx7iWN3JC>~l%fgfPt#H*tJ<5C7%BB(^ z%2lm5)3UR2!P(4RaYDHmMi02m7fDXJSd~nC+Ie66L@T?D4){2rZx+1m`Oiz-;97P| z{M`*HY5?x$UHVO*H$8Y*Yx!P2C9Kz284z_a5tE+TS=-d4e8pEBg?WUm{Pm&-7NuyX z_D9#|N%dO@L2~_*3YE~Fk^lg{={2tMs%P15W<`c5+tsqpu?$3bS9K%Wy$wZX_Cx1C zxVp-`7X<*M77LjYUH;%{>XtsA&W2m=A+IOX@@1rGD{aHTW}+`+30;Gm=9k9MO+O-j3uRJbaMUv~SKwyGr^ z=8}~FAi5x+eR<2%!t7;u`cr0KR$8!aMoRwHk-xG~f2wsQFiauJID+20RG~A`Un_q;TV;FeO2u}-yxO!06(CB3TO#*utU@0d`KBMl)@08= zJ^J`{te77Fthp@EIS^!;SE09XJ5h=CK=(EncR-4VmyBQLJIyKfbpU9vW~NyKFEUZ;BuSj9`^Vh(_|giPDaKlft>hM zV}Q6!iw9|l5}f-`Gzpp#5zpZJ?atb$Q=?s2yW`-aehoE06ciu`Fe4e+a)gGiF*T$g zoDp=ec;y6I@G!ERy_k>G8;Z^0TSuK4d<33N)xaCdXSivmTsX)V=?)=*V^n~C69dvl zEJLel#^hxBZ6;Wi#khlbhbC`=dxM99b6T7k`h{V03p+$Vjwx{RWHf$Fj4)X1Lh>pK z3fsCD&XN9<3UJg?-=0!8lRikbEA(E6H0M2EfhYrxF1Vb0>M56o;;{57r&08XL4W}O z@EJ)yc0i^3V{=a3ezNrJjS?#`YcOJ3B<=8yc)^=*9EFePIn?9-+X|95O{@6>tM~xu z(Q#;ijUIShRpI1bm2mCWPa#qf7seac%JKR;0JJS&NE=2 z9)S!$2ITi9BZb7ZC3nyh@Rg030>)C|*ZnM#1IyO~m732A59N~GEAUis?UK!~v3%>7 zpOJ2c6iH75=R*nkVyXy;@zm$51bvCj8Cf3?ZrJiIg2H)|Jc$3Fy+WB+VsxOIc;c3D zqea)E$&0@a&Dy@&%879IGl0sCBm&7UjBLO$diBXN| zshc)93Lgg}>E6Awr=5Y@p1EMIJ*9q{CVD2>NF-{|Nw&Z0vrqt#_55vtdlwBg#VzI_ zRc5n_YaJk*8@5~HY!FG5>P#9l5xMV=viqBc{mcZQuY#oM1c}v|hb3y8PC3ca_>EDa zb#Xbg2eS;@SI3|Mp24C(#E-A0Zb9H?F0P3F)E@@~Q#Y6OlF=CDb-;+`b^nW4qsp(} ztRF2{pQQ!ldST2oh`$j zd>X$u>A2_tGn4~IimTD(pPq2cGA-~#$RYb5GG@lN&Di&>l#%wjf|1gtkUi7F?;=*x>6#h3ekY5*PBO>2{EN>T@k0s&9zOh7NQo6bPJ3{}n|>C%IX9vaXf zZIAvKq668|gO^XQ4B12PhgNB?u#=&1KLND(IwaVtZ59$7Sba221-=gJptkGMq;8$S z5|yKr*WqoA(aFp)!6^21co+lHw&!;UijYh9@h;0>&DZ_2l9Jnyg#XpnpLhK;l}LNS z>B00phTF;kOSgeNq$)_8h%In1(1RT%f8aChvjWoXfkGfiYNi8b6=icbV_+_b^2tQC zTO7b6CST)MPDrUy*^6=N|{jYDNixI9eNcx+CA@dHUOyc8Bhe_^y ztI9;RYSF@(l0h?_ILM7!egdK#xaM8=u5J*Og4-;yOMyqCGCi`d5SQ(NS{ZDcGX!?$ zc44x}Sfmgr^jv7XF4|ehl-&4reqcH-=BFMYKcuQ-p^u5U%1&VqB4mVM%KbE7=X!k zaa}lYEK&ga)s#+Olz5e$IRG5DZmi+-nb#fpu($^sF5szcVt*OH#}r8TDlh5J(t~3b zlu;j5a@3hr*Jft$XBmX-aJz!cmILW}>=fdm84<@p=F=@33oQH14k#o_S>u)@^<4?P zJH)HJ_#vv%1qke7q*31(2}b`cQHgYVlLE44e%W=Pv{ALEn_?>k>roNS#t7-NPX z!mK?=M}CAN?{TKXJe&i^ZjdB+vboUCAgbI(C2wz<=MnrNc^{z2^HF-xy0>dW_!uRU z4kIS{&MoWF{YIgEs|eex^iakJ`_LpTeyHbcKEVI}%03W@Jaxa+-p@;N>--2Wiqt{ff@IyE7ktHG!tnmrdI5RB7@WmlSfXI!zzqE zurV5zJa~mP19RH5Bt@m=yHh}|3VKcbG4pFZ5A#B$9Bs`L3!5L zEizM9%Bk*lX+RZsRDgao-S*%n3&1Y_KW$$tUaT_as z7u*kBk(^5sWtMKBi54TiEbo)`$4DbnHvPi34I3)IZSwH3V3NxaOM`WkLono*0vvr} zVDGi7l(`nqW4+%`LRdhIB&5Aa>#ZiCBJI!4>5SjU3?u8DspRA}pm|-N_F}#^L-_m;Fx(&3K15$+GIe*!7yl_+XQFHB>j;iOLBZK zL)AU8Ly^lyB{W@B_?t#~G=p!A>EHY@8Fk7I-Ejl2H_*oP6^;e1_NFWFW(NORf&b>5 zJ6wxedZB%-erUTGm`}82UF8QHg~#mB$4kqj9j3+$l%FF;+Kl-=4FFe# z7n6EOd*&1BI@!yY=W;fPP*Q&jisPO$C7womGcqO376xp$J2%u`(HPgk*jOg3Cu z{;Wc&Qdu;heD@_X7nOz~=aY=+dx`NrTc~|XK|;fN4$Ugq$?HYF&6SYlC7FTs2(}oQ zQ4QZFv#XJ(?H{e&c|d5E3j>jV2Q!jb(qot_L6N7TY_(4I|JZng;aY_*?%x*;?D@;YY_6>dUuX&8>~~G0eey{qqe4VgH0m z`ijbeHanU3cwV|PxpF?nfy@-l{IgNghuid|9HS_0nvCs@Y~dioqw+x~X3Ac3pvz8j zx@E(=luLPb$$9MT@65!lL=0t%yfS=Han{^lWFnm5$^ZR#WTzvb(~i$lY~)F63I5<} P0^AP1ZJ<@5;TZKlOlsI@ literal 0 HcmV?d00001 diff --git a/examples/nextjs-defi-lending-moonwell/public/logo.svg b/examples/nextjs-defi-lending-moonwell/public/logo.svg new file mode 100644 index 0000000..4f3b3bb --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/public/logo.svg @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/examples/nextjs-defi-lending-moonwell/src/app/error.tsx b/examples/nextjs-defi-lending-moonwell/src/app/error.tsx new file mode 100644 index 0000000..18e3459 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/error.tsx @@ -0,0 +1,27 @@ +"use client"; + +/** + * Route-level error boundary. Without one, a render-time throw drops the user + * onto Next.js's blank error screen — possibly while a transaction is in + * flight, taking the on-screen hash with it. + */ +export default function ErrorPage({ + error, + reset, +}: { + error: Error; + reset: () => void; +}) { + return ( +
+

Something went wrong.

+

{error.message}

+ +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/app/globals.css b/examples/nextjs-defi-lending-moonwell/src/app/globals.css new file mode 100644 index 0000000..5c4b6d7 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/globals.css @@ -0,0 +1,28 @@ +@import "tailwindcss"; + +/* + * Dynamic's example palette, shared with the other recipe apps in + * dynamic-labs-oss/examples (see nextjs-defi-lending-morpho). + */ +@theme inline { + --color-brand: #4779ff; + --color-chip: #e8f0fe; + --color-chip-ink: #1967d2; + --color-ink: #030303; + --color-muted: #606060; + --color-line: #dadada; + --color-surface: #f9f9f9; + + --font-sans: var(--font-roboto), system-ui, sans-serif; +} + +@layer base { + body { + @apply bg-white text-ink font-sans; + } + + /* Figures align in columns without changing typeface. */ + .tabular { + font-variant-numeric: tabular-nums; + } +} diff --git a/examples/nextjs-defi-lending-moonwell/src/app/layout.tsx b/examples/nextjs-defi-lending-moonwell/src/app/layout.tsx new file mode 100644 index 0000000..e4c4ff9 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/layout.tsx @@ -0,0 +1,39 @@ +import type { Metadata } from "next"; +import { Roboto } from "next/font/google"; +import Providers from "@/lib/providers"; +import Navigation from "@/components/Navigation"; +import Footer from "@/components/footer"; + +import "./globals.css"; + +const roboto = Roboto({ + subsets: ["latin"], + weight: ["300", "400", "500", "700"], + variable: "--font-roboto", +}); + +export const metadata: Metadata = { + title: "Earn Yield by Lending on Moonwell with Dynamic", + description: + "Supply and withdraw USDC on Moonwell (Base) using Dynamic embedded wallets", +}; + +export default function RootLayout({ + children, +}: { + children: React.ReactNode; +}) { + return ( + + + +
+ +
{children}
+
+
+ + + + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/app/lend/[mToken]/page.tsx b/examples/nextjs-defi-lending-moonwell/src/app/lend/[mToken]/page.tsx new file mode 100644 index 0000000..8aa5a24 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/lend/[mToken]/page.tsx @@ -0,0 +1,165 @@ +"use client"; + +import Link from "next/link"; +import { notFound, useParams } from "next/navigation"; +import { ChevronLeft } from "lucide-react"; +import { BalanceDisplay } from "@/components/BalanceDisplay"; +import { SupplyWithdrawForm } from "@/components/SupplyWithdrawForm"; +import { Badge } from "@/components/ui/Badge"; +import { Skeleton } from "@/components/ui/Skeleton"; +import { TokenIcon } from "@/components/ui/TokenIcon"; +import { BASESCAN_URL, MUSDC_ADDRESS } from "@/lib/constants"; +import { useBalances, useMarkets } from "@/lib/hooks"; +import { + assetDisplayName, + findMarketByMToken, + formatApy, + formatUsd, +} from "@/lib/moonwell"; +import { useWallet } from "@/lib/providers"; + +export default function MarketDetailPage() { + const params = useParams<{ mToken: string }>(); + const mTokenAddress = params.mToken; + + // Supplying is wired up for the native USDC market only — see the note below. + const isUsdcMarket = + mTokenAddress.toLowerCase() === MUSDC_ADDRESS.toLowerCase(); + + const { evmAccount } = useWallet(); + const { data: markets, error: marketsError } = useMarkets(); + const { + data: balances, + isLoading: balancesLoading, + error: balancesError, + } = useBalances(isUsdcMarket ? evmAccount?.address : undefined); + + const market = markets && findMarketByMToken(markets, mTokenAddress); + + // Only 404 once the list has actually loaded — an unknown address is a real + // miss, a pending fetch is not. + if (markets && !market) { + notFound(); + } + + // A failed markets fetch would otherwise leave the stat skeletons up + // forever; say what happened instead, like the list page does. + if (marketsError && !markets) { + return ( +
+

+ Could not load this market: {marketsError.message} +

+
+ ); + } + + const stats = [ + { label: "Supply APY", value: market && formatApy(market.baseSupplyApy) }, + { + label: "APY incl. rewards", + value: market && formatApy(market.totalSupplyApr), + }, + { + label: "Total supplied", + value: market && formatUsd(market.totalSupplyUsd), + }, + ]; + + return ( +
+ + + All markets + + +
+ {market ? ( + + ) : ( + + )} +
+ {market ? ( + <> +
+

+ {market.asset} +

+ Base +
+

+ {assetDisplayName(market.asset)} +

+ + ) : ( +
+ + +
+ )} +
+
+ +
+ {stats.map(({ label, value }) => ( +
+

{label}

+ {value ? ( +

{value}

+ ) : ( + + )} +
+ ))} +
+ + {isUsdcMarket ? ( + <> + + + + ) : ( +
+

+ This example only wires up supply and withdraw for the USDC market. +

+

+ Every other market is listed read-only, with live rates straight from + the Moonwell API. +

+ + Go to the USDC market + +
+ )} + + + {mTokenAddress} + +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/app/lend/page.tsx b/examples/nextjs-defi-lending-moonwell/src/app/lend/page.tsx new file mode 100644 index 0000000..e27b775 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/lend/page.tsx @@ -0,0 +1,54 @@ +"use client"; + +import { MarketRow } from "@/components/MarketRow"; +import { Skeleton } from "@/components/ui/Skeleton"; +import { useMarkets } from "@/lib/hooks"; + +export default function LendPage() { + const { data: markets, isLoading, error } = useMarkets(); + + return ( +
+
+

Markets

+

+ Supply assets to Moonwell on Base and earn interest. +

+
+ +
+ Asset + Network + Supply APY + Total supplied + +
+ + {isLoading ? ( +
+ {Array.from({ length: 8 }).map((_, i) => ( +
+ +
+ ))} +
+ ) : error ? ( +
+ Could not load markets: {error.message} +
+ ) : ( + markets?.map((market) => ( + + )) + )} + + {markets && ( +

+ {markets.length} active markets. Deprecated markets are filtered out — + including the legacy USDbC market, which reports the same{" "} + mUSDC symbol as native USDC. +

+ )} +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/app/page.tsx b/examples/nextjs-defi-lending-moonwell/src/app/page.tsx new file mode 100644 index 0000000..ee9d1fd --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/app/page.tsx @@ -0,0 +1,5 @@ +import { redirect } from "next/navigation"; + +export default function Main() { + redirect("/lend"); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/BalanceDisplay.tsx b/examples/nextjs-defi-lending-moonwell/src/components/BalanceDisplay.tsx new file mode 100644 index 0000000..f297268 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/BalanceDisplay.tsx @@ -0,0 +1,63 @@ +"use client"; + +import type { Balances } from "@/lib/hooks"; +import { formatUsdcAmount } from "@/lib/moonwell"; +import { Skeleton } from "@/components/ui/Skeleton"; + +/** + * Wallet balance next to the supplied balance. The supplied figure is derived + * from the mToken balance and the current exchange rate, so it grows with + * accrued interest without any extra bookkeeping. + */ +export function BalanceDisplay({ + balances, + isLoading, + error, +}: { + balances?: Balances; + isLoading: boolean; + /** Message from a failed balance read — distinct from being signed out. */ + error?: string; +}) { + return ( +
+
+

Wallet balance

+ {isLoading ? ( + + ) : ( +

+ {balances ? formatUsdcAmount(balances.walletUsdc) : "—"} + USDC +

+ )} +
+ +
+

Supplied

+ {isLoading ? ( + + ) : ( + <> +

+ {balances ? formatUsdcAmount(balances.suppliedUsdc) : "—"} + USDC +

+ {!balances && + // A failed read is not the same as being signed out — never ask + // a user with a live position to "sign in" over an RPC error. + (error ? ( +

+ Could not read your balances: {error} +

+ ) : ( +

+ Sign in to see your position +

+ ))} + + )} +
+
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/Login.tsx b/examples/nextjs-defi-lending-moonwell/src/components/Login.tsx new file mode 100644 index 0000000..a35d03a --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/Login.tsx @@ -0,0 +1,110 @@ +"use client"; + +import { useState } from "react"; +import { ChevronLeft, Loader2 } from "lucide-react"; +import { useSendEmailOTP, useVerifyOTP } from "@dynamic-labs-sdk/react-hooks"; + +const INPUT = + "w-full px-3 py-2.5 text-sm rounded-lg border border-line outline-none focus:border-brand transition-colors"; + +const SUBMIT = + "cursor-pointer w-full flex items-center justify-center gap-2 text-sm font-medium py-2.5 rounded-lg bg-brand hover:bg-brand/90 text-white transition-colors disabled:bg-line disabled:text-muted disabled:cursor-not-allowed"; + +/** + * Headless email-OTP sign-in. The JavaScript SDK ships no modal, so the whole + * flow is two mutations: `useSendEmailOTP` returns the `OTPVerification` handle + * that `useVerifyOTP` needs, and the code goes in as `verificationToken`. + */ +export function Login({ onDone }: { onDone?: () => void }) { + const [email, setEmail] = useState(""); + const [code, setCode] = useState(""); + + const { + mutate: sendEmailOTP, + data: otpVerification, + isPending: isSending, + error: sendError, + reset: resetSend, + } = useSendEmailOTP(); + + const { + mutate: verifyOTP, + isPending: isVerifying, + error: verifyError, + reset: resetVerify, + } = useVerifyOTP(); + + const error = sendError ?? verifyError; + + if (!otpVerification) { + return ( +
+

Enter your email

+ setEmail(e.target.value)} + placeholder="you@example.com" + className={INPUT} + onKeyDown={(e) => e.key === "Enter" && email && sendEmailOTP({ email })} + /> + + {error && ( +

{error.message}

+ )} +
+ ); + } + + return ( +
+ +

+ Code sent to {email} +

+ setCode(e.target.value.replace(/\D/g, "").slice(0, 6))} + placeholder="Enter 6-digit code" + className={`${INPUT} font-mono tracking-[0.4em] text-center`} + /> + + {error && ( +

{error.message}

+ )} +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/MarketRow.tsx b/examples/nextjs-defi-lending-moonwell/src/components/MarketRow.tsx new file mode 100644 index 0000000..6ea4360 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/MarketRow.tsx @@ -0,0 +1,62 @@ +"use client"; + +import Link from "next/link"; +import { Badge } from "@/components/ui/Badge"; +import { TokenIcon } from "@/components/ui/TokenIcon"; +import { + assetDisplayName, + formatApy, + formatUsd, + type Market, +} from "@/lib/moonwell"; + +/** + * One row of the market list, laid out like the moonwell.fi markets table. + * + * The whole row is the link — "View Market" is a visual target inside it, not a + * separate control, so there is only ever one anchor per row to tab to. + */ +export function MarketRow({ market }: { market: Market }) { + return ( + +
+ +
+

{market.asset}

+

+ {assetDisplayName(market.asset)} +

+
+
+ +
+ Base +
+ +
+

+ Supply APY +

+

{formatApy(market.baseSupplyApy)}

+
+ +
+

+ {formatUsd(market.totalSupplyUsd)} +

+
+ +
+ {/* A span, not a link: the row is already the anchor, and a nested + interactive element would be announced twice. */} + + View Market + +
+ + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/Navigation.tsx b/examples/nextjs-defi-lending-moonwell/src/components/Navigation.tsx new file mode 100644 index 0000000..14a7d8f --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/Navigation.tsx @@ -0,0 +1,38 @@ +"use client"; + +import Link from "next/link"; +import dynamic from "next/dynamic"; +import { usePathname } from "next/navigation"; +import DynamicLogo from "@/components/dynamic/Logo"; + +const DynamicButton = dynamic(() => import("@/components/dynamic/DynamicButton"), { + ssr: false, +}); + +export default function Navigation() { + const currentPath = usePathname(); + const isActive = currentPath === "/lend" || currentPath.startsWith("/lend/"); + + return ( +
+ + + + + + +
+ +
+
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/SupplyWithdrawForm.tsx b/examples/nextjs-defi-lending-moonwell/src/components/SupplyWithdrawForm.tsx new file mode 100644 index 0000000..a21c370 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/SupplyWithdrawForm.tsx @@ -0,0 +1,282 @@ +"use client"; + +import { useState } from "react"; +import { formatUnits, parseUnits } from "viem"; +import { Loader2 } from "lucide-react"; +import { BASESCAN_URL, USDC_DECIMALS } from "@/lib/constants"; +import { + useLendingOperations, + type Balances, +} from "@/lib/hooks"; +import { useWallet } from "@/lib/providers"; + +type Mode = "supply" | "withdraw"; + +/** Parses user input, returning null when it is not a usable amount. */ +function parseAmount(value: string): bigint | null { + if (!value.trim()) return null; + try { + const parsed = parseUnits(value, USDC_DECIMALS); + return parsed > 0n ? parsed : null; + } catch { + return null; + } +} + +export function SupplyWithdrawForm({ + balances, + balancesError, +}: { + balances?: Balances; + /** True when the on-chain balance read failed, as opposed to still loading. */ + balancesError?: boolean; +}) { + const { evmAccount, loggedIn } = useWallet(); + const { tx, reset, approve, supply, withdraw, withdrawMax } = + useLendingOperations(evmAccount); + + const [mode, setMode] = useState("supply"); + const [value, setValue] = useState(""); + // The Max click is remembered explicitly: the supplied balance grows with + // every exchange-rate tick, so inferring "max" from an equality check goes + // stale within one 5s poll and would silently leave dust behind. + const [isMax, setIsMax] = useState(false); + // Set when an approval was mined but the supply chained onto it failed, so + // the user is told an allowance is now standing rather than left to guess. + const [approvalStands, setApprovalStands] = useState(false); + // Held for the entire submit flow. tx.phase alone cannot drive the disabled + // state: between the approval resolving ("success") and the chained supply + // dispatching ("pending"), no phase is in flight — the button would re-enable + // for a moment in the middle of a flow the user cannot safely re-enter. + const [isSubmitting, setIsSubmitting] = useState(false); + + const amount = parseAmount(value); + const maxAmount = + mode === "supply" ? (balances?.walletUsdc ?? 0n) : (balances?.suppliedUsdc ?? 0n); + // Only meaningful once balances have loaded. Before that the form disables + // submission below without claiming anything about the user's funds. + const exceedsBalance = + balances !== undefined && amount !== null && amount > maxAmount; + const needsApproval = + mode === "supply" && amount !== null && (balances?.allowance ?? 0n) < amount; + + const isBusy = + isSubmitting || + tx.phase === "switching" || + tx.phase === "approving" || + tx.phase === "pending"; + const canSubmit = + !isBusy && + amount !== null && + !exceedsBalance && + loggedIn && + balances !== undefined; + + const setMax = () => { + setValue(formatUnits(maxAmount, USDC_DECIMALS)); + setIsMax(true); + }; + + /** The submit button doubles as the progress indicator for the transaction. */ + function submitLabel() { + if (tx.phase === "switching") return "Switching to Base…"; + if (tx.phase === "approving") return "Approving USDC…"; + if (tx.phase === "pending") { + return mode === "supply" ? "Supplying…" : "Withdrawing…"; + } + // Between chained steps no phase is in flight but the flow still is — + // keep the in-flight label rather than flashing the resting one. + if (isSubmitting) { + return mode === "supply" ? "Supplying…" : "Withdrawing…"; + } + if (needsApproval) return "Approve & Supply"; + return mode === "supply" ? "Supply" : "Withdraw"; + } + + function successLabel() { + if (tx.action === "supply") return "Supply confirmed."; + if (tx.action === "withdrawal") return "Withdrawal confirmed."; + return "Transaction confirmed."; + } + + const clearInput = () => { + setValue(""); + setIsMax(false); + }; + + const handleSubmit = async () => { + if (!amount) return; + setApprovalStands(false); + setIsSubmitting(true); + try { + if (mode === "supply") { + const approving = needsApproval; + // Approval and supply are one click. The error is already on screen if + // the approval itself failed. + if (approving && !(await approve(amount))) return; + // A supply straight after an approval may simulate before the new + // allowance is readable. Retrying the simulate absorbs that rather than + // making the user press Supply a second time; without a preceding + // approval an allowance error is real, so it surfaces at once. + const supplied = await supply(amount, approving ? 20 : 1); + // The amount is only cleared on success: after a failure the user needs + // it on screen to retry, next to the error explaining what happened. + if (supplied) clearInput(); + else if (approving) setApprovalStands(true); + return; + } + // A "withdraw everything" request redeems the mToken balance outright so + // no dust is left behind by an exchange-rate tick between quote and mining. + const isFullWithdrawal = isMax || (amount === maxAmount && maxAmount > 0n); + const withdrew = + isFullWithdrawal && balances + ? await withdrawMax(balances.mTokenBalance) + : await withdraw(amount); + if (withdrew) clearInput(); + } finally { + setIsSubmitting(false); + } + }; + + return ( +
+
+ {(["supply", "withdraw"] as const).map((tab) => ( + + ))} +
+ +
+
+ + +
+
+ {/* + A text input, not `type="number"`. A number input renders its value + through the browser locale, so "4.000045" displays as "4,000045" for + a comma-decimal user — indistinguishable from four million in an + amount field. It also mutates the value on scroll. The pattern below + accepts digits and a single dot with at most six decimals — USDC's + precision — so `parseUnits` never silently rounds what was typed. + */} + { + const next = e.target.value.replace(",", "."); + if (next === "" || /^\d*\.?\d{0,6}$/.test(next)) { + setValue(next); + setIsMax(false); + } + }} + placeholder="0.00" + disabled={isBusy} + className="tabular flex-1 py-2.5 text-sm bg-transparent outline-none" + /> + USDC +
+ {exceedsBalance && ( +

+ {mode === "supply" + ? "Amount exceeds your wallet balance" + : "Amount exceeds your supplied balance"} +

+ )} + {loggedIn && balances === undefined && ( +

+ {balancesError + ? "Could not read your balances — retrying in the background." + : "Loading balances…"} +

+ )} +
+ + {!loggedIn ? ( +

+ Sign in to {mode} +

+ ) : ( + + )} + + {tx.phase === "error" && ( +

+ {tx.error} + {approvalStands && + " Your USDC approval did go through, so the allowance is in place — submitting again will not re-approve."} + {tx.hash && ( + <> + {" "} + + View on Basescan + + + )} +

+ )} + + {/* Suppressed while the flow is still running: the approval's own + "confirmed" state is an implementation detail mid-chain, not an + invitation to interact. */} + {tx.phase === "success" && !isSubmitting && ( +

+ {successLabel()}{" "} + {tx.hash && ( + + View on Basescan + + )} +

+ )} +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/dynamic/DynamicButton.tsx b/examples/nextjs-defi-lending-moonwell/src/components/dynamic/DynamicButton.tsx new file mode 100644 index 0000000..ec254cf --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/dynamic/DynamicButton.tsx @@ -0,0 +1,147 @@ +"use client"; + +import { useEffect, useRef, useState } from "react"; +import { Check, Copy, Loader2 } from "lucide-react"; +import { + useInitStatus, + useLogout, + useUser, +} from "@dynamic-labs-sdk/react-hooks"; +import { Login } from "@/components/Login"; +import { useWallet } from "@/lib/providers"; + +function truncate(address: string) { + return `${address.slice(0, 6)}…${address.slice(-4)}`; +} + +/** Outlined blue action, matching the Connect Wallet button on moonwell.fi. */ +const OUTLINED = + "cursor-pointer text-sm font-medium py-1.5 px-4 rounded-lg border border-brand text-brand hover:bg-chip transition-colors"; + +export default function DynamicButton() { + const { data: initStatus, error: initError } = useInitStatus(); + const { data: user } = useUser(); + const { evmAccount } = useWallet(); + const { mutate: logout } = useLogout(); + + const [open, setOpen] = useState(false); + const [copied, setCopied] = useState(false); + const ref = useRef(null); + + useEffect(() => { + function onClick(e: MouseEvent) { + if (ref.current && !ref.current.contains(e.target as Node)) { + setOpen(false); + } + } + document.addEventListener("mousedown", onClick); + return () => document.removeEventListener("mousedown", onClick); + }, []); + + // Every hook returns null or an empty list until init finishes, so gate the + // whole control on it rather than rendering a misleading signed-out state. + if (initStatus !== "finished") { + return ( + + ); + } + + if (user) { + return ( +
+ + + {open && ( +
+
+

Signed in as

+

{user.email ?? "—"}

+
+ +
+ {evmAccount ? ( +
+
+

Base wallet

+

+ {truncate(evmAccount.address)} +

+
+ +
+ ) : ( +
+ + Creating your embedded wallet… +
+ )} +
+ + +
+ )} +
+ ); + } + + return ( +
+ + + {open && ( +
+ setOpen(false)} /> +
+ )} +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/dynamic/Logo.tsx b/examples/nextjs-defi-lending-moonwell/src/components/dynamic/Logo.tsx new file mode 100644 index 0000000..e03fe3a --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/dynamic/Logo.tsx @@ -0,0 +1,59 @@ +interface DynamicLogoProps { + width?: number; + height?: number; + className?: string; +} + +export default function DynamicLogo({ + width = 150, + height = 30, + className = "text-[#141839]", +}: DynamicLogoProps) { + return ( + + + + + + + + + + + + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/footer.tsx b/examples/nextjs-defi-lending-moonwell/src/components/footer.tsx new file mode 100644 index 0000000..8e94180 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/footer.tsx @@ -0,0 +1,40 @@ +import DynamicLogo from "@/components/dynamic/Logo"; + +const LINKS = [ + { + label: "GitHub", + href: "https://github.com/dynamic-labs-oss/examples/tree/main/examples/nextjs-defi-lending-moonwell", + }, + { label: "Docs", href: "https://docs.dynamic.xyz" }, + { label: "Dashboard", href: "https://app.dynamic.xyz" }, + { label: "Support", href: "https://www.dynamic.xyz/join-slack" }, +]; + +export default function Footer() { + return ( +
+
+
+
+ powered by + +
+ +
+
+
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/ui/Badge.tsx b/examples/nextjs-defi-lending-moonwell/src/components/ui/Badge.tsx new file mode 100644 index 0000000..d5fb7a5 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/ui/Badge.tsx @@ -0,0 +1,30 @@ +import { cn } from "@/lib/utils"; + +const COLORS = { + base: "bg-chip text-chip-ink", + green: "bg-green-50 text-green-700", + grey: "bg-line text-muted", +} as const; + +/** Small chip, matching the network/market-type badges in the Moonwell app. */ +export function Badge({ + color = "grey", + children, + className, +}: { + color?: keyof typeof COLORS; + children: React.ReactNode; + className?: string; +}) { + return ( + + {children} + + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/ui/Skeleton.tsx b/examples/nextjs-defi-lending-moonwell/src/components/ui/Skeleton.tsx new file mode 100644 index 0000000..57f0bc6 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/ui/Skeleton.tsx @@ -0,0 +1,10 @@ +import { cn } from "@/lib/utils"; + +export function Skeleton({ className, ...props }: React.HTMLAttributes) { + return ( +
+ ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/components/ui/TokenIcon.tsx b/examples/nextjs-defi-lending-moonwell/src/components/ui/TokenIcon.tsx new file mode 100644 index 0000000..1d18615 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/components/ui/TokenIcon.tsx @@ -0,0 +1,46 @@ +import { cn } from "@/lib/utils"; + +/* + * Token logos are third-party brand marks, so this example draws a monogram + * instead of vendoring them. cbBTC → "BTC": the lowercase wrapper prefix is + * stripped so wrapped assets read as what they wrap. + */ +const TINTS = [ + "bg-chip text-chip-ink", + "bg-green-50 text-green-700", + "bg-surface text-muted", + "bg-line text-ink", +]; + +function tintFor(symbol: string) { + const sum = [...symbol].reduce((acc, c) => acc + c.charCodeAt(0), 0); + return TINTS[sum % TINTS.length]; +} + +function monogram(symbol: string) { + return symbol.replace(/^[a-z]+/, "").slice(0, 3) || symbol.slice(0, 3); +} + +export function TokenIcon({ + symbol, + size = 36, + className, +}: { + symbol: string; + size?: number; + className?: string; +}) { + return ( + + {monogram(symbol)} + + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/ERC20_ABI.ts b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/ERC20_ABI.ts new file mode 100644 index 0000000..0ae47c8 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/ERC20_ABI.ts @@ -0,0 +1,36 @@ +export const ERC20_ABI = [ + { + inputs: [], + name: "decimals", + outputs: [{ name: "", type: "uint8" }], + stateMutability: "view", + type: "function", + }, + { + inputs: [{ name: "owner", type: "address" }], + name: "balanceOf", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { name: "owner", type: "address" }, + { name: "spender", type: "address" }, + ], + name: "allowance", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { name: "spender", type: "address" }, + { name: "amount", type: "uint256" }, + ], + name: "approve", + outputs: [{ name: "", type: "bool" }], + stateMutability: "nonpayable", + type: "function", + }, +] as const; diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/MTOKEN_ABI.ts b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/MTOKEN_ABI.ts new file mode 100644 index 0000000..c31a9ef --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/MTOKEN_ABI.ts @@ -0,0 +1,44 @@ +/** + * Minimal Moonwell mToken interface (Compound v2 fork). + * + * `mint`, `redeem` and `redeemUnderlying` return a uint error code rather than + * reverting on some failures — simulate first and assert the result is `0n` + * before broadcasting. + */ +export const MTOKEN_ABI = [ + { + inputs: [{ name: "mintAmount", type: "uint256" }], + name: "mint", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [{ name: "redeemTokens", type: "uint256" }], + name: "redeem", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [{ name: "redeemAmount", type: "uint256" }], + name: "redeemUnderlying", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "exchangeRateStored", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, + { + inputs: [{ name: "owner", type: "address" }], + name: "balanceOf", + outputs: [{ name: "", type: "uint256" }], + stateMutability: "view", + type: "function", + }, +] as const; diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/index.ts b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/index.ts new file mode 100644 index 0000000..1756ac6 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/ABIs/index.ts @@ -0,0 +1,2 @@ +export * from "@/lib/ABIs/ERC20_ABI"; +export * from "@/lib/ABIs/MTOKEN_ABI"; diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/constants.ts b/examples/nextjs-defi-lending-moonwell/src/lib/constants.ts new file mode 100644 index 0000000..d5b2fc3 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/constants.ts @@ -0,0 +1,42 @@ +/** Base mainnet. This example is single-network by design — no chain selector. */ +export const CHAIN_ID = 8453; + +/** + * Moonwell's public markets endpoint. It defaults to Base, but the chain is + * passed explicitly so the URL documents itself. + */ +export const MARKETS_API = "https://api.moonwell.fi/v1/markets?chainId=8453"; + +/** Native USDC on Base (6 decimals). */ +export const USDC_ADDRESS = + "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const; + +/** + * Moonwell's mToken for the native USDC market (8 decimals). + * + * Two markets report the `mUSDC` symbol: this one and the deprecated USDbC + * market at 0x703843C3379b52F9FF486c9f5892218d2a065cC8. Always identify a + * market by its mToken address, never by symbol. + */ +export const MUSDC_ADDRESS = + "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22" as const; + +export const USDC_DECIMALS = 6; +/** + * Not referenced by the app — the exchange-rate scaling absorbs it — but kept + * because the recipe documents the 8-decimal mToken scale beside USDC's 6. + */ +export const MTOKEN_DECIMALS = 8; + +export const BASESCAN_URL = "https://basescan.org"; + +/** + * Base RPC used for both reads and broadcasting. + * + * Defaults to Moonwell's public endpoint. Base's own public endpoint + * (`mainnet.base.org`) rate-limits browser traffic and answers with 403, which + * shows up as a failed broadcast rather than a failed read. Override with + * `NEXT_PUBLIC_BASE_RPC_URL` to point at your own provider. + */ +export const BASE_RPC_URL = + process.env.NEXT_PUBLIC_BASE_RPC_URL || "https://rpc.moonwell.fi/main/evm/8453"; diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/dynamic.ts b/examples/nextjs-defi-lending-moonwell/src/lib/dynamic.ts new file mode 100644 index 0000000..b3f502c --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/dynamic.ts @@ -0,0 +1,71 @@ +import { createDynamicClient, initializeClient } from "@dynamic-labs-sdk/client"; +import { addEvmExtension } from "@dynamic-labs-sdk/evm"; +import { BASE_RPC_URL, CHAIN_ID } from "@/lib/constants"; + +// `universalLink` defaults to `window.location.origin`, which does not exist +// while Next.js renders on the server — fall back to the dev origin so this +// module can be imported from a "use client" module graph without throwing. +const universalLink = + typeof window !== "undefined" + ? window.location.origin + : "http://localhost:3000"; + +// Named loudly because it is the one setup step every reader must get right — +// without it the SDK fails with a message that says nothing about env vars. +if (typeof window !== "undefined" && !process.env.NEXT_PUBLIC_DYNAMIC_ENV_ID) { + console.error( + "NEXT_PUBLIC_DYNAMIC_ENV_ID is not set. Copy .env.example to .env.local " + + "and fill in your environment ID from app.dynamic.xyz.", + ); +} + +export const dynamicClient = createDynamicClient({ + autoInitialize: false, + environmentId: process.env.NEXT_PUBLIC_DYNAMIC_ENV_ID!, + metadata: { + name: "Moonwell Lending", + universalLink, + }, + transformers: { + /** + * The first network of a chain is the default for a fresh wallet, so + * restricting the EVM list to Base makes Base the default — without this, + * an environment that also has Ethereum enabled hands out wallets sitting + * on chain 1 and every write fails until the user switches. + * + * Also puts `BASE_RPC_URL` in front of the project's own RPC list, so the + * WaaS client broadcasts through it — Dynamic builds that transport from + * `networkData.rpcUrls`, so overriding it here is what makes the send use + * a working endpoint rather than Base's rate-limited public one. + */ + networksData: (networksData) => + networksData + .filter( + (network) => + network.chain !== "EVM" || Number(network.networkId) === CHAIN_ID, + ) + .map((network) => { + if (Number(network.networkId) !== CHAIN_ID) return network; + return { + ...network, + rpcUrls: { + ...network.rpcUrls, + http: [BASE_RPC_URL, ...network.rpcUrls.http], + }, + }; + }), + }, +}); + +// Register extensions and initialize at module scope so both happen before any +// component renders. Extension functions take NO arguments. The browser guard +// is a Next.js concern only: "use client" modules still execute during SSR, +// where there is no wallet environment to initialize. +if (typeof window !== "undefined") { + addEvmExtension(); + // The react-hooks surface reports init failure through `initStatus`; the + // log keeps the underlying cause from being swallowed with it. + initializeClient().catch((error) => { + console.error("Dynamic client failed to initialize", error); + }); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/hooks/index.ts b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/index.ts new file mode 100644 index 0000000..0ccd575 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/index.ts @@ -0,0 +1,7 @@ +export { useMarkets } from "@/lib/hooks/useMarkets"; +export { useBalances, balancesQueryKey, type Balances } from "@/lib/hooks/useBalances"; +export { + useLendingOperations, + type TxPhase, + type TxState, +} from "@/lib/hooks/useLendingOperations"; diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useBalances.ts b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useBalances.ts new file mode 100644 index 0000000..1f01325 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useBalances.ts @@ -0,0 +1,73 @@ +"use client"; + +import { useQuery } from "@tanstack/react-query"; +import { ERC20_ABI, MTOKEN_ABI } from "@/lib/ABIs"; +import { MUSDC_ADDRESS, USDC_ADDRESS } from "@/lib/constants"; +import { publicClient } from "@/lib/viem"; +import { underlyingFromMTokens } from "@/lib/moonwell"; + +export interface Balances { + /** USDC sitting in the wallet, in USDC's smallest unit (6 decimals). */ + walletUsdc: bigint; + /** mToken balance, 8 decimals. */ + mTokenBalance: bigint; + /** What the mToken balance currently redeems for, in USDC units. */ + suppliedUsdc: bigint; + /** USDC the mToken contract is allowed to pull. */ + allowance: bigint; +} + +export const balancesQueryKey = (address?: string) => + ["moonwell", "balances", address ?? "anonymous"] as const; + +/** + * Wallet USDC, supplied balance and allowance for the USDC market. + * + * The supplied balance is derived rather than read: an mToken balance is + * constant while its exchange rate grows, so interest only shows up once the + * two are multiplied. + */ +export function useBalances(address?: string) { + return useQuery({ + queryKey: balancesQueryKey(address), + enabled: !!address, + staleTime: 5_000, + refetchInterval: 5_000, + queryFn: async (): Promise => { + const owner = address as `0x${string}`; + const [walletUsdc, mTokenBalance, exchangeRate, allowance] = + await Promise.all([ + publicClient.readContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "balanceOf", + args: [owner], + }), + publicClient.readContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "balanceOf", + args: [owner], + }), + publicClient.readContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "exchangeRateStored", + }), + publicClient.readContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "allowance", + args: [owner, MUSDC_ADDRESS], + }), + ]); + + return { + walletUsdc, + mTokenBalance, + suppliedUsdc: underlyingFromMTokens(mTokenBalance, exchangeRate), + allowance, + }; + }, + }); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useLendingOperations.ts b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useLendingOperations.ts new file mode 100644 index 0000000..0015f55 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useLendingOperations.ts @@ -0,0 +1,316 @@ +"use client"; + +import { useCallback, useState } from "react"; +import { useQueryClient } from "@tanstack/react-query"; +import type { Account } from "viem"; +import { + getActiveNetworkId, + isProgrammaticNetworkSwitchAvailable, + switchActiveNetwork, +} from "@dynamic-labs-sdk/client"; +import { createWalletClientForWalletAccount } from "@dynamic-labs-sdk/evm/viem"; +import type { EvmWalletAccount } from "@dynamic-labs-sdk/evm"; +import { ERC20_ABI, MTOKEN_ABI } from "@/lib/ABIs"; +import { CHAIN_ID, MUSDC_ADDRESS, USDC_ADDRESS } from "@/lib/constants"; +import { balancesQueryKey } from "@/lib/hooks/useBalances"; +import { publicClient } from "@/lib/viem"; +import { formatErrorMessage, isStaleAllowanceError } from "@/lib/utils"; + +export type TxPhase = + | "idle" + | "switching" + | "approving" + | "pending" + | "success" + | "error"; + +export interface TxState { + phase: TxPhase; + hash?: `0x${string}`; + error?: string; + /** Which operation the state refers to, e.g. "approval" or "supply". */ + action?: string; +} + +const IDLE: TxState = { phase: "idle" }; + +/** + * Compound v2 markets answer some failures with a non-zero return code instead + * of reverting, so a transaction can succeed on-chain while doing nothing. + * Simulating first exposes that code — anything but 0 is a refusal. + */ +export function assertNoErrorCode(result: unknown, action: string) { + if (typeof result === "bigint" && result !== 0n) { + throw new Error( + `Moonwell rejected the ${action} with error code ${result}. ` + + `See https://docs.moonwell.fi for what each code means.`, + ); + } +} + +/** + * Blocks until the RPC is serving at least `blockNumber`. + * + * Invalidating the balance queries the instant a receipt arrives usually reads + * back the *old* balances: the receipt came from one node, and the refetch can + * be served by another that has not applied that block. React Query then caches + * those stale values, so the UI sits on pre-transaction numbers until a later + * poll happens to hit a caught-up node. + */ +async function waitForBlock( + blockNumber: bigint, + attempts = 10, + delayMs = 400, +) { + for (let attempt = 0; attempt < attempts; attempt++) { + // cacheTime 0, or viem answers from its own short-lived block cache. + const current = await publicClient.getBlockNumber({ cacheTime: 0 }); + if (current >= blockNumber) return; + await new Promise((resolve) => setTimeout(resolve, delayMs)); + } + // Giving up is survivable — the 5s balance poll catches up on its own — + // but it should never be silent. + console.warn(`RPC still behind block ${blockNumber}; balances may lag.`); +} + +export function useLendingOperations(evmAccount: EvmWalletAccount | null) { + const queryClient = useQueryClient(); + const [tx, setTx] = useState(IDLE); + + const address = evmAccount?.address as `0x${string}` | undefined; + + /** + * Puts the wallet on Base before anything is signed. + * + * An embedded wallet does not start on Base just because Base is enabled — it + * opens on whatever network the environment considers default. And + * `createWalletClientForWalletAccount` derives its chain from the wallet's + * *current* network, so the switch has to happen before the client is built, + * not after. + * + * Embedded wallets switch programmatically with no user prompt. An external + * wallet may refuse, so the capability is checked rather than assumed. + */ + const getWalletClient = useCallback( + async (onSwitchStart?: () => void) => { + if (!evmAccount) throw new Error("Connect a wallet first"); + + const { networkId } = await getActiveNetworkId({ + walletAccount: evmAccount, + }); + + if (Number(networkId) !== CHAIN_ID) { + if (!isProgrammaticNetworkSwitchAvailable({ walletAccount: evmAccount })) { + throw new Error( + `This wallet is on chain ${networkId} and cannot switch networks programmatically. Switch to Base (${CHAIN_ID}) in your wallet, then try again.`, + ); + } + onSwitchStart?.(); + await switchActiveNetwork({ + networkId: String(CHAIN_ID), + walletAccount: evmAccount, + }); + } + + const walletClient = await createWalletClientForWalletAccount({ + walletAccount: evmAccount, + }); + + // Backstop: if the switch silently failed we would otherwise sign against + // the wrong chain's contracts. + if (walletClient.chain?.id !== CHAIN_ID) { + throw new Error( + `Wallet is still on chain ${walletClient.chain?.id ?? "unknown"} after switching to Base (${CHAIN_ID}).`, + ); + } + + // The embedded wallet signs locally, which viem models as a `local` + // account. A `json-rpc` account means the SDK fell back to proxying + // through a provider that cannot sign — the transaction would be + // forwarded to a public RPC, which holds no keys and answers + // `eth_sendTransaction` with "rpc method is unsupported". Failing here + // names the cause instead of surfacing that as a network error. + if (walletClient.account?.type !== "local") { + throw new Error( + `Selected wallet cannot sign locally (viem account type "${walletClient.account?.type ?? "unknown"}"). This example expects a Dynamic embedded wallet.`, + ); + } + return walletClient; + }, + [evmAccount], + ); + + const reset = useCallback(() => setTx(IDLE), []); + + /** + * Runs one simulate → write → wait cycle and keeps `tx` in step with it. + * `phase` is the caller's label for the in-flight state so the UI can tell + * an approval apart from the supply that follows it. + * + * The simulate callback is handed the wallet's *account object*, not its + * address. `writeContract` prefers the account carried on the simulated + * request over the one on the client, and an address string parses into a + * `json-rpc` account — which would send `eth_sendTransaction` to the RPC + * instead of signing locally with the embedded wallet. + */ + const run = useCallback( + async ( + phase: Exclude, + action: string, + simulate: (account: Account) => Promise<{ + request: Parameters< + Awaited>["writeContract"] + >[0]; + result: unknown; + }>, + /** + * How many times to retry the simulate step while it fails on a stale + * allowance. Simulation is a read, so retrying it is free and safe — the + * write still happens exactly once, after a simulate that succeeded. + */ + simulateAttempts = 1, + ) => { + if (!address) { + setTx({ phase: "error", error: "Connect a wallet first" }); + return false; + } + setTx({ phase }); + let hash: `0x${string}` | undefined; + try { + // Only surfaces the switching phase when a switch is actually needed, so + // the common same-chain path does not flash it. + const walletClient = await getWalletClient(() => + setTx({ phase: "switching" }), + ); + setTx({ phase }); + + let simulated: Awaited> | undefined; + for (let attempt = 1; ; attempt++) { + try { + simulated = await simulate(walletClient.account); + break; + } catch (error) { + if (attempt >= simulateAttempts || !isStaleAllowanceError(error)) { + throw error; + } + await new Promise((resolve) => setTimeout(resolve, 1_000)); + } + } + + const { request, result } = simulated; + assertNoErrorCode(result, action); + + hash = await walletClient.writeContract(request); + setTx({ phase, hash, action }); + + const receipt = await publicClient.waitForTransactionReceipt({ hash }); + if (receipt.status !== "success") { + throw new Error(`${action} transaction reverted`); + } + + // The transaction is final the moment the receipt says success, so + // report it now. The refresh below makes ten more RPC round-trips, and + // a hiccup in any of them must not repaint a mined transaction as a + // failure. + setTx({ phase: "success", hash, action }); + + try { + // Only refetch once the RPC can actually see this block, otherwise + // the refreshed balances are the pre-transaction ones. + await waitForBlock(receipt.blockNumber); + await queryClient.invalidateQueries({ + queryKey: balancesQueryKey(address), + }); + } catch (refreshError) { + // Best-effort: the 5s balance poll catches up on its own. + console.error(`Balance refresh after the ${action} failed`, refreshError); + } + return true; + } catch (error) { + console.error(`The ${action} failed`, error); + // Keep the hash when the write was broadcast: whether the funds moved + // is the one thing the user most needs to check, so the UI links it. + setTx({ phase: "error", error: formatErrorMessage(error), action, hash }); + return false; + } + }, + [address, getWalletClient, queryClient], + ); + + /** Approves the mToken to spend `amount` USDC. */ + const approve = useCallback( + (amount: bigint) => + run("approving", "approval", async (account) => + publicClient.simulateContract({ + address: USDC_ADDRESS, + abi: ERC20_ABI, + functionName: "approve", + args: [MUSDC_ADDRESS, amount], + account, + }), + ), + [run], + ); + + /** + * Supplies USDC and receives mUSDC. + * + * `simulateAttempts` above 1 is for a supply chained straight onto an + * approval: the allowance is on-chain but the read path may not serve it for + * a few seconds, and retrying the simulate absorbs that without asking the + * user to press anything twice. + */ + const supply = useCallback( + (amount: bigint, simulateAttempts = 1) => + run( + "pending", + "supply", + async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "mint", + args: [amount], + account, + }), + simulateAttempts, + ), + [run], + ); + + /** Withdraws an exact USDC amount. */ + const withdraw = useCallback( + (amount: bigint) => + run("pending", "withdrawal", async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "redeemUnderlying", + args: [amount], + account, + }), + ), + [run], + ); + + /** + * Withdraws everything by redeeming the whole mToken balance. Going through + * `redeem` rather than `redeemUnderlying` avoids leaving dust behind when the + * exchange rate moves between quoting and mining. + */ + const withdrawMax = useCallback( + (mTokenBalance: bigint) => + run("pending", "withdrawal", async (account) => + publicClient.simulateContract({ + address: MUSDC_ADDRESS, + abi: MTOKEN_ABI, + functionName: "redeem", + args: [mTokenBalance], + account, + }), + ), + [run], + ); + + return { tx, reset, approve, supply, withdraw, withdrawMax }; +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useMarkets.ts b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useMarkets.ts new file mode 100644 index 0000000..b52474e --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/hooks/useMarkets.ts @@ -0,0 +1,26 @@ +"use client"; + +import { useQuery } from "@tanstack/react-query"; +import { MARKETS_API } from "@/lib/constants"; +import { + filterActiveMarkets, + parseMarketsResponse, + type Market, +} from "@/lib/moonwell"; + +async function fetchActiveMarkets(): Promise { + const res = await fetch(MARKETS_API); + if (!res.ok) { + throw new Error(`Moonwell API returned ${res.status}`); + } + return filterActiveMarkets(parseMarketsResponse(await res.json())); +} + +/** Live Base markets, deprecated ones already removed. */ +export function useMarkets() { + return useQuery({ + queryKey: ["moonwell", "markets"], + queryFn: fetchActiveMarkets, + staleTime: 30_000, + }); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/moonwell.ts b/examples/nextjs-defi-lending-moonwell/src/lib/moonwell.ts new file mode 100644 index 0000000..f5e3a00 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/moonwell.ts @@ -0,0 +1,174 @@ +/** + * Pure domain logic for the Moonwell markets API and mToken accounting. + * Everything here is framework-free and unit tested in `moonwell.test.ts`. + */ + +export interface Market { + /** Underlying asset symbol, e.g. "USDC". */ + asset: string; + assetAddress: string; + /** mToken symbol. NOT unique — both USDC and legacy USDbC report "mUSDC". */ + mToken: string; + /** The stable identifier for a market. */ + mTokenAddress: string; + deprecated: boolean; + /** Already a percentage: 4.3861606852 means 4.39%. */ + baseSupplyApy: number; + baseBorrowApy: number; + /** Supply APY including protocol rewards, also a percentage. */ + totalSupplyApr: number; + totalBorrowApr: number; + totalSupplyUsd: number; + totalBorrowsUsd: number; + liquidityUsd: number; + utilization: number; + collateralFactor: number; +} + +const NUMBER_FIELDS = [ + "baseSupplyApy", + "baseBorrowApy", + "totalSupplyApr", + "totalBorrowApr", + "totalSupplyUsd", + "totalBorrowsUsd", + "liquidityUsd", + "utilization", + "collateralFactor", +] as const; + +const STRING_FIELDS = [ + "asset", + "assetAddress", + "mToken", + "mTokenAddress", +] as const; + +function isRecord(value: unknown): value is Record { + return typeof value === "object" && value !== null; +} + +function isMarket(value: unknown): value is Market { + if (!isRecord(value)) return false; + if (typeof value.deprecated !== "boolean") return false; + return ( + STRING_FIELDS.every((f) => typeof value[f] === "string") && + NUMBER_FIELDS.every((f) => typeof value[f] === "number") + ); +} + +/** + * Runtime guard over the markets endpoint. The response is + * `{ success, data: Market[], meta }`; anything else is a hard error rather + * than a silently empty market list. + */ +export function parseMarketsResponse(payload: unknown): Market[] { + if (!isRecord(payload)) { + throw new Error("Moonwell API: expected a JSON object"); + } + if (payload.success !== true) { + throw new Error("Moonwell API: response success flag was not true"); + } + if (!Array.isArray(payload.data)) { + throw new Error("Moonwell API: expected data to be an array"); + } + if (!payload.data.every(isMarket)) { + throw new Error("Moonwell API: a market is missing required fields"); + } + return payload.data; +} + +/** Deprecated markets are read-only husks — never show or target them. */ +export function filterActiveMarkets(markets: Market[]): Market[] { + return markets.filter((market) => !market.deprecated); +} + +/** Markets are identified by mToken address because symbols collide. */ +export function findMarketByMToken( + markets: Market[], + mTokenAddress: string, +): Market | undefined { + const needle = mTokenAddress.toLowerCase(); + return markets.find((m) => m.mTokenAddress.toLowerCase() === needle); +} + +/** + * Converts an mToken balance into the underlying asset's smallest unit. + * + * `exchangeRateStored` is scaled by 1e(10 + underlyingDecimals), so dividing + * the product by 1e18 lands in underlying units for any market, regardless of + * the underlying's decimals. Truncating division rounds in the protocol's + * favour, which is what we want when displaying a redeemable balance. + */ +export function underlyingFromMTokens( + mTokenBalance: bigint, + exchangeRateStored: bigint, +): bigint { + return (mTokenBalance * exchangeRateStored) / 10n ** 18n; +} + +/** + * Formats a token amount for display, to cents. + * + * Rounds half-up in bigint arithmetic rather than going through `Number` — + * `(1.005).toFixed(2)` is `"1.00"`, because 1.005 has no exact binary + * representation. Balances are money, so they round by the stated rule and not + * by whichever float happens to be nearest. + * + * A nonzero balance never reads as "0.00": the Max button offers full + * precision, so a card showing 0.00 while Max offers something is a + * contradiction the user cannot resolve. + */ +export function formatUsdcAmount(value: bigint, decimals = 6): string { + if (value === 0n) return "0.00"; + const scale = 10n ** BigInt(decimals); + const cents = (value * 100n + scale / 2n) / scale; + if (cents === 0n) return "<0.01"; + return `${cents / 100n}.${String(cents % 100n).padStart(2, "0")}`; +} + +/** API APY values are already percentages. */ +export function formatApy(apy: number): string { + if (!Number.isFinite(apy)) return "—"; + return `${apy.toFixed(2)}%`; +} + +/** + * Full asset names as shown on moonwell.fi. The markets API returns symbols + * only, and the app pairs each symbol with its name in the market list. + */ +const ASSET_NAMES: Record = { + AERO: "Aerodrome", + DAI: "Dai", + ETH: "Ethereum", + EURC: "Euro Coin", + LBTC: "Lombard Staked Bitcoin", + MAMO: "Mamo", + MORPHO: "Morpho", + USDC: "USD Coin", + USDS: "Sky Dollar", + VIRTUAL: "Virtuals Protocol", + WELL: "Moonwell", + cbBTC: "Coinbase Bitcoin", + cbETH: "Coinbase Staked Ethereum", + cbXRP: "Coinbase XRP", + rETH: "Rocket Pool Staked Ethereum", + tBTC: "Threshold Bitcoin", + weETH: "EtherFi Restaked Ethereum", + wrsETH: "KelpDAO Restaked Ethereum", + wstETH: "Lido Staked Ethereum", +}; + +/** Falls back to the symbol for any asset listed after this map was written. */ +export function assetDisplayName(symbol: string): string { + return ASSET_NAMES[symbol] ?? symbol; +} + +export function formatUsd(value: number): string { + if (!Number.isFinite(value)) return "—"; + const abs = Math.abs(value); + if (abs >= 1e9) return `$${(value / 1e9).toFixed(2)}B`; + if (abs >= 1e6) return `$${(value / 1e6).toFixed(2)}M`; + if (abs >= 1e3) return `$${(value / 1e3).toFixed(2)}K`; + return `$${value.toFixed(2)}`; +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/providers.tsx b/examples/nextjs-defi-lending-moonwell/src/lib/providers.tsx new file mode 100644 index 0000000..fd380f7 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/providers.tsx @@ -0,0 +1,113 @@ +"use client"; + +import { createContext, useContext, type ReactNode } from "react"; +import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; +import { DynamicProvider, useOnEvent, useUser, useGetWalletAccounts } from "@dynamic-labs-sdk/react-hooks"; +import { + createWaasWalletAccounts, + getChainsMissingWaasWalletAccounts, + isWaasWalletAccount, +} from "@dynamic-labs-sdk/client/waas"; +import type { WalletAccount } from "@dynamic-labs-sdk/client"; +import { isEvmWalletAccount, type EvmWalletAccount } from "@dynamic-labs-sdk/evm"; +import { CHAIN_ID } from "@/lib/constants"; +import { dynamicClient } from "@/lib/dynamic"; + +interface WalletContextValue { + evmAccount: EvmWalletAccount | null; + loggedIn: boolean; + /** Base only — this example has no network selector. */ + chainId: number; +} + +const WalletContext = createContext({ + evmAccount: null, + loggedIn: false, + chainId: CHAIN_ID, +}); + +export function useWallet() { + return useContext(WalletContext); +} + +const queryClient = new QueryClient({ + defaultOptions: { + queries: { + // Matches the Moonwell app's 5s cadence for on-chain reads. Window-focus + // refetching is deliberately left on: polling pauses while the tab is in + // the background, so without it a user who switches away during a + // transaction comes back to stale balances. + staleTime: 1000 * 5, + }, + }, +}); + +/** + * Embedded (WaaS) wallet creation is not automatic — it has to be triggered + * after authentication. `getChainsMissingWaasWalletAccounts()` is the correct + * signal: guarding on `accounts.length === 0` can read a stale non-empty list + * immediately after auth and silently skip creation. + * + * `useOnEvent` (never a raw `onEvent` call in a component) deduplicates the + * subscription and cleans it up on unmount, including under Strict Mode. + */ +function WaasBootstrap() { + useOnEvent({ + event: "userChanged", + listener: async (user) => { + if (!user) return; + const missingChains = getChainsMissingWaasWalletAccounts(); + if (missingChains.length === 0) return; + try { + await createWaasWalletAccounts({ chains: missingChains }); + } catch (error) { + // Nothing awaits an event listener, so an uncaught rejection here is + // silent — and the UI would wait forever for a wallet that never + // arrives. Signing out and back in retries the creation. + console.error("Embedded wallet creation failed", error); + } + }, + }); + return null; +} + +function WalletContextProvider({ children }: { children: ReactNode }) { + const { data: user } = useUser(); + const { data: accounts = [] } = useGetWalletAccounts(); + // `useGetWalletAccounts` is typed as the chain-agnostic base account, while + // the type guard is declared over the chain-specific `WalletAccount` union. + const evmAccounts = (accounts as WalletAccount[]).filter(isEvmWalletAccount); + + // Prefer the embedded wallet. `addEvmExtension()` also registers EIP-6963 + // discovery, so an external browser wallet can appear in this list — and only + // the WaaS provider signs locally. Picking the first EVM account instead would + // hand transactions to a provider that just forwards `eth_sendTransaction` to + // a public RPC, which has no keys and rejects it. + const evmAccount = + evmAccounts.find((walletAccount) => isWaasWalletAccount({ walletAccount })) ?? + evmAccounts[0] ?? + null; + + return ( + + {children} + + ); +} + +/** + * `QueryClientProvider` must sit OUTSIDE `DynamicProvider`: every hook in + * `@dynamic-labs-sdk/react-hooks` is built on TanStack Query. + */ +export default function Providers({ children }: { children: ReactNode }) { + return ( + + + + {children} + + + ); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/utils.ts b/examples/nextjs-defi-lending-moonwell/src/lib/utils.ts new file mode 100644 index 0000000..6ae707f --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/utils.ts @@ -0,0 +1,25 @@ +import { type ClassValue, clsx } from "clsx"; +import { twMerge } from "tailwind-merge"; + +export function cn(...inputs: ClassValue[]): string { + return twMerge(clsx(inputs)); +} + +/** + * True for the one failure that a moment's patience fixes: a freshly approved + * allowance that the read path has not caught up to yet. Everything else — a + * balance genuinely too low, a paused market — must surface immediately rather + * than sit behind a retry loop. + */ +export function isStaleAllowanceError(error: unknown): boolean { + return formatErrorMessage(error).toLowerCase().includes("allowance"); +} + +export function formatErrorMessage(error: unknown): string { + if (error && typeof error === "object" && "shortMessage" in error) { + const short = (error as { shortMessage?: string }).shortMessage; + if (short) return short; + } + if (error instanceof Error) return error.message; + return String(error); +} diff --git a/examples/nextjs-defi-lending-moonwell/src/lib/viem.ts b/examples/nextjs-defi-lending-moonwell/src/lib/viem.ts new file mode 100644 index 0000000..793d315 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/src/lib/viem.ts @@ -0,0 +1,9 @@ +import { createPublicClient, http } from "viem"; +import { base } from "viem/chains"; +import { BASE_RPC_URL } from "@/lib/constants"; + +/** Read-only Base client. Writes go through the Dynamic wallet client. */ +export const publicClient = createPublicClient({ + chain: base, + transport: http(BASE_RPC_URL), +}); diff --git a/examples/nextjs-defi-lending-moonwell/tsconfig.json b/examples/nextjs-defi-lending-moonwell/tsconfig.json new file mode 100644 index 0000000..d7e05e5 --- /dev/null +++ b/examples/nextjs-defi-lending-moonwell/tsconfig.json @@ -0,0 +1,27 @@ +{ + "compilerOptions": { + "target": "ES2020", + "lib": ["dom", "dom.iterable", "esnext"], + "allowJs": true, + "skipLibCheck": true, + "strict": true, + "noEmit": true, + "esModuleInterop": true, + "module": "esnext", + "moduleResolution": "bundler", + "resolveJsonModule": true, + "isolatedModules": true, + "jsx": "preserve", + "incremental": true, + "plugins": [ + { + "name": "next" + } + ], + "paths": { + "@/*": ["./src/*"] + } + }, + "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"], + "exclude": ["node_modules"] +}