@luxfi/exchange 0.1.0

package/dist/bridge/private-teleport-types.js

@@ -0,0 +1,308 @@
+/**
+ * Private Teleport Types
+ *
+ * Types for cross-chain private teleportation using Z-Chain privacy layer
+ * Flow: XVM UTXO → Warp → ZNote (shielded) → Z-Chain AMM (private swap) → C-Chain/XVM
+ */
+// ═══════════════════════════════════════════════════════════════════════════
+// TELEPORT STATE
+// ═══════════════════════════════════════════════════════════════════════════
+/** Teleport state enum (matches contract) */
+export var TeleportState;
+(function (TeleportState) {
+    TeleportState[TeleportState["INITIATED"] = 0] = "INITIATED";
+    TeleportState[TeleportState["SHIELDED"] = 1] = "SHIELDED";
+    TeleportState[TeleportState["SWAP_COMPLETE"] = 2] = "SWAP_COMPLETE";
+    TeleportState[TeleportState["EXPORTED"] = 3] = "EXPORTED";
+    TeleportState[TeleportState["COMPLETED"] = 4] = "COMPLETED";
+    TeleportState[TeleportState["CANCELLED"] = 5] = "CANCELLED";
+    TeleportState[TeleportState["EXPIRED"] = 6] = "EXPIRED";
+})(TeleportState || (TeleportState = {}));
+export const DEFAULT_PRIVATE_TELEPORT_CONFIG = {
+    networkId: 1,
+    teleportContract: '0x0000000000000000000000000000000000000420',
+    zNoteContract: '0x0000000000000000000000000000000000000421',
+    zChainAMMContract: '0x0000000000000000000000000000000000000422',
+    privateBridgeContract: '0x0000000000000000000000000000000000000423',
+    warpPrecompile: '0x0200000000000000000000000000000000000005',
+    defaultDeadline: 3600,
+    minShieldBlocks: 5,
+};
+export const LUX_CHAINS = {
+    xChain: {
+        chainId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        name: 'X-Chain (XVM)',
+        type: 'xvm',
+    },
+    cChain: {
+        chainId: '0x0000000000000000000000000000000000000000000000000000000000000001',
+        name: 'C-Chain (EVM)',
+        type: 'cchain',
+    },
+    zChain: {
+        chainId: '0x0000000000000000000000000000000000000000000000000000000000000002',
+        name: 'Z-Chain (Privacy)',
+        type: 'zchain',
+    },
+};
+// ═══════════════════════════════════════════════════════════════════════════
+// CONTRACT ABIS (PARTIAL)
+// ═══════════════════════════════════════════════════════════════════════════
+export const PRIVATE_TELEPORT_ABI = [
+    // ═══════════════════════════════════════════════════════════════════════════
+    // INITIATE & SWAP
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        name: 'initiateTeleport',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'warpMessage', type: 'bytes' },
+            { name: 'commitment', type: 'bytes32' },
+            { name: 'encryptedAmount', type: 'bytes32' },
+            { name: 'recipient', type: 'address' },
+            { name: 'destChain', type: 'bytes32' },
+            { name: 'destAsset', type: 'bytes32' },
+            { name: 'privateSwap', type: 'bool' },
+        ],
+        outputs: [{ name: 'teleportId', type: 'bytes32' }],
+    },
+    {
+        name: 'executePrivateSwap',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'minOutput', type: 'bytes32' },
+            { name: 'proof', type: 'bytes' },
+        ],
+        outputs: [],
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // EXPORT (UNSHIELD)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        name: 'exportToDestination',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'rangeProof', type: 'bytes' },
+            { name: 'nullifier', type: 'bytes32' },
+            { name: 'merkleProof', type: 'bytes32[]' },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'unshieldToXChain',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'destinationAddress', type: 'bytes' },
+            { name: 'amount', type: 'uint64' },
+            { name: 'nullifier', type: 'bytes32' },
+            { name: 'merkleProof', type: 'bytes32[]' },
+            { name: 'rangeProof', type: 'bytes' },
+        ],
+        outputs: [{ name: 'exportTxId', type: 'bytes32' }],
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PRIVATE TRANSFERS (STAY SHIELDED)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        name: 'privateTransferToRecipient',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'recipientCommitment', type: 'bytes32' },
+            { name: 'encryptedNote', type: 'bytes' },
+            { name: 'nullifier', type: 'bytes32' },
+            { name: 'merkleProof', type: 'bytes32[]' },
+            { name: 'transferProof', type: 'bytes' },
+        ],
+        outputs: [{ name: 'newNoteIndex', type: 'uint256' }],
+    },
+    {
+        name: 'splitAndTransfer',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'outputs', type: 'tuple[]', components: [
+                    { name: 'commitment', type: 'bytes32' },
+                    { name: 'encryptedNote', type: 'bytes' },
+                    { name: 'encryptedMemo', type: 'bytes' },
+                ] },
+            { name: 'nullifier', type: 'bytes32' },
+            { name: 'merkleProof', type: 'bytes32[]' },
+            { name: 'splitProof', type: 'bytes' },
+        ],
+        outputs: [{ name: 'noteIndices', type: 'uint256[]' }],
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // COMPLETE & CANCEL
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        name: 'completeTeleport',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'teleportId', type: 'bytes32' },
+            { name: 'warpConfirmation', type: 'bytes' },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'cancelTeleport',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [{ name: 'teleportId', type: 'bytes32' }],
+        outputs: [],
+    },
+    {
+        name: 'getTeleport',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'teleportId', type: 'bytes32' }],
+        outputs: [
+            {
+                name: '',
+                type: 'tuple',
+                components: [
+                    { name: 'teleportId', type: 'bytes32' },
+                    { name: 'state', type: 'uint8' },
+                    { name: 'sourceChain', type: 'bytes32' },
+                    { name: 'destChain', type: 'bytes32' },
+                    { name: 'sourceAsset', type: 'bytes32' },
+                    { name: 'destAsset', type: 'bytes32' },
+                    { name: 'noteCommitment', type: 'bytes32' },
+                    { name: 'encryptedAmount', type: 'bytes32' },
+                    { name: 'nullifierHash', type: 'bytes32' },
+                    { name: 'sender', type: 'address' },
+                    { name: 'recipient', type: 'address' },
+                    { name: 'deadline', type: 'uint256' },
+                    { name: 'createdBlock', type: 'uint256' },
+                    { name: 'privateSwap', type: 'bool' },
+                ],
+            },
+        ],
+    },
+    {
+        name: 'isComplete',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'teleportId', type: 'bytes32' }],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+    {
+        name: 'isExpired',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'teleportId', type: 'bytes32' }],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+];
+export const ZNOTE_ABI = [
+    {
+        name: 'importFromXChain',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'commitment', type: 'bytes32' },
+            { name: 'encryptedAmount', type: 'bytes32' },
+            { name: 'assetId', type: 'bytes32' },
+            { name: 'recipient', type: 'address' },
+        ],
+        outputs: [{ name: 'noteIndex', type: 'uint256' }],
+    },
+    {
+        name: 'verifyMerkleProof',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'proof', type: 'bytes32[]' },
+            { name: 'commitment', type: 'bytes32' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+    {
+        name: 'getMerkleProof',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'noteIndex', type: 'uint256' }],
+        outputs: [{ name: 'proof', type: 'bytes32[]' }],
+    },
+    {
+        name: 'getNoteRoot',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'bytes32' }],
+    },
+    {
+        name: 'getNote',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'commitment', type: 'bytes32' }],
+        outputs: [
+            {
+                name: '',
+                type: 'tuple',
+                components: [
+                    { name: 'commitment', type: 'bytes32' },
+                    { name: 'encryptedOwner', type: 'bytes' },
+                    { name: 'encryptedValue', type: 'bytes' },
+                    { name: 'assetId', type: 'bytes32' },
+                    { name: 'createdAt', type: 'uint64' },
+                ],
+            },
+        ],
+    },
+];
+export const ZCHAIN_AMM_ABI = [
+    {
+        name: 'swapEncrypted',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'poolId', type: 'bytes32' },
+            { name: 'encryptedAmount', type: 'bytes32' },
+            { name: 'encryptedMinOutput', type: 'bytes32' },
+            { name: 'recipient', type: 'address' },
+        ],
+        outputs: [{ name: 'outputCommitment', type: 'bytes32' }],
+    },
+    {
+        name: 'verifySwapProof',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'proof', type: 'bytes' },
+            { name: 'commitment', type: 'bytes32' },
+            { name: 'poolId', type: 'bytes32' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+    {
+        name: 'getPool',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'poolId', type: 'bytes32' }],
+        outputs: [
+            {
+                name: '',
+                type: 'tuple',
+                components: [
+                    { name: 'poolId', type: 'bytes32' },
+                    { name: 'assetA', type: 'bytes32' },
+                    { name: 'assetB', type: 'bytes32' },
+                    { name: 'feeRate', type: 'uint16' },
+                    { name: 'active', type: 'bool' },
+                ],
+            },
+        ],
+    },
+];

