@openserv-labs/client 2.0.2 → 2.1.2

package/dist/erc8004-api.js

@@ -0,0 +1,491 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Erc8004API = void 0;
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const pinata_1 = require("pinata");
+const erc8004_abi_js_1 = require("./erc8004-abi.js");
+const erc8004_contracts_js_1 = require("./erc8004-contracts.js");
+/**
+ * API for ERC-8004 agent identity operations on the OpenServ platform.
+ *
+ * ERC-8004 is an on-chain agent identity standard. This API enables:
+ * - Deploying workspace agents to the blockchain as ERC-8004 tokens
+ * - Managing web3 wallets associated with workspaces
+ * - Presigning IPFS URLs for uploading agent registration files
+ * - Querying callable triggers for on-chain service registration
+ * - Signing feedback auth for reputation interactions
+ *
+ * @example
+ * ```typescript
+ * const client = new PlatformClient({ apiKey: 'your-key' });
+ *
+ * // Generate a web3 wallet for the workspace
+ * const wallet = await client.workflows.generateWallet({ id: 123 });
+ *
+ * // Get a presigned IPFS URL for uploading the agent card
+ * const { url } = await client.erc8004.presignIpfsUrl({ workflowId: 123 });
+ *
+ * // Deploy to ERC-8004
+ * await client.erc8004.deploy({
+ *   workflowId: 123,
+ *   erc8004AgentId: '8453:42',
+ *   stringifiedAgentCard: JSON.stringify(registrationFile),
+ *   walletAddress: '0x...',
+ *   network: 'base',
+ *   chainId: 8453,
+ * });
+ * ```
+ */
+class Erc8004API {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // ===========================================================================
+    // ERC-8004 Deployment
+    // ===========================================================================
+    /**
+     * Deploy a workspace agent to the ERC-8004 identity registry.
+     *
+     * This records the deployment details in the platform database. The actual
+     * on-chain registration should be performed separately using the agent0 SDK.
+     * Call this method both before and after blockchain registration to keep
+     * the platform in sync.
+     *
+     * If the deploy fails (e.g. insufficient ETH for gas), the error is
+     * enriched with the workspace wallet address and instructions for funding
+     * it so you can retry.
+     *
+     * @param params - Deployment parameters
+     * @param params.workflowId - The workflow (workspace) ID to deploy
+     * @param params.erc8004AgentId - Agent ID in format "chainId:tokenId"
+     * @param params.stringifiedAgentCard - JSON-stringified registration file
+     * @param params.latestDeploymentTransactionHash - Transaction hash from on-chain registration
+     * @param params.latestDeploymentTimestamp - Timestamp of the deployment
+     * @param params.walletAddress - Wallet address that performed the deployment
+     * @param params.network - Network name (e.g., "base")
+     * @param params.chainId - Chain ID (e.g., 8453 for Base mainnet)
+     * @param params.rpcUrl - RPC URL for the chain
+     * @param params.swap - If true, swap USDC in the wallet to ETH for gas before deploying (not yet implemented)
+     * @returns The updated workflow data
+     *
+     * @example
+     * ```typescript
+     * // Before blockchain registration (save initial state)
+     * await client.erc8004.deploy({
+     *   workflowId: 123,
+     *   erc8004AgentId: '',
+     *   stringifiedAgentCard: JSON.stringify(registrationFile),
+     *   walletAddress: '0x...',
+     *   network: 'base',
+     *   chainId: 8453,
+     *   rpcUrl: 'https://mainnet.base.org',
+     * });
+     *
+     * // ... perform on-chain registration ...
+     *
+     * // After blockchain registration (save final state with tx hash)
+     * await client.erc8004.deploy({
+     *   workflowId: 123,
+     *   erc8004AgentId: '8453:42',
+     *   stringifiedAgentCard: JSON.stringify(updatedRegistrationFile),
+     *   latestDeploymentTransactionHash: '0xabc...',
+     *   latestDeploymentTimestamp: new Date(),
+     *   walletAddress: '0x...',
+     *   network: 'base',
+     *   chainId: 8453,
+     *   rpcUrl: 'https://mainnet.base.org',
+     * });
+     * ```
+     */
+    async deploy(params) {
+        const { workflowId, swap, ...body } = params;
+        if (swap) {
+            throw new Error("USDC-to-ETH swap for gas is not yet implemented. " +
+                "This feature is coming soon. In the meantime, fund the workspace " +
+                "wallet with ETH directly and retry without the swap option.");
+        }
+        try {
+            return await this.client.put(`/workspaces/${workflowId}/erc-8004/deploy`, body);
+        }
+        catch (error) {
+            // Enrich the error with wallet info so the user knows where to send ETH
+            throw await this.enrichDeployError(error, workflowId);
+        }
+    }
+    /**
+     * Enrich a deploy error with the workspace wallet address and funding
+     * instructions. Called automatically when deploy() fails.
+     */
+    async enrichDeployError(originalError, workflowId) {
+        const originalMessage = originalError instanceof Error
+            ? originalError.message
+            : String(originalError);
+        let walletAddress = null;
+        try {
+            const wallet = await this.client.workflows.getWallet({ id: workflowId });
+            walletAddress = wallet.address;
+        }
+        catch {
+            // Wallet may not exist yet
+        }
+        const fundingHint = walletAddress
+            ? `\n\nWorkspace wallet address: ${walletAddress}\n` +
+                `Send ETH to this address to cover gas fees, then retry.` +
+                `\n\nNote: automatic USDC-to-ETH swap is coming soon. ` +
+                `Once available, pass swap: true to convert USDC in the wallet to ETH for gas.`
+            : `\n\nNo wallet found for this workspace. ` +
+                `Generate one first with client.workflows.generateWallet({ id: ${workflowId} }), ` +
+                `then fund it with ETH and retry.`;
+        return new Error(originalMessage + fundingHint);
+    }
+    // ===========================================================================
+    // Full On-Chain Registration
+    // ===========================================================================
+    /**
+     * Register (or re-deploy) a workspace agent on-chain as an ERC-8004 identity.
+     *
+     * This is a high-level method that orchestrates the entire deployment:
+     * 1. Reads workspace wallet and callable triggers
+     * 2. Builds the ERC-8004 agent card JSON
+     * 3. Uploads the agent card to IPFS via a presigned Pinata URL
+     * 4. Registers on-chain (first deploy) or updates the URI (re-deploy)
+     * 5. Saves the deployment state to the platform
+     *
+     * @param params.workflowId - The workflow (workspace) ID
+     * @param params.privateKey - Funded private key for on-chain transactions (must have ETH for gas)
+     * @param params.chainId - Chain ID (default: 8453 for Base mainnet)
+     * @param params.rpcUrl - RPC URL (default: "https://mainnet.base.org")
+     * @param params.name - Agent name override (defaults: single trigger → trigger name, else workspace name)
+     * @param params.description - Agent description override (defaults: single trigger → trigger description, else workspace goal + service list)
+     * @param params.image - Agent image URL (optional)
+     * @returns Deployment result with agentId, IPFS CID, transaction hash, and URLs
+     *
+     * @example
+     * ```typescript
+     * const result = await client.erc8004.registerOnChain({
+     *   workflowId: 123,
+     *   privateKey: '0x...',
+     *   name: 'My AI Agent',
+     *   description: 'An agent that does amazing things',
+     * });
+     * console.log(result.agentId);         // "8453:42"
+     * console.log(result.txHash);           // "0xabc..."
+     * console.log(result.ipfsCid);          // "bafkrei..."
+     * console.log(result.blockExplorerUrl); // "https://basescan.org/tx/0xabc..."
+     * console.log(result.scanUrl);          // "https://www.8004scan.io/agents/base/42"
+     * ```
+     */
+    async registerOnChain(params) {
+        const { workflowId, privateKey, chainId = 8453, rpcUrl = "https://mainnet.base.org", image, } = params;
+        // 1. Get wallet, callable triggers, and workspace data
+        const [wallet, callableTriggers, workspace] = await Promise.all([
+            this.client.workflows.getWallet({ id: workflowId }),
+            this.client.triggers.getCallableTriggers({ workflowId }),
+            this.client.workflows.get({ id: workflowId }),
+        ]);
+        // Derive name and description from triggers/workspace (matching monorepo logic)
+        let name = params.name;
+        let description = params.description;
+        if (!name || !description) {
+            if (callableTriggers.length === 1 && callableTriggers[0]) {
+                const t = callableTriggers[0];
+                if (!name)
+                    name = t.name || workspace.name;
+                if (!description)
+                    description = t.description || workspace.goal || "Default";
+            }
+            else {
+                if (!name)
+                    name = workspace.name;
+                if (!description) {
+                    const triggerBullets = callableTriggers
+                        .filter((t) => t.description)
+                        .map((t) => `- ${t.name}: ${t.description}`)
+                        .join("\n");
+                    description = [
+                        workspace.goal || "Default",
+                        ...(triggerBullets ? [`\nServices:\n${triggerBullets}`] : []),
+                    ].join("");
+                }
+            }
+        }
+        // 2. Build ERC-8004 agent card (matches monorepo addRegistrationFile format)
+        const baseUrl = this.client.rawClient.defaults.baseURL || "https://api.openserv.ai";
+        const services = [];
+        // MCP endpoint (machine-facing, aggregates all x402 triggers)
+        const mcpEndpoint = `${baseUrl}/workspaces/${workflowId}/trigger-x402-mcp/mcp`;
+        services.push({
+            name: "MCP",
+            endpoint: mcpEndpoint,
+            version: "2025-06-18",
+        });
+        for (const t of callableTriggers) {
+            const meta = {};
+            if (t.name)
+                meta.triggerName = t.name;
+            if (t.description)
+                meta.description = t.description;
+            // WEB endpoint (human-facing paywall URL)
+            services.push({
+                name: "web",
+                endpoint: t.webEndpoint,
+                ...(Object.keys(meta).length > 0 ? meta : {}),
+            });
+            // HTTP endpoint (machine-facing x402 URL)
+            if (t.httpEndpoint) {
+                const httpMeta = { ...meta };
+                if (t.inputSchema)
+                    httpMeta.inputSchema = t.inputSchema;
+                services.push({
+                    name: "http",
+                    endpoint: t.httpEndpoint,
+                    ...(Object.keys(httpMeta).length > 0 ? httpMeta : {}),
+                });
+            }
+        }
+        // Add walletAddress as an endpoint (deduplicate first)
+        if (wallet.address) {
+            const filtered = services.filter((s) => s.name !== "agentWallet" && s.name !== "wallet");
+            services.length = 0;
+            services.push(...filtered);
+            services.push({
+                name: "agentWallet",
+                endpoint: `eip155:${chainId}:${wallet.address}`,
+            });
+        }
+        // Build registrations array (populated on re-deploy)
+        const existingAgentId = wallet.erc8004AgentId;
+        const registrations = [];
+        if (existingAgentId) {
+            const [, tokenId] = existingAgentId.split(":");
+            if (tokenId) {
+                const contracts = (0, erc8004_contracts_js_1.getErc8004Contracts)(chainId);
+                registrations.push({
+                    agentId: Number.parseInt(tokenId, 10),
+                    agentRegistry: `eip155:${chainId}:${contracts.IDENTITY_REGISTRY}`,
+                });
+            }
+        }
+        const agentCard = {
+            type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
+            name,
+            description,
+            ...(image && { image }),
+            services,
+            ...(registrations.length > 0 && { registrations }),
+            active: true,
+            x402support: true,
+        };
+        const agentCardJson = JSON.stringify(agentCard);
+        // 3. Detect first deploy vs re-deploy
+        const isRedeploy = !!existingAgentId;
+        // 4. Save initial state
+        await this.deploy({
+            workflowId,
+            erc8004AgentId: existingAgentId ?? "",
+            stringifiedAgentCard: agentCardJson,
+            ...(wallet.address ? { walletAddress: wallet.address } : {}),
+            network: "base",
+            chainId,
+            rpcUrl,
+        });
+        // 5. Upload to IPFS
+        const { url: presignedUrl } = await this.presignIpfsUrl({ workflowId });
+        const ipfsCid = await this.uploadToIpfs(agentCardJson, presignedUrl);
+        // 6. On-chain registration
+        const contracts = (0, erc8004_contracts_js_1.getErc8004Contracts)(chainId);
+        const chainConfig = (0, erc8004_contracts_js_1.getErc8004Chain)(chainId);
+        const registryAddress = contracts.IDENTITY_REGISTRY;
+        // Build a viem Chain from the ERC-8004 chain config
+        const viemChain = chainConfig
+            ? (0, viem_1.defineChain)({
+                id: chainConfig.chainId,
+                name: chainConfig.name,
+                nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+                rpcUrls: {
+                    default: { http: [rpcUrl] },
+                },
+                blockExplorers: {
+                    default: {
+                        name: chainConfig.name,
+                        url: chainConfig.blockExplorerUrl,
+                    },
+                },
+                testnet: chainConfig.testnet,
+            })
+            : (0, viem_1.defineChain)({
+                id: chainId,
+                name: `Chain ${chainId}`,
+                nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+                rpcUrls: {
+                    default: { http: [rpcUrl] },
+                },
+            });
+        const normalizedKey = (privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`);
+        const account = (0, accounts_1.privateKeyToAccount)(normalizedKey);
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: viemChain,
+            transport: (0, viem_1.http)(rpcUrl),
+        });
+        const walletClient = (0, viem_1.createWalletClient)({
+            account,
+            chain: viemChain,
+            transport: (0, viem_1.http)(rpcUrl),
+        });
+        let agentId;
+        let txHash;
+        if (isRedeploy) {
+            // Re-deploy: just update the URI
+            const tokenId = existingAgentId.split(":")[1];
+            if (!tokenId) {
+                throw new Error(`Invalid existing agentId format: ${existingAgentId}`);
+            }
+            const hash = await walletClient.writeContract({
+                address: registryAddress,
+                abi: erc8004_abi_js_1.IDENTITY_REGISTRY_ABI,
+                functionName: "setAgentURI",
+                args: [BigInt(tokenId), `ipfs://${ipfsCid}`],
+            });
+            await publicClient.waitForTransactionReceipt({ hash });
+            txHash = hash;
+            agentId = existingAgentId;
+        }
+        else {
+            // First deploy: register then set URI
+            const registerHash = await walletClient.writeContract({
+                address: registryAddress,
+                abi: erc8004_abi_js_1.IDENTITY_REGISTRY_ABI,
+                functionName: "register",
+                args: [],
+            });
+            const registerReceipt = await publicClient.waitForTransactionReceipt({
+                hash: registerHash,
+            });
+            // Extract agentId from Registered or Transfer event
+            const tokenId = this.extractAgentIdFromReceipt(registerReceipt.logs, registryAddress);
+            agentId = `${chainId}:${tokenId}`;
+            // Set the IPFS URI
+            const uriHash = await walletClient.writeContract({
+                address: registryAddress,
+                abi: erc8004_abi_js_1.IDENTITY_REGISTRY_ABI,
+                functionName: "setAgentURI",
+                args: [BigInt(tokenId), `ipfs://${ipfsCid}`],
+            });
+            await publicClient.waitForTransactionReceipt({ hash: uriHash });
+            txHash = uriHash;
+        }
+        // 7. Save final state
+        await this.deploy({
+            workflowId,
+            erc8004AgentId: agentId,
+            stringifiedAgentCard: agentCardJson,
+            latestDeploymentTransactionHash: txHash,
+            latestDeploymentTimestamp: new Date(),
+            ...(wallet.address ? { walletAddress: wallet.address } : {}),
+            network: "base",
+            chainId,
+            rpcUrl,
+        });
+        const blockExplorerUrl = chainConfig
+            ? `${chainConfig.blockExplorerUrl}/tx/${txHash}`
+            : `https://basescan.org/tx/${txHash}`;
+        const network = chainConfig?.network ?? "base";
+        const tokenId = agentId.split(":")[1];
+        const scanUrl = `https://www.8004scan.io/agents/${network}/${tokenId}`;
+        return {
+            agentId,
+            ipfsCid,
+            txHash,
+            agentCardUrl: `https://gateway.pinata.cloud/ipfs/${ipfsCid}`,
+            blockExplorerUrl,
+            scanUrl,
+        };
+    }
+    /**
+     * Upload a JSON string to IPFS using a presigned Pinata URL.
+     */
+    async uploadToIpfs(jsonContent, presignedUrl) {
+        const pinata = new pinata_1.PinataSDK({
+            pinataJwt: "",
+            pinataGateway: "gateway.pinata.cloud",
+        });
+        const file = new File([jsonContent], "registration.json", {
+            type: "application/json",
+        });
+        const response = await pinata.upload.public.file(file).url(presignedUrl);
+        const cid = response.cid;
+        if (!cid) {
+            throw new Error(`No CID returned from Pinata. Response: ${JSON.stringify(response)}`);
+        }
+        return cid;
+    }
+    /**
+     * Extract the agent token ID from a registration transaction receipt.
+     * Looks for the Registered event first, then falls back to Transfer event.
+     */
+    extractAgentIdFromReceipt(logs, registryAddress) {
+        // Try Registered event first
+        for (const log of logs) {
+            if (log.address.toLowerCase() !== registryAddress.toLowerCase())
+                continue;
+            try {
+                const decoded = (0, viem_1.decodeEventLog)({
+                    abi: erc8004_abi_js_1.IDENTITY_REGISTRY_ABI,
+                    data: log.data,
+                    topics: log.topics,
+                });
+                if (decoded.eventName === "Registered") {
+                    const args = decoded.args;
+                    return args.agentId.toString();
+                }
+            }
+            catch {
+                // Not this event, try next
+            }
+        }
+        // Fallback to Transfer event (ERC-721 mint: from=0x0)
+        for (const log of logs) {
+            if (log.address.toLowerCase() !== registryAddress.toLowerCase())
+                continue;
+            try {
+                const decoded = (0, viem_1.decodeEventLog)({
+                    abi: erc8004_abi_js_1.IDENTITY_REGISTRY_ABI,
+                    data: log.data,
+                    topics: log.topics,
+                });
+                if (decoded.eventName === "Transfer") {
+                    const args = decoded.args;
+                    return args.tokenId.toString();
+                }
+            }
+            catch {
+                // Not this event, try next
+            }
+        }
+        throw new Error("Could not extract agent ID from transaction receipt. " +
+            "No Registered or Transfer event found.");
+    }
+    /**
+     * Get a presigned IPFS URL for uploading an agent registration file.
+     *
+     * The returned URL is a signed Pinata upload URL that expires in 60 seconds.
+     * Use it to upload the agent's registration file (agent card) to IPFS before
+     * on-chain registration.
+     *
+     * @param params - Parameters
+     * @param params.workflowId - The workflow (workspace) ID
+     * @returns Object containing the presigned IPFS upload URL
+     *
+     * @example
+     * ```typescript
+     * const { url } = await client.erc8004.presignIpfsUrl({ workflowId: 123 });
+     * // Use the URL to upload agent card to IPFS within 60 seconds
+     * ```
+     */
+    async presignIpfsUrl(params) {
+        return this.client.put(`/workspaces/${params.workflowId}/erc-8004/presign-ipfs-url`);
+    }
+}
+exports.Erc8004API = Erc8004API;

