@luxfi/dex 1.2.1 → 2.0.0

package/dist/hooks/use-lxbook.js

@@ -0,0 +1,213 @@
+/**
+ * LXBook Hooks (LP-9020)
+ * React hooks for CLOB trading via LXBook precompile
+ */
+import { useCallback } from 'react';
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
+import { encodeFunctionData } from 'viem';
+import { LX } from '../precompile/addresses';
+import { LX_BOOK_ABI } from '../precompile/abis';
+import { ActionType, TIF, OrderKind, } from '../precompile/types';
+/**
+ * Hook to get L1 (best bid/ask) for a market
+ */
+export function useLXBookL1(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getL1',
+        args: [marketId],
+    });
+    return {
+        l1: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get market config
+ */
+export function useLXBookMarket(marketId) {
+    const { data, isLoading, error } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getMarketConfig',
+        args: [marketId],
+    });
+    return {
+        config: data,
+        isLoading,
+        error,
+    };
+}
+/**
+ * Hook to get market status
+ */
+export function useLXBookMarketStatus(marketId) {
+    const { data, isLoading, error } = useReadContract({
+        address: LX.LX_BOOK,
+        abi: LX_BOOK_ABI,
+        functionName: 'getMarketStatus',
+        args: [marketId],
+    });
+    return {
+        status: data,
+        isLoading,
+        error,
+    };
+}
+/**
+ * Build action payload for execute()
+ */
+function buildAction(actionType, nonce, expiresAfter, data) {
+    return {
+        actionType,
+        nonce,
+        expiresAfter,
+        data,
+    };
+}
+/**
+ * Encode order data for placement
+ */
+function encodeOrderData(order) {
+    // Pack order into bytes - this matches the Go/Solidity struct layout
+    const encoded = encodeFunctionData({
+        abi: [{
+                type: 'function',
+                name: 'encodeOrder',
+                inputs: [{
+                        name: 'order',
+                        type: 'tuple',
+                        components: [
+                            { name: 'marketId', type: 'uint32' },
+                            { name: 'isBuy', type: 'bool' },
+                            { name: 'kind', type: 'uint8' },
+                            { name: 'sizeX18', type: 'uint128' },
+                            { name: 'limitPxX18', type: 'uint128' },
+                            { name: 'triggerPxX18', type: 'uint128' },
+                            { name: 'reduceOnly', type: 'bool' },
+                            { name: 'tif', type: 'uint8' },
+                            { name: 'cloid', type: 'bytes16' },
+                            { name: 'groupId', type: 'bytes16' },
+                            { name: 'groupType', type: 'uint8' },
+                        ],
+                    }],
+                outputs: [],
+                stateMutability: 'pure',
+            }],
+        functionName: 'encodeOrder',
+        args: [order],
+    });
+    // Strip function selector (first 4 bytes)
+    return `0x${encoded.slice(10)}`;
+}
+/**
+ * Hook for placing orders via LXBook execute()
+ */
+export function useLXBookExecute() {
+    const { writeContract, data: hash, isPending, error } = useWriteContract();
+    const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });
+    const execute = useCallback((action) => {
+        writeContract({
+            address: LX.LX_BOOK,
+            abi: LX_BOOK_ABI,
+            functionName: 'execute',
+            args: [action],
+        });
+    }, [writeContract]);
+    const executeBatch = useCallback((actions) => {
+        writeContract({
+            address: LX.LX_BOOK,
+            abi: LX_BOOK_ABI,
+            functionName: 'executeBatch',
+            args: [actions],
+        });
+    }, [writeContract]);
+    return {
+        execute,
+        executeBatch,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}
+/**
+ * Hook for placing limit orders
+ */
+export function useLXBookPlaceOrder() {
+    const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute();
+    const placeOrder = useCallback(async (params) => {
+        const order = {
+            marketId: params.marketId,
+            isBuy: params.isBuy,
+            kind: OrderKind.LIMIT,
+            sizeX18: params.size,
+            limitPxX18: params.price,
+            triggerPxX18: 0n,
+            reduceOnly: params.reduceOnly ?? false,
+            tif: params.tif ?? TIF.GTC,
+            cloid: params.cloid ?? '0x00000000000000000000000000000000',
+            groupId: '0x00000000000000000000000000000000',
+            groupType: 0,
+        };
+        const action = buildAction(ActionType.PLACE, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 300), // 5 min expiry
+        encodeOrderData(order));
+        return execute(action);
+    }, [execute]);
+    const placeMarketOrder = useCallback(async (params) => {
+        const order = {
+            marketId: params.marketId,
+            isBuy: params.isBuy,
+            kind: OrderKind.MARKET,
+            sizeX18: params.size,
+            limitPxX18: 0n, // Market order - no limit
+            triggerPxX18: 0n,
+            reduceOnly: params.reduceOnly ?? false,
+            tif: TIF.IOC,
+            cloid: '0x00000000000000000000000000000000',
+            groupId: '0x00000000000000000000000000000000',
+            groupType: 0,
+        };
+        const action = buildAction(ActionType.PLACE, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), // 1 min expiry for market
+        encodeOrderData(order));
+        return execute(action);
+    }, [execute]);
+    return {
+        placeOrder,
+        placeMarketOrder,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}
+/**
+ * Hook for canceling orders
+ */
+export function useLXBookCancelOrder() {
+    const { execute, hash, isPending, isConfirming, isSuccess, error } = useLXBookExecute();
+    const cancelByOid = useCallback(async (oid) => {
+        // Encode oid as bytes
+        const data = `0x${oid.toString(16).padStart(64, '0')}`;
+        const action = buildAction(ActionType.CANCEL, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), data);
+        return execute(action);
+    }, [execute]);
+    const cancelByCloid = useCallback(async (cloid) => {
+        const action = buildAction(ActionType.CANCEL_BY_CLOID, BigInt(Date.now()), BigInt(Math.floor(Date.now() / 1000) + 60), cloid);
+        return execute(action);
+    }, [execute]);
+    return {
+        cancelByOid,
+        cancelByCloid,
+        hash,
+        isPending,
+        isConfirming,
+        isSuccess,
+        error,
+    };
+}

