0xtrails 0.0.1 → 0.0.2

package/dist/intents.js

@@ -0,0 +1,288 @@
+import { Config, Payload } from "@0xsequence/wallet-primitives";
+import { AbiParameters, Address, Bytes, ContractAddress, Hash, } from "ox";
+import { isAddressEqual, } from "viem";
+import { ATTESATION_SIGNER_ADDRESS } from "./constants.js";
+import { findPreconditionAddresses } from "./preconditions.js";
+export async function getIntentCallsPayloads(apiClient, args) {
+    return apiClient.getIntentCallsPayloads(args);
+}
+export function calculateIntentAddress(mainSigner, calls) {
+    console.log("[trails-sdk] calculateIntentAddress inputs:", {
+        mainSigner,
+        calls: JSON.stringify(calls, null, 2),
+    });
+    const context = {
+        factory: "0xBd0F8abD58B4449B39C57Ac9D5C67433239aC447",
+        stage1: "0x53bA242E7C2501839DF2972c75075dc693176Cd0",
+        stage2: "0xa29874c88b8Fd557e42219B04b0CeC693e1712f5",
+        creationCode: "0x603e600e3d39601e805130553df33d3d34601c57363d3d373d363d30545af43d82803e903d91601c57fd5bf3",
+    };
+    const coreCalls = calls.map((call) => ({
+        type: "call",
+        chainId: call.chainId.toString(),
+        space: call.space ? call.space.toString() : "0",
+        nonce: call.nonce ? call.nonce.toString() : "0",
+        calls: call.calls.map((call) => ({
+            to: Address.from(call.to),
+            value: call.value?.toString() || "0",
+            data: Bytes.toHex(Bytes.from(call.data || "0x")),
+            gasLimit: call.gasLimit?.toString() || "0",
+            delegateCall: !!call.delegateCall,
+            onlyFallback: !!call.onlyFallback,
+            behaviorOnError: call.behaviorOnError,
+        })),
+    }));
+    const calculatedAddress = calculateIntentConfigurationAddress(Address.from(mainSigner), coreCalls, context);
+    console.log("[trails-sdk] Final calculated address:", calculatedAddress.toString());
+    return calculatedAddress;
+}
+export function calculateOriginAndDestinationIntentAddresses(mainSigner, calls) {
+    const originChainId = calls[0]?.chainId;
+    const destinationChainId = calls[1]?.chainId;
+    console.log("[trails-sdk] originChainId:", originChainId);
+    console.log("[trails-sdk] destinationChainId:", destinationChainId);
+    // Different origin and destination chains: cross-chain execution.
+    const originCalls = calls.filter((c) => c.chainId === originChainId);
+    const destinationCalls = calls.filter((c) => c.chainId === destinationChainId);
+    console.log("[trails-sdk] originCalls:", originCalls);
+    console.log("[trails-sdk] destinationCalls:", destinationCalls);
+    const originIntentAddress = calculateIntentAddress(mainSigner, originCalls);
+    const destinationIntentAddress = calculateIntentAddress(mainSigner, destinationCalls);
+    console.log("[trails-sdk] originIntentAddress:", originIntentAddress);
+    console.log("[trails-sdk] destinationIntentAddress:", destinationIntentAddress);
+    return { originIntentAddress, destinationIntentAddress };
+}
+export function commitIntentConfig(apiClient, mainSignerAddress, calls, preconditions) {
+    console.log("[trails-sdk] commitIntentConfig inputs:", {
+        mainSignerAddress,
+        calls: JSON.stringify(calls, null, 2),
+        preconditions: JSON.stringify(preconditions, null, 2),
+    });
+    const { originIntentAddress, destinationIntentAddress } = calculateOriginAndDestinationIntentAddresses(mainSignerAddress, calls);
+    console.log("[trails-sdk] originIntentAddress:", originIntentAddress.toString());
+    console.log("[trails-sdk] destinationIntentAddress:", destinationIntentAddress.toString());
+    const originChainIdStr = calls[0]?.chainId;
+    const destinationChainIdStr = calls[1]?.chainId;
+    // The executionInfos could be empty, so we need to handle the undefined case.
+    const { originAddress: receivedAddress } = originChainIdStr && destinationChainIdStr
+        ? findPreconditionAddresses(preconditions, Number(originChainIdStr), Number(destinationChainIdStr))
+        : { originAddress: undefined };
+    console.log("[trails-sdk] Address comparison:", {
+        receivedAddress,
+        calculatedAddress: originIntentAddress.toString(),
+        match: receivedAddress &&
+            isAddressEqual(Address.from(receivedAddress), originIntentAddress),
+    });
+    const args = {
+        originIntentAddress: originIntentAddress.toString(),
+        destinationIntentAddress: destinationIntentAddress.toString(),
+        mainSigner: mainSignerAddress,
+        calls: calls,
+        preconditions: preconditions,
+    };
+    return apiClient.commitIntentConfig(args);
+}
+export async function sendOriginTransaction(account, walletClient, originParams) {
+    const chainId = await walletClient.getChainId();
+    if (chainId.toString() !== originParams.chain.id.toString()) {
+        console.log("[trails-sdk] sendOriginTransaction: switching chain", "want:", originParams.chain.id, "current:", chainId);
+        await walletClient.switchChain({ id: originParams.chain.id });
+        console.log("[trails-sdk] sendOriginTransaction: switched chain to", originParams.chain.id);
+    }
+    console.log("[trails-sdk] sending origin tx");
+    console.time("[trails-sdk] sendTx");
+    const hash = await walletClient.sendTransaction({
+        account: account,
+        to: originParams.to,
+        data: originParams.data,
+        value: BigInt(originParams.value),
+        chain: originParams.chain,
+    });
+    console.timeEnd("[trails-sdk] sendTx");
+    return hash;
+}
+export function hashIntentParams({ userAddress, nonce, originTokens, destinationCalls, destinationTokens, }) {
+    if (!userAddress ||
+        userAddress === "0x0000000000000000000000000000000000000000")
+        throw new Error("UserAddress is zero");
+    if (typeof nonce !== "bigint")
+        throw new Error("Nonce is not a bigint");
+    if (!originTokens || originTokens.length === 0)
+        throw new Error("OriginTokens is empty");
+    if (!destinationCalls || destinationCalls.length === 0)
+        throw new Error("DestinationCalls is empty");
+    if (!destinationTokens || destinationTokens.length === 0)
+        throw new Error("DestinationTokens is empty");
+    for (let i = 0; i < destinationCalls.length; i++) {
+        const currentCall = destinationCalls[i];
+        if (!currentCall)
+            throw new Error(`DestinationCalls[${i}] is nil`);
+        if (!currentCall.calls || currentCall.calls.length === 0) {
+            throw new Error(`DestinationCalls[${i}] has no calls`);
+        }
+    }
+    const originTokensForAbi = originTokens.map((token) => ({
+        address: token.address,
+        chainId: token.chainId,
+    }));
+    let cumulativeCallsHashBytes = Bytes.from(new Uint8Array(32));
+    for (let i = 0; i < destinationCalls.length; i++) {
+        const callPayload = destinationCalls[i];
+        if (!callPayload)
+            throw new Error(`DestinationCalls[${i}] is nil`);
+        const currentDestCallPayloadHashBytes = Payload.hash(ATTESATION_SIGNER_ADDRESS, BigInt(callPayload.chainId), {
+            type: "call",
+            space: callPayload.space ? BigInt(callPayload.space) : 0n,
+            nonce: callPayload.nonce ? BigInt(callPayload.nonce) : 0n,
+            calls: callPayload.calls.map((call) => ({
+                type: "call",
+                to: call.to,
+                value: BigInt(call.value?.toString() || "0"),
+                data: Bytes.toHex(Bytes.from(call.data || "0x")),
+                gasLimit: BigInt(call.gasLimit?.toString() || "0"),
+                delegateCall: !!call.delegateCall,
+                onlyFallback: !!call.onlyFallback,
+                behaviorOnError: call.behaviorOnError === 0
+                    ? "ignore"
+                    : call.behaviorOnError === 1
+                        ? "revert"
+                        : "abort",
+            })),
+        });
+        cumulativeCallsHashBytes = Hash.keccak256(Bytes.concat(cumulativeCallsHashBytes, currentDestCallPayloadHashBytes), {
+            as: "Bytes",
+        });
+    }
+    const cumulativeCallsHashHex = Bytes.toHex(cumulativeCallsHashBytes);
+    const destinationTokensForAbi = destinationTokens.map((token) => ({
+        address: token.address,
+        chainId: token.chainId,
+        amount: token.amount,
+    }));
+    const abiSchema = [
+        { type: "address" },
+        { type: "uint256" },
+        {
+            type: "tuple[]",
+            components: [
+                { name: "address", type: "address" },
+                { name: "chainId", type: "uint256" },
+            ],
+        },
+        {
+            type: "tuple[]",
+            components: [
+                { name: "address", type: "address" },
+                { name: "chainId", type: "uint256" },
+                { name: "amount", type: "uint256" },
+            ],
+        },
+        { type: "bytes32" },
+    ];
+    const encodedHex = AbiParameters.encode(abiSchema, [
+        userAddress,
+        nonce,
+        originTokensForAbi,
+        destinationTokensForAbi,
+        cumulativeCallsHashHex,
+    ]);
+    const encodedBytes = Bytes.fromHex(encodedHex);
+    const hashBytes = Hash.keccak256(encodedBytes);
+    const hashHex = Bytes.toHex(hashBytes);
+    return hashHex;
+}
+// TODO: Add proper type
+export function bigintReplacer(_key, value) {
+    return typeof value === "bigint" ? value.toString() : value;
+}
+export function calculateIntentConfigurationAddress(mainSigner, calls, context) {
+    const config = createIntentConfiguration(mainSigner, calls);
+    // Calculate the image hash of the configuration
+    const imageHash = Config.hashConfiguration(config);
+    // Calculate the counterfactual address using the image hash and context
+    return ContractAddress.fromCreate2({
+        from: context.factory,
+        bytecodeHash: Hash.keccak256(Bytes.concat(Bytes.from(context.creationCode), Bytes.padLeft(Bytes.from(context.stage1), 32)), { as: "Bytes" }),
+        salt: imageHash,
+    });
+}
+function createIntentConfiguration(mainSigner, calls) {
+    const mainSignerLeaf = {
+        type: "signer",
+        address: mainSigner,
+        weight: 1n,
+    };
+    console.log("[trails-sdk] mainSignerLeaf:", mainSignerLeaf);
+    const subdigestLeaves = calls.map((call) => {
+        const digest = Payload.hash(Address.from("0x0000000000000000000000000000000000000000"), BigInt(call.chainId), {
+            type: "call",
+            space: BigInt(call.space || 0),
+            nonce: BigInt(call.nonce || 0),
+            calls: call.calls.map((call) => ({
+                type: "call",
+                to: call.to,
+                value: BigInt(call.value?.toString() || "0"),
+                data: Bytes.toHex(Bytes.from(call.data || "0x")),
+                gasLimit: BigInt(call.gasLimit?.toString() || "0"),
+                delegateCall: !!call.delegateCall,
+                onlyFallback: !!call.onlyFallback,
+                behaviorOnError: call.behaviorOnError === 0
+                    ? "ignore"
+                    : call.behaviorOnError === 1
+                        ? "revert"
+                        : "abort",
+            })),
+        });
+        console.log("[trails-sdk] digest:", Bytes.toHex(digest));
+        return {
+            type: "any-address-subdigest",
+            digest: Bytes.toHex(digest),
+        };
+    });
+    console.log("[trails-sdk] calls:", calls);
+    console.log("[trails-sdk] subdigestLeaves:", subdigestLeaves);
+    const otherLeaves = [...subdigestLeaves];
+    if (otherLeaves.length === 0) {
+        throw new Error("Intent configuration must have at least one call or LiFi information.");
+    }
+    let secondaryTopologyNode;
+    if (otherLeaves.length === 1) {
+        secondaryTopologyNode = otherLeaves[0];
+    }
+    else {
+        secondaryTopologyNode = buildMerkleTreeFromMembers(otherLeaves);
+    }
+    // Print the topology
+    console.log("[trails-sdk] Topology:", JSON.stringify([mainSignerLeaf, secondaryTopologyNode], bigintReplacer, 2));
+    return {
+        threshold: 1n,
+        checkpoint: 0n,
+        topology: [mainSignerLeaf, secondaryTopologyNode],
+    };
+}
+// Renamed and generalized from createSubdigestTree
+function buildMerkleTreeFromMembers(members) {
+    if (members.length === 0) {
+        throw new Error("Cannot create a tree from empty members");
+    }
+    if (members.length === 1) {
+        return members[0]; // Returns a single Leaf or a Node
+    }
+    let currentLevel = [...members];
+    while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            if (i + 1 < currentLevel.length) {
+                const right = currentLevel[i + 1];
+                nextLevel.push([left, right]);
+            }
+            else {
+                // Odd one out, carries over to the next level
+                nextLevel.push(left);
+            }
+        }
+        currentLevel = nextLevel;
+    }
+    return currentLevel[0];
+}