package/dist/bridge/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Cross-chain bridge types for XVM ↔ C-Chain atomic swaps
+ */
+export type CrossChainMintStatus = 'idle' | 'initiating' | 'locking' | 'waiting_confirmation' | 'minting' | 'swapping' | 'complete' | 'failed' | 'cancelled';
+export interface CrossChainMintRequest {
+    /** Source chain (XVM) asset ID */
+    sourceAsset: `0x${string}`;
+    /** Amount to bridge (in source chain decimals) */
+    amount: bigint;
+    /** Recipient address on C-Chain */
+    recipient: `0x${string}`;
+    /** Optional: target token on C-Chain (if swap desired) */
+    targetToken?: `0x${string}`;
+    /** Minimum amount to receive (slippage protection) */
+    minReceive?: bigint;
+    /** Deadline timestamp in seconds */
+    deadline: number;
+}
+export interface CrossChainMintState {
+    /** Unique swap ID from bridge */
+    swapId: `0x${string}` | null;
+    /** Current status of the mint operation */
+    status: CrossChainMintStatus;
+    /** Source transaction hash on X-Chain */
+    sourceTxHash: string | null;
+    /** Mint transaction hash on C-Chain */
+    mintTxHash: string | null;
+    /** Swap transaction hash (if target token specified) */
+    swapTxHash: string | null;
+    /** Error message if failed */
+    error: string | null;
+    /** Timestamp when operation started */
+    startedAt: number | null;
+    /** Timestamp when operation completed */
+    completedAt: number | null;
+}
+export interface SwapRoute {
+    tokenIn: `0x${string}`;
+    tokenOut: `0x${string}`;
+    poolFee: number;
+    tickSpacing: number;
+    hooks?: `0x${string}`;
+}
+export interface AtomicSwapConfig {
+    /** Network ID for Warp messages */
+    networkId: number;
+    /** XVM chain ID */
+    xvmChainId: `0x${string}`;
+    /** C-Chain ID */
+    cChainId: `0x${string}`;
+    /** Warp precompile address */
+    warpPrecompile: `0x${string}`;
+    /** Atomic swap bridge contract on C-Chain */
+    bridgeContract: `0x${string}`;
+    /** Default deadline in seconds */
+    defaultDeadline: number;
+}
+export declare const DEFAULT_SWAP_CONFIG: AtomicSwapConfig;
+/**
+ * XVM asset mapping to C-Chain wrapped tokens
+ */
+export interface AssetMapping {
+    /** XVM asset ID */
+    xvmAssetId: `0x${string}`;
+    /** C-Chain wrapped token address */
+    wrappedToken: `0x${string}`;
+    /** Token symbol */
+    symbol: string;
+    /** Token decimals (always 6 for XVM) */
+    decimals: number;
+}
+/**
+ * Well-known asset mappings for Lux mainnet
+ */
+export declare const ASSET_MAPPINGS: AssetMapping[];
+/**
+ * Get wrapped token address for an XVM asset
+ */
+export declare function getWrappedToken(xvmAssetId: `0x${string}`): `0x${string}` | null;
+/**
+ * Get XVM asset ID for a wrapped token
+ */
+export declare function getXvmAsset(wrappedToken: `0x${string}`): `0x${string}` | null;
+//# sourceMappingURL=types.d.ts.map