package/dist/erc8004-contracts.d.ts

@@ -0,0 +1,92 @@
+/**
+ * ERC-8004 contract addresses and chain configuration.
+ *
+ * Contract addresses sourced from the official erc-8004-contracts repository:
+ * https://github.com/erc-8004/erc-8004-contracts
+ *
+ * All mainnets share the same contract addresses.
+ * All testnets share the same contract addresses.
+ */
+/** Contract addresses shared across all ERC-8004 mainnets */
+export declare const ERC8004_MAINNET_CONTRACTS: {
+    readonly IDENTITY_REGISTRY: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+    readonly REPUTATION_REGISTRY: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63";
+};
+/** Contract addresses shared across all ERC-8004 testnets */
+export declare const ERC8004_TESTNET_CONTRACTS: {
+    readonly IDENTITY_REGISTRY: "0x8004A818BFB912233c491871b3d84c89A494BD9e";
+    readonly REPUTATION_REGISTRY: "0x8004B663056A597Dffe9eCcC1965A193B7388713";
+};
+/** Configuration for an ERC-8004 supported chain */
+export interface Erc8004ChainConfig {
+    /** Numeric chain ID */
+    chainId: number;
+    /** Human-readable network name */
+    network: string;
+    /** Display name */
+    name: string;
+    /** Whether this is a testnet */
+    testnet: boolean;
+    /** Default public RPC URL */
+    rpcUrl: string;
+    /** Block explorer base URL */
+    blockExplorerUrl: string;
+    /** ERC-8004 contract addresses */
+    contracts: {
+        IDENTITY_REGISTRY: string;
+        REPUTATION_REGISTRY: string;
+    };
+}
+/**
+ * All chains where ERC-8004 contracts are deployed.
+ *
+ * Source: https://github.com/erc-8004/erc-8004-contracts
+ */
+export declare const ERC8004_CHAINS: Record<number, Erc8004ChainConfig>;
+/**
+ * Get the ERC-8004 chain configuration for a given chain ID.
+ *
+ * @param chainId - The numeric chain ID
+ * @returns The chain configuration, or undefined if the chain is not supported
+ *
+ * @example
+ * ```typescript
+ * const baseConfig = getErc8004Chain(8453);
+ * console.log(baseConfig?.contracts.IDENTITY_REGISTRY);
+ * // "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
+ * ```
+ */
+export declare function getErc8004Chain(chainId: number): Erc8004ChainConfig | undefined;
+/**
+ * Get the ERC-8004 contract addresses for a given chain ID.
+ *
+ * @param chainId - The numeric chain ID
+ * @returns The contract addresses
+ * @throws Error if the chain ID is not supported
+ *
+ * @example
+ * ```typescript
+ * const contracts = getErc8004Contracts(8453);
+ * console.log(contracts.IDENTITY_REGISTRY);
+ * // "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
+ * ```
+ */
+export declare function getErc8004Contracts(chainId: number): {
+    IDENTITY_REGISTRY: string;
+    REPUTATION_REGISTRY: string;
+};
+/**
+ * List all supported ERC-8004 chain IDs.
+ *
+ * @param filter - Optional filter: "mainnet", "testnet", or undefined for all
+ * @returns Array of supported chain IDs
+ *
+ * @example
+ * ```typescript
+ * const allChains = listErc8004ChainIds();
+ * const mainnets = listErc8004ChainIds("mainnet");
+ * const testnets = listErc8004ChainIds("testnet");
+ * ```
+ */
+export declare function listErc8004ChainIds(filter?: "mainnet" | "testnet"): number[];
+//# sourceMappingURL=erc8004-contracts.d.ts.map

package/dist/erc8004-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc8004-contracts.d.ts","sourceRoot":"","sources":["../src/erc8004-contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,6DAA6D;AAC7D,eAAO,MAAM,yBAAyB;;;CAG5B,CAAC;AAEX,6DAA6D;AAC7D,eAAO,MAAM,yBAAyB;;;CAG5B,CAAC;AAMX,oDAAoD;AACpD,MAAM,WAAW,kBAAkB;IACjC,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,kCAAkC;IAClC,SAAS,EAAE;QACT,iBAAiB,EAAE,MAAM,CAAC;QAC1B,mBAAmB,EAAE,MAAM,CAAC;KAC7B,CAAC;CACH;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAwJpD,CAAC;AAMX;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GACd,kBAAkB,GAAG,SAAS,CAEhC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG;IACpD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CASA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,EAAE,CAQ5E"}