package/dist/metaTxnMonitor.d.ts

@@ -0,0 +1,14 @@
+import type { Relayer } from "@0xsequence/wallet-core";
+export type MetaTxn = {
+    id: string;
+    chainId: string;
+    contract?: string | undefined;
+    input?: string | undefined;
+    walletAddress?: string | undefined;
+};
+export type MetaTxnStatus = {
+    [key: string]: Relayer.OperationStatus;
+};
+export declare const getMetaTxStatus: (relayer: Relayer.Standard.Rpc.RpcRelayer, metaTxId: string, chainId: number) => Promise<Relayer.OperationStatus>;
+export declare const useMetaTxnsMonitor: (metaTxns: MetaTxn[] | undefined, getRelayer: (chainId: number) => Relayer.Standard.Rpc.RpcRelayer) => MetaTxnStatus;
+//# sourceMappingURL=metaTxnMonitor.d.ts.map

package/dist/metaTxnMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metaTxnMonitor.d.ts","sourceRoot":"","sources":["../src/metaTxnMonitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAKtD,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAA;CACvC,CAAA;AAID,eAAO,MAAM,eAAe,GAC1B,SAAS,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EACxC,UAAU,MAAM,EAChB,SAAS,MAAM,KACd,OAAO,CAAC,OAAO,CAAC,eAAe,CAEjC,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,UAAU,OAAO,EAAE,GAAG,SAAS,EAC/B,YAAY,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,kBAqIjE,CAAA"}