package/dist/bridge/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/bridge/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,YAAY,GACZ,SAAS,GACT,sBAAsB,GACtB,SAAS,GACT,UAAU,GACV,UAAU,GACV,QAAQ,GACR,WAAW,CAAA;AAEf,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAA;IAC1B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,mCAAmC;IACnC,SAAS,EAAE,KAAK,MAAM,EAAE,CAAA;IACxB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;IAC3B,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,iCAAiC;IACjC,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,IAAI,CAAA;IAC5B,2CAA2C;IAC3C,MAAM,EAAE,oBAAoB,CAAA;IAC5B,yCAAyC;IACzC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,uCAAuC;IACvC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,wDAAwD;IACxD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,uCAAuC;IACvC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,yCAAyC;IACzC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,KAAK,MAAM,EAAE,CAAA;IACtB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,mBAAmB;IACnB,UAAU,EAAE,KAAK,MAAM,EAAE,CAAA;IACzB,iBAAiB;IACjB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAA;IACvB,8BAA8B;IAC9B,cAAc,EAAE,KAAK,MAAM,EAAE,CAAA;IAC7B,6CAA6C;IAC7C,cAAc,EAAE,KAAK,MAAM,EAAE,CAAA;IAC7B,kCAAkC;IAClC,eAAe,EAAE,MAAM,CAAA;CACxB;AAED,eAAO,MAAM,mBAAmB,EAAE,gBAOjC,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,mBAAmB;IACnB,UAAU,EAAE,KAAK,MAAM,EAAE,CAAA;IACzB,oCAAoC;IACpC,YAAY,EAAE,KAAK,MAAM,EAAE,CAAA;IAC3B,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,EAQxC,CAAA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,MAAM,EAAE,GAAG,IAAI,CAG/E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,KAAK,MAAM,EAAE,GAAG,KAAK,MAAM,EAAE,GAAG,IAAI,CAK7E"}