package/dist/hooks/use-lxfeed.d.ts

@@ -0,0 +1,111 @@
+import type { Address } from 'viem';
+import type { LXMarkPrice } from '../precompile/types';
+/**
+ * Hook to get mark price for a market
+ */
+export declare function useLXFeedMarkPrice(marketId: number): {
+    markPrice: LXMarkPrice | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        indexPxX18: bigint;
+        markPxX18: bigint;
+        premiumX18: bigint;
+        timestamp: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get index price for a market
+ */
+export declare function useLXFeedIndexPrice(marketId: number): {
+    priceX18: bigint | undefined;
+    timestamp: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [bigint, timestamp: bigint], import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get funding rate for a market
+ */
+export declare function useLXFeedFundingRate(marketId: number): {
+    rateX18: bigint | undefined;
+    nextFundingTime: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [bigint, bigint], import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get trigger price for stop/take orders
+ */
+export declare function useLXFeedTriggerPrice(marketId: number, isBuy: boolean): {
+    triggerPriceX18: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<bigint, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get oracle price for token pair
+ */
+export declare function useLXOraclePrice(baseToken: Address, quoteToken: Address): {
+    price: {
+        price: bigint;
+        confidence: bigint;
+        timestamp: bigint;
+        source: number;
+        expo: number;
+    } | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        price: bigint;
+        confidence: bigint;
+        timestamp: bigint;
+        source: number;
+        expo: number;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get aggregated oracle price with deviation info
+ */
+export declare function useLXOracleAggregatedPrice(baseToken: Address, quoteToken: Address, maxStaleness?: bigint): {
+    aggregated: {
+        price: bigint;
+        minPrice: bigint;
+        maxPrice: bigint;
+        deviation: bigint;
+        numSources: bigint;
+        timestamp: bigint;
+    } | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        price: bigint;
+        minPrice: bigint;
+        maxPrice: bigint;
+        deviation: bigint;
+        numSources: bigint;
+        timestamp: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to check if oracle price is fresh
+ */
+export declare function useLXOraclePriceFresh(baseToken: Address, quoteToken: Address, maxStaleness?: bigint): {
+    isFresh: boolean | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<boolean, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Combined hook for market price data
+ */
+export declare function useLXMarketPrices(marketId: number): {
+    markPrice: LXMarkPrice | undefined;
+    indexPrice: bigint | undefined;
+    fundingRate: bigint | undefined;
+    nextFundingTime: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: () => void;
+};
+//# sourceMappingURL=use-lxfeed.d.ts.map

package/dist/hooks/use-lxfeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lxfeed.d.ts","sourceRoot":"","sources":["../../src/hooks/use-lxfeed.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAGnC,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,qBAAqB,CAAA;AAErE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM;eAS5B,WAAW,GAAG,SAAS;;;;;;;;;EAK7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM;;;;;;EAiBnD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM;;;;;;EAiBpD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;qBASzC,MAAM,GAAG,SAAS;;;;EAK9C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;;;;;;;;;;;;;;;;;EAcvE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,OAAO,EACnB,YAAY,GAAE,MAAc;;;;;;;;;;;;;;;;;;;EAe7B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,OAAO,EACnB,YAAY,GAAE,MAAc;aAUT,OAAO,GAAG,SAAS;;;;EAKvC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM;;;;;;;;EAkBjD"}

package/dist/hooks/use-lxfeed.js

@@ -0,0 +1,152 @@
+/**
+ * LXFeed Hooks (LP-9040)
+ * React hooks for price feeds, mark price, and funding rates
+ */
+import { useReadContract } from 'wagmi';
+import { LX } from '../precompile/addresses';
+import { LX_FEED_ABI, LX_ORACLE_ABI } from '../precompile/abis';
+/**
+ * Hook to get mark price for a market
+ */
+export function useLXFeedMarkPrice(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getMarkPrice',
+        args: [marketId],
+    });
+    return {
+        markPrice: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get index price for a market
+ */
+export function useLXFeedIndexPrice(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getIndexPrice',
+        args: [marketId],
+    });
+    const result = data;
+    return {
+        priceX18: result?.[0],
+        timestamp: result?.[1],
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get funding rate for a market
+ */
+export function useLXFeedFundingRate(marketId) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getFundingRate',
+        args: [marketId],
+    });
+    const result = data;
+    return {
+        rateX18: result?.[0],
+        nextFundingTime: result?.[1],
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get trigger price for stop/take orders
+ */
+export function useLXFeedTriggerPrice(marketId, isBuy) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_FEED,
+        abi: LX_FEED_ABI,
+        functionName: 'getTriggerPrice',
+        args: [marketId, isBuy],
+    });
+    return {
+        triggerPriceX18: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get oracle price for token pair
+ */
+export function useLXOraclePrice(baseToken, quoteToken) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'getPrice',
+        args: [baseToken, quoteToken],
+    });
+    return {
+        price: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to get aggregated oracle price with deviation info
+ */
+export function useLXOracleAggregatedPrice(baseToken, quoteToken, maxStaleness = 3600n // 1 hour default
+) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'getAggregatedPrice',
+        args: [baseToken, quoteToken, maxStaleness],
+    });
+    return {
+        aggregated: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Hook to check if oracle price is fresh
+ */
+export function useLXOraclePriceFresh(baseToken, quoteToken, maxStaleness = 3600n) {
+    const { data, isLoading, error, refetch } = useReadContract({
+        address: LX.LX_ORACLE,
+        abi: LX_ORACLE_ABI,
+        functionName: 'isPriceFresh',
+        args: [baseToken, quoteToken, maxStaleness],
+    });
+    return {
+        isFresh: data,
+        isLoading,
+        error,
+        refetch,
+    };
+}
+/**
+ * Combined hook for market price data
+ */
+export function useLXMarketPrices(marketId) {
+    const mark = useLXFeedMarkPrice(marketId);
+    const index = useLXFeedIndexPrice(marketId);
+    const funding = useLXFeedFundingRate(marketId);
+    return {
+        markPrice: mark.markPrice,
+        indexPrice: index.priceX18,
+        fundingRate: funding.rateX18,
+        nextFundingTime: funding.nextFundingTime,
+        isLoading: mark.isLoading || index.isLoading || funding.isLoading,
+        error: mark.error || index.error || funding.error,
+        refetch: () => {
+            mark.refetch();
+            index.refetch();
+            funding.refetch();
+        },
+    };
+}

package/dist/hooks/use-lxvault.d.ts

@@ -0,0 +1,137 @@
+import type { Address } from 'viem';
+import type { LXPosition, LXMarginInfo } from '../precompile/types';
+/**
+ * Hook to get token balance in vault
+ */
+export declare function useLXVaultBalance(token: Address, subaccountId?: number): {
+    balance: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<bigint, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get position for a market
+ */
+export declare function useLXVaultPosition(marketId: number, subaccountId?: number): {
+    position: LXPosition | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        marketId: number;
+        side: number;
+        sizeX18: bigint;
+        entryPxX18: bigint;
+        unrealizedPnlX18: bigint;
+        accumulatedFundingX18: bigint;
+        lastFundingTime: bigint;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get margin info (free margin, used margin, etc.)
+ */
+export declare function useLXVaultMargin(subaccountId?: number): {
+    margin: LXMarginInfo | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        totalCollateralX18: bigint;
+        usedMarginX18: bigint;
+        freeMarginX18: bigint;
+        marginRatioX18: bigint;
+        maintenanceMarginX18: bigint;
+        liquidatable: boolean;
+    }, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to check if account is liquidatable
+ */
+export declare function useLXVaultLiquidatable(account?: Address, subaccountId?: number): {
+    liquidatable: boolean | undefined;
+    shortfall: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [boolean, bigint], import("viem").ReadContractErrorType>>;
+};
+/**
+ * Hook to get funding rate for a market
+ */
+export declare function useLXVaultFundingRate(marketId: number): {
+    rateX18: bigint | undefined;
+    nextFundingTime: bigint | undefined;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<readonly [bigint, bigint], import("viem").ReadContractErrorType>>;
+};
+interface UseLXVaultDepositResult {
+    deposit: (token: Address, amount: bigint, subaccountId?: number) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for depositing tokens into vault
+ */
+export declare function useLXVaultDeposit(): UseLXVaultDepositResult;
+interface UseLXVaultWithdrawResult {
+    withdraw: (token: Address, amount: bigint, subaccountId?: number) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for withdrawing tokens from vault
+ */
+export declare function useLXVaultWithdraw(): UseLXVaultWithdrawResult;
+interface UseLXVaultTransferResult {
+    transfer: (token: Address, amount: bigint, fromSubaccount: number, toSubaccount: number) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for transferring between subaccounts
+ */
+export declare function useLXVaultTransfer(): UseLXVaultTransferResult;
+interface UseLXVaultLiquidateResult {
+    liquidate: (targetAccount: Address, targetSubaccount: number, marketId: number, sizeX18: bigint) => void;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for liquidating underwater positions
+ */
+export declare function useLXVaultLiquidate(): UseLXVaultLiquidateResult;
+/**
+ * Combined hook for common vault operations
+ */
+export declare function useLXVault(subaccountId?: number): {
+    address: `0x${string}` | undefined;
+    subaccountId: number;
+    margin: LXMarginInfo | undefined;
+    isLoadingMargin: boolean;
+    deposit: (token: Address, amount: bigint, subaccountId?: number) => void;
+    withdraw: (token: Address, amount: bigint, subaccountId?: number) => void;
+    transfer: (token: Address, amount: bigint, fromSubaccount: number, toSubaccount: number) => void;
+    isDepositing: boolean;
+    isWithdrawing: boolean;
+    isTransferring: boolean;
+    refetchMargin: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        totalCollateralX18: bigint;
+        usedMarginX18: bigint;
+        freeMarginX18: bigint;
+        marginRatioX18: bigint;
+        maintenanceMarginX18: bigint;
+        liquidatable: boolean;
+    }, import("viem").ReadContractErrorType>>;
+};
+export {};
+//# sourceMappingURL=use-lxvault.d.ts.map

package/dist/hooks/use-lxvault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lxvault.d.ts","sourceRoot":"","sources":["../../src/hooks/use-lxvault.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAGnC,OAAO,KAAK,EAAa,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAS9E;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,GAAE,MAAU;aAYrD,MAAM,GAAG,SAAS;;;;EAKtC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU;cAYvD,UAAU,GAAG,SAAS;;;;;;;;;;;;EAK3C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,GAAE,MAAU;YAYrC,YAAY,GAAG,SAAS;;;;;;;;;;;EAK3C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,YAAY,GAAE,MAAU;;;;;;EAqBjF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM;;;;;;EAiBrD;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACxE,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,uBAAuB,CAwB3D;AAED,UAAU,wBAAwB;IAChC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACzE,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,wBAAwB,CAwB7D;AAED,UAAU,wBAAwB;IAChC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;IAChG,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,wBAAwB,CA6B7D;AAED,UAAU,yBAAyB;IACjC,SAAS,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxG,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/B,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,yBAAyB,CA6B/D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,YAAY,GAAE,MAAU;;;;;qBApKhC,OAAO,UAAU,MAAM,iBAAiB,MAAM,KAAK,IAAI;sBAsCtD,OAAO,UAAU,MAAM,iBAAiB,MAAM,KAAK,IAAI;sBAsCvD,OAAO,UAAU,MAAM,kBAAkB,MAAM,gBAAgB,MAAM,KAAK,IAAI;;;;;;;;;;;;EA4GjG"}