package/dist/metaTxnMonitor.js

@@ -0,0 +1,121 @@
+import { useQueries } from "@tanstack/react-query";
+import { useMemo } from "react";
+const POLL_INTERVAL = 3_000; // 3 seconds
+export const getMetaTxStatus = async (relayer, metaTxId, chainId) => {
+    return relayer.status(metaTxId, BigInt(chainId));
+};
+export const useMetaTxnsMonitor = (metaTxns, getRelayer) => {
+    const results = useQueries({
+        queries: (metaTxns || []).map((metaTxn) => {
+            const opHashToPoll = metaTxn.id;
+            return {
+                queryKey: ["metaTxnStatus", metaTxn.chainId, metaTxn.id],
+                queryFn: async () => {
+                    const relayer = getRelayer(parseInt(metaTxn.chainId));
+                    if (!opHashToPoll) {
+                        return {
+                            status: "failed",
+                            reason: "Missing operation hash for monitoring.",
+                        };
+                    }
+                    if (!relayer) {
+                        return {
+                            status: "failed",
+                            reason: `Relayer not available for chain ${metaTxn.chainId}.`,
+                        };
+                    }
+                    const opStatus = await relayer.status(opHashToPoll, BigInt(metaTxn.chainId));
+                    let newStatusEntry;
+                    if (opStatus.status === "confirmed") {
+                        newStatusEntry = {
+                            status: "confirmed",
+                            transactionHash: opStatus.transactionHash,
+                            data: opStatus.data,
+                        };
+                    }
+                    else if (opStatus.status === "failed") {
+                        newStatusEntry = {
+                            status: "failed",
+                            reason: opStatus.reason,
+                            data: opStatus.data,
+                        };
+                    }
+                    else if (opStatus.status === "pending") {
+                        newStatusEntry = {
+                            status: "pending",
+                        };
+                    }
+                    else if (opStatus.status === "unknown") {
+                        newStatusEntry = {
+                            status: "unknown",
+                        };
+                    }
+                    else {
+                        const originalStatus = opStatus.status;
+                        console.warn(`[trails-sdk] ⚠️ Unexpected relayer status "${originalStatus}" for ${opHashToPoll}:`, opStatus);
+                        newStatusEntry = {
+                            status: "unknown",
+                        };
+                    }
+                    return newStatusEntry;
+                },
+                refetchInterval: (query) => {
+                    const data = query.state.data;
+                    if (!data)
+                        return POLL_INTERVAL;
+                    if (data.status === "confirmed")
+                        return false;
+                    return POLL_INTERVAL;
+                },
+                enabled: !!metaTxn && !!metaTxn.id && !!metaTxn.chainId,
+                retry: (failureCount, error) => {
+                    if (failureCount >= 30) {
+                        console.error(`[trails-sdk] ❌ Giving up on transaction ${opHashToPoll} after 3 failed API attempts:`, error);
+                        return false;
+                    }
+                    return true;
+                },
+            };
+        }),
+    });
+    const statuses = useMemo(() => {
+        const newStatuses = {};
+        (metaTxns || []).forEach((metaTxn, index) => {
+            const operationKey = `${metaTxn.chainId}-${metaTxn.id}`;
+            const queryResult = results[index];
+            if (queryResult) {
+                if (queryResult.isLoading &&
+                    queryResult.fetchStatus !== "idle" &&
+                    !queryResult.data) {
+                    newStatuses[operationKey] = {
+                        status: "pending",
+                    };
+                }
+                else if (queryResult.isError) {
+                    newStatuses[operationKey] = {
+                        status: "failed",
+                        reason: queryResult.error?.message ||
+                            "An unknown error occurred",
+                    };
+                }
+                else if (queryResult.data) {
+                    newStatuses[operationKey] =
+                        queryResult.data;
+                }
+                else {
+                    newStatuses[operationKey] = {
+                        status: "unknown",
+                    };
+                }
+            }
+            else {
+                newStatuses[operationKey] = {
+                    status: "failed",
+                    reason: "Query result unexpectedly missing",
+                };
+            }
+        });
+        return newStatuses;
+    }, [metaTxns, results]);
+    return statuses;
+};