package/dist/bridge/types.js

@@ -0,0 +1,37 @@
+/**
+ * Cross-chain bridge types for XVM ↔ C-Chain atomic swaps
+ */
+export const DEFAULT_SWAP_CONFIG = {
+    networkId: 1,
+    xvmChainId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    cChainId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    warpPrecompile: '0x0200000000000000000000000000000000000005',
+    bridgeContract: '0x0000000000000000000000000000000000000410',
+    defaultDeadline: 3600, // 1 hour
+};
+/**
+ * Well-known asset mappings for Lux mainnet
+ */
+export const ASSET_MAPPINGS = [
+    {
+        xvmAssetId: '0x0000000000000000000000000000000000000000000000000000000000000001',
+        wrappedToken: '0x0000000000000000000000000000000000000001', // WLUX
+        symbol: 'WLUX',
+        decimals: 6,
+    },
+    // Add more mappings as tokens are registered
+];
+/**
+ * Get wrapped token address for an XVM asset
+ */
+export function getWrappedToken(xvmAssetId) {
+    const mapping = ASSET_MAPPINGS.find((m) => m.xvmAssetId === xvmAssetId);
+    return mapping?.wrappedToken ?? null;
+}
+/**
+ * Get XVM asset ID for a wrapped token
+ */
+export function getXvmAsset(wrappedToken) {
+    const mapping = ASSET_MAPPINGS.find((m) => m.wrappedToken.toLowerCase() === wrappedToken.toLowerCase());
+    return mapping?.xvmAssetId ?? null;
+}

package/dist/bridge/use-cross-chain-mint.d.ts

@@ -0,0 +1,34 @@
+/**
+ * React hook for one-click cross-chain minting
+ *
+ * Enables users to mint wrapped tokens on C-Chain from X-Chain assets
+ * with a single transaction using Warp atomic swaps.
+ */
+import { type CrossChainStore } from './cross-chain-store';
+import type { CrossChainMintRequest, CrossChainMintState, AtomicSwapConfig } from './types';
+export interface UseCrossChainMintOptions {
+    /** Configuration overrides */
+    config?: Partial<AtomicSwapConfig>;
+    /** Poll interval for status updates (ms) */
+    pollInterval?: number;
+}
+export interface UseCrossChainMintReturn {
+    /** Initiate a cross-chain mint */
+    mint: (request: Omit<CrossChainMintRequest, 'deadline'> & {
+        deadline?: number;
+    }) => Promise<string>;
+    /** Cancel a pending mint after deadline */
+    cancel: (swapId: string) => Promise<void>;
+    /** Current state of a mint by swap ID */
+    getMintState: (swapId: string) => CrossChainMintState | undefined;
+    /** All active mints */
+    activeMints: CrossChainStore['pendingMints'];
+    /** Recent completed mints */
+    recentMints: CrossChainStore['recentMints'];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message */
+    error: string | null;
+}
+export declare function useCrossChainMint(options?: UseCrossChainMintOptions): UseCrossChainMintReturn;
+//# sourceMappingURL=use-cross-chain-mint.d.ts.map

package/dist/bridge/use-cross-chain-mint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cross-chain-mint.d.ts","sourceRoot":"","sources":["../../src/bridge/use-cross-chain-mint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC9E,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EAGnB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAgBhB,MAAM,WAAW,wBAAwB;IACvC,8BAA8B;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAClC,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACnG,2CAA2C;IAC3C,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACzC,yCAAyC;IACzC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,mBAAmB,GAAG,SAAS,CAAA;IACjE,uBAAuB;IACvB,WAAW,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IAC5C,6BAA6B;IAC7B,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,CAAA;IAC3C,oBAAoB;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,oBAAoB;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,uBAAuB,CAiPjG"}