package/dist/metaTxns.d.ts

@@ -0,0 +1,6 @@
+import type { IntentPrecondition } from "@0xsequence/trails-api";
+import type { Relayer } from "@0xsequence/wallet-core";
+import type { Hex } from "viem";
+import type { MetaTxn } from "./metaTxnMonitor.js";
+export declare function relayerSendMetaTx(relayer: Relayer.Standard.Rpc.RpcRelayer, metaTx: MetaTxn, preconditions: IntentPrecondition[]): Promise<Hex>;
+//# sourceMappingURL=metaTxns.d.ts.map

package/dist/metaTxns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metaTxns.d.ts","sourceRoot":"","sources":["../src/metaTxns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACtD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EACxC,MAAM,EAAE,OAAO,EACf,aAAa,EAAE,kBAAkB,EAAE,GAClC,OAAO,CAAC,GAAG,CAAC,CAWd"}

package/dist/metaTxns.js

@@ -0,0 +1,4 @@
+export async function relayerSendMetaTx(relayer, metaTx, preconditions) {
+    const { opHash } = await relayer.sendMetaTxn(metaTx.walletAddress, metaTx.contract, metaTx.input, BigInt(metaTx.chainId), undefined, preconditions);
+    return opHash;
+}

package/dist/paymasterSend.d.ts

@@ -0,0 +1,90 @@
+import type { Account, Chain, PublicClient, WalletClient } from "viem";
+import type { UserOperation } from "viem/account-abstraction";
+import type { ToSimpleSmartAccountReturnType } from "./toSimpleSmartAccount.js";
+interface PackedCall {
+    to: `0x${string}`;
+    value: bigint;
+    gasLimit: bigint;
+    behaviorOnError: number;
+    data: `0x${string}`;
+}
+interface Payload {
+    kind: number;
+    noChainId: boolean;
+    space: number;
+    nonce: number;
+    parentWallets: string[];
+    calls: PackedCall[];
+}
+export declare const ENTRYPOINT_ABI: ({
+    name: string;
+    type: string;
+    stateMutability: string;
+    inputs: ({
+        name: string;
+        type: string;
+        components: {
+            name: string;
+            type: string;
+        }[];
+    } | {
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    outputs: never[];
+} | {
+    name: string;
+    type: string;
+    stateMutability: string;
+    inputs: {
+        name: string;
+        type: string;
+        components: {
+            name: string;
+            type: string;
+        }[];
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+})[];
+export declare function packPayload(payload: Payload): `0x${string}`;
+export declare function getDelegatorSmartAccount({ publicClient, }: {
+    publicClient: PublicClient;
+}): Promise<ToSimpleSmartAccountReturnType>;
+export declare function getPaymasterGaslessTransaction({ walletClient, chain, tokenAddress, amount, recipient, delegatorSmartAccount, }: {
+    walletClient: WalletClient;
+    chain: Chain;
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    recipient: `0x${string}`;
+    delegatorSmartAccount: ToSimpleSmartAccountReturnType;
+}): Promise<{
+    to: string;
+    data: string;
+    value: string;
+}[]>;
+export declare function sendPaymasterGaslessTransaction({ walletClient, publicClient, chain, paymasterUrl, delegatorSmartAccount, calls, }: {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    chain: Chain;
+    paymasterUrl: string;
+    delegatorSmartAccount: ToSimpleSmartAccountReturnType;
+    calls: {
+        to: string;
+        data: string;
+        value: string;
+    }[];
+}): Promise<string>;
+export type stakeOnEntryPointParams = {
+    relayerClient: WalletClient;
+    relayerAccount: Account;
+    delegatorAddress: `0x${string}`;
+    chain: Chain;
+};
+export declare function stakeOnEntryPoint({ relayerClient, relayerAccount, delegatorAddress, chain, }: stakeOnEntryPointParams): Promise<`0x${string}`>;
+export declare const getRequiredPrefund: (userOperation: UserOperation) => bigint;
+export {};
+//# sourceMappingURL=paymasterSend.d.ts.map

package/dist/paymasterSend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymasterSend.d.ts","sourceRoot":"","sources":["../src/paymasterSend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAatE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAc7D,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAA;AAK/E,UAAU,UAAU;IAClB,EAAE,EAAE,KAAK,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,IAAI,EAAE,KAAK,MAAM,EAAE,CAAA;CACpB;AAED,UAAU,OAAO;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB;AAMD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0D1B,CAAA;AAMD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,MAAM,EAAE,CAqB3D;AAID,wBAAsB,wBAAwB,CAAC,EAC7C,YAAY,GACb,EAAE;IACD,YAAY,EAAE,YAAY,CAAA;CAC3B,GAAG,OAAO,CAAC,8BAA8B,CAAC,CA4B1C;AAED,wBAAsB,8BAA8B,CAAC,EACnD,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,MAAM,EACN,SAAS,EACT,qBAAqB,GACtB,EAAE;IACD,YAAY,EAAE,YAAY,CAAA;IAC1B,KAAK,EAAE,KAAK,CAAA;IACZ,YAAY,EAAE,KAAK,MAAM,EAAE,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,KAAK,MAAM,EAAE,CAAA;IACxB,qBAAqB,EAAE,8BAA8B,CAAA;CACtD,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAsDzD;AAED,wBAAsB,+BAA+B,CAAC,EACpD,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,qBAAqB,EACrB,KAAK,GACN,EAAE;IACD,YAAY,EAAE,YAAY,CAAA;IAC1B,YAAY,EAAE,YAAY,CAAA;IAC1B,KAAK,EAAE,KAAK,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,qBAAqB,EAAE,8BAA8B,CAAA;IACrD,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CACrD,GAAG,OAAO,CAAC,MAAM,CAAC,CAwKlB;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,YAAY,CAAA;IAC3B,cAAc,EAAE,OAAO,CAAA;IACvB,gBAAgB,EAAE,KAAK,MAAM,EAAE,CAAA;IAC/B,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,KAAK,GACN,EAAE,uBAAuB,0BA+CzB;AAED,eAAO,MAAM,kBAAkB,GAAI,eAAe,aAAa,WAW9D,CAAA"}