@actioncodes/protocol 1.2.2 → 2.0.1

package/dist/adapters/solana/solana.js

@@ -1,537 +0,0 @@
-"use strict";
-// Copyright 2025 Trana, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const spl_memo_1 = require("@solana/spl-memo");
-const meta_1 = require("../../meta");
-const base_1 = require("../base");
-const nacl = __importStar(require("tweetnacl"));
-const actioncode_1 = require("../../actioncode");
-const buffer_1 = require("buffer");
-const bs58_1 = __importDefault(require("bs58"));
-/**
- * Simple Solana adapter for protocol meta operations
- * Supports both legacy and versioned transactions
- */
-class SolanaAdapter extends base_1.BaseChainAdapter {
-    constructor() {
-        super(...arguments);
-        this.chain = 'solana';
-    }
-    /**
-     * Encode protocol meta as a Solana memo instruction
-     * @param meta - The protocol meta to encode
-     * @returns TransactionInstruction for the memo
-     */
-    encodeMeta(meta) {
-        const metaString = meta_1.ProtocolMetaParser.serialize(meta);
-        const signerPubkeys = [];
-        try {
-            if (meta.iss && meta.iss !== 'undefined') {
-                const pubkey = new web3_js_1.PublicKey(meta.iss);
-                signerPubkeys.push(pubkey);
-            }
-        }
-        catch (error) {
-            // Ignore error, issuer is not a valid public key
-        }
-        return (0, spl_memo_1.createMemoInstruction)(metaString, signerPubkeys);
-    }
-    /**
-     * Decode protocol meta from Solana transaction (legacy or versioned)
-     * @param tx - The Solana transaction (can be deserialized object or base64 string)
-     * @returns Decoded ProtocolMetaV1 or null if not found
-     */
-    decodeMeta(tx) {
-        // If it's a string, deserialize it first
-        if (typeof tx === 'string') {
-            try {
-                tx = this.deserializeTransaction(tx);
-            }
-            catch {
-                return null;
-            }
-        }
-        // Check if it's a versioned transaction
-        if ('message' in tx && tx.message) {
-            return this.decodeVersionedTransaction(tx);
-        }
-        else if ('instructions' in tx && Array.isArray(tx.instructions)) {
-            return this.decodeLegacyTransaction(tx);
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * Deserialize a Solana transaction from base64 string
-     * @param base64String - Base64 encoded transaction
-     * @returns SolanaTransaction object
-     */
-    deserializeTransaction(base64String) {
-        try {
-            const buffer = buffer_1.Buffer.from(base64String, 'base64');
-            // Try legacy first, then versioned
-            try {
-                return web3_js_1.Transaction.from(buffer);
-            }
-            catch {
-                return web3_js_1.VersionedTransaction.deserialize(buffer);
-            }
-        }
-        catch (error) {
-            throw new Error('Failed to deserialize Solana transaction');
-        }
-    }
-    /**
-     * Inject protocol meta into Solana transaction
-     * @param serializedTx - Serialized transaction string (base64)
-     * @param meta - ProtocolMetaV1 object
-     * @returns Serialized transaction with injected meta
-     */
-    injectMeta(serializedTx, meta) {
-        // Deserialize the transaction using existing pattern
-        const tx = this.deserializeTransaction(serializedTx);
-        const metaIx = this.encodeMeta(meta);
-        if (tx instanceof web3_js_1.VersionedTransaction) {
-            // Convert TransactionInstruction to MessageCompiledInstruction for versioned transactions
-            // Create new static account keys array with all required keys
-            const newStaticAccountKeys = [...tx.message.staticAccountKeys];
-            // Add any missing keys from the memo instruction
-            metaIx.keys.forEach(({ pubkey }) => {
-                if (!newStaticAccountKeys.some(key => key.equals(pubkey))) {
-                    newStaticAccountKeys.push(pubkey);
-                }
-            });
-            // Ensure programId is also in static keys
-            if (!newStaticAccountKeys.some(key => key.equals(metaIx.programId))) {
-                newStaticAccountKeys.push(metaIx.programId);
-            }
-            // Create new compiled instructions array
-            const newCompiledInstructions = [...tx.message.compiledInstructions];
-            // Find the program ID index in the new static keys
-            const programIdIndex = newStaticAccountKeys.findIndex(key => key.equals(metaIx.programId));
-            const accountKeyIndexes = metaIx.keys.map(key => {
-                const index = newStaticAccountKeys.findIndex(staticKey => staticKey.equals(key.pubkey));
-                if (index === -1) {
-                    throw new Error(`Account key ${key.pubkey.toBase58()} not found in static account keys`);
-                }
-                return index;
-            });
-            const compiledInstruction = {
-                programIdIndex,
-                accountKeyIndexes,
-                data: metaIx.data
-            };
-            newCompiledInstructions.push(compiledInstruction);
-            // Create new MessageV0 with updated data
-            const newMessage = new web3_js_1.MessageV0({
-                header: tx.message.header,
-                staticAccountKeys: newStaticAccountKeys,
-                recentBlockhash: tx.message.recentBlockhash,
-                compiledInstructions: newCompiledInstructions,
-                addressTableLookups: tx.message.addressTableLookups,
-            });
-            // Create new VersionedTransaction
-            const newVersionedTx = new web3_js_1.VersionedTransaction(newMessage);
-            return buffer_1.Buffer.from(newVersionedTx.serialize()).toString('base64');
-        }
-        else if (tx instanceof web3_js_1.Transaction) {
-            tx.instructions.push(metaIx);
-            // Clear existing signatures since we modified the transaction
-            tx.signatures = [];
-            // Serialize the transaction back without requiring signatures
-            return tx.serialize({ requireAllSignatures: false }).toString('base64');
-        }
-        else {
-            throw new Error('Invalid transaction type');
-        }
-    }
-    /**
-     * Validate transaction with protocol meta and authority list
-     * @param tx - The Solana transaction
-     * @param authorities - Array of valid protocol authority public keys (base58)
-     * @param expectedPrefix - Expected protocol prefix (default: 'DEFAULT')
-     * @returns True if transaction is valid
-     */
-    validate(tx, authorities, expectedPrefix = 'DEFAULT') {
-        return this.detectTampering(tx, authorities, expectedPrefix);
-    }
-    /**
-     * Check if the issuer has signed the transaction
-     * @param tx - The Solana transaction (can be deserialized object or base64 string)
-     * @param issuer - Issuer public key to check
-     * @returns True if issuer has signed
-     */
-    hasIssuerSignature(tx, issuer) {
-        // If it's a string, deserialize it first
-        if (typeof tx === 'string') {
-            try {
-                tx = this.deserializeTransaction(tx);
-            }
-            catch {
-                return false;
-            }
-        }
-        // Check if it's a versioned transaction
-        if ('message' in tx && tx.message) {
-            return this.hasIssuerSignatureVersioned(tx, issuer);
-        }
-        else if ('signatures' in tx && Array.isArray(tx.signatures)) {
-            return this.hasIssuerSignatureLegacy(tx, issuer);
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Decode protocol meta from legacy Solana transaction
-     */
-    decodeLegacyTransaction(transaction) {
-        for (const instruction of transaction.instructions) {
-            if (instruction.programId.equals(SolanaAdapter.MEMO_PROGRAM_ID)) {
-                const memoData = instruction.data;
-                if (memoData && memoData.length > 0) {
-                    try {
-                        const memoString = new TextDecoder().decode(memoData);
-                        const meta = meta_1.ProtocolMetaParser.parse(memoString);
-                        if (meta && meta.version === '1') {
-                            return meta;
-                        }
-                        // Continue searching if this memo is not a valid protocol meta
-                    }
-                    catch {
-                        // Continue searching if this memo cannot be parsed
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Decode protocol meta from versioned Solana transaction
-     */
-    decodeVersionedTransaction(transaction) {
-        const message = transaction.message;
-        if (message instanceof web3_js_1.MessageV0) {
-            return this.decodeMessageV0(message);
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * Decode protocol meta from MessageV0
-     */
-    decodeMessageV0(message) {
-        for (const instruction of message.compiledInstructions) {
-            const programId = message.staticAccountKeys[instruction.programIdIndex];
-            if (programId.equals(SolanaAdapter.MEMO_PROGRAM_ID)) {
-                const memoData = instruction.data;
-                if (memoData && memoData.length > 0) {
-                    try {
-                        const memoString = new TextDecoder().decode(memoData);
-                        const meta = meta_1.ProtocolMetaParser.parse(memoString);
-                        if (meta && meta.version === '1') {
-                            return meta;
-                        }
-                        // Continue searching if this memo is not a valid protocol meta
-                    }
-                    catch {
-                        // Continue searching if this memo cannot be parsed
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if the issuer has signed a legacy transaction
-     */
-    hasIssuerSignatureLegacy(transaction, issuer) {
-        return transaction.signatures.some(sig => sig.publicKey.toBase58() === issuer);
-    }
-    /**
-     * Check if the issuer has signed a versioned transaction
-     */
-    hasIssuerSignatureVersioned(transaction, issuer) {
-        const message = transaction.message;
-        if (message instanceof web3_js_1.MessageV0) {
-            // Check static account keys
-            for (const key of message.staticAccountKeys) {
-                if (key.toBase58() === issuer) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Validate Solana transaction integrity with additional checks
-     * @param tx - The Solana transaction
-     * @param meta - Decoded protocol meta
-     * @returns True if transaction integrity is valid
-     */
-    validateTransactionIntegrity(tx, meta) {
-        // Additional Solana-specific validation can be added here
-        // For example, checking transaction signatures, recent blockhash, etc.
-        // Verify that the memo instruction contains the expected protocol meta
-        const decodedMeta = this.decodeMeta(tx);
-        if (!decodedMeta) {
-            return false;
-        }
-        if (!meta.iss) {
-            return false;
-        }
-        if (!this.hasIssuerSignature(tx, meta.iss)) {
-            return false;
-        }
-        // Cross-check the decoded meta with the provided meta
-        return (decodedMeta.version === meta.version &&
-            decodedMeta.prefix === meta.prefix &&
-            decodedMeta.initiator === meta.initiator &&
-            decodedMeta.id === meta.id &&
-            decodedMeta.iss === meta.iss &&
-            decodedMeta.params === meta.params);
-    }
-    verifyCodeSignature(actionCode) {
-        try {
-            const message = this.getCodeSignatureMessage(actionCode.code, actionCode.timestamp, actionCode.prefix);
-            const messageBytes = new TextEncoder().encode(message);
-            const pubkeyBytes = new web3_js_1.PublicKey(actionCode.pubkey).toBytes();
-            const sigBytes = bs58_1.default.decode(actionCode.signature);
-            return nacl.sign.detached.verify(messageBytes, sigBytes, pubkeyBytes);
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Decode protocol meta from base64 string (for backward compatibility)
-     * @param base64String - Base64 encoded transaction
-     * @returns Decoded ProtocolMetaV1 or null
-     */
-    decodeFromBase64(base64String) {
-        return this.decodeMeta(base64String);
-    }
-    /**
-     * Sign the transaction with the protocol key
-     * @param actionCode - The action code containing the transaction
-     * @param key - The keypair to sign with
-     * @returns Promise that resolves to the signed action code
-     */
-    async signWithProtocolKey(actionCode, key) {
-        try {
-            if (!actionCode.transaction?.transaction) {
-                throw new Error('No transaction found');
-            }
-            const tx = this.deserializeTransaction(actionCode.transaction.transaction);
-            // Check if transaction has protocol meta
-            const meta = this.decodeMeta(tx);
-            if (!meta) {
-                throw new Error('Invalid transaction, protocol meta not found');
-            }
-            // Validate transaction integrity
-            if (!this.validateTransactionIntegrity(tx, meta)) {
-                throw new Error('Invalid transaction, transaction integrity not valid');
-            }
-            // Sign the transaction
-            if (tx instanceof web3_js_1.Transaction) {
-                tx.partialSign(key);
-            }
-            else if (tx instanceof web3_js_1.VersionedTransaction) {
-                tx.sign([key]);
-            }
-            else {
-                throw new Error('Invalid transaction type');
-            }
-            const updatedTransaction = {
-                ...actionCode.transaction,
-                transaction: tx.serialize({ requireAllSignatures: false }).toString('base64'),
-            };
-            const updatedFields = {
-                ...actionCode.json,
-                transaction: updatedTransaction,
-            };
-            return actioncode_1.ActionCode.fromPayload(updatedFields);
-        }
-        catch (error) {
-            throw new Error(`Failed to sign transaction with protocol key: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * Verify the finalized transaction from blockchain
-     * @param tx - The finalized transaction response from blockchain
-     * @param actionCode - The action code to verify against
-     * @returns True if the transaction is valid and matches the action code
-     */
-    verifyFinalizedTransaction(tx, actionCode) {
-        try {
-            // Handle null/undefined transaction
-            if (tx.transaction === null || tx.transaction === undefined) {
-                return false;
-            }
-            // Both legacy and versioned responses have message and signatures
-            const response = tx.transaction;
-            if (!response.message || !response.signatures) {
-                return false;
-            }
-            let transaction;
-            // Check if it's a versioned transaction by looking at the message structure
-            if (response.message instanceof web3_js_1.MessageV0) {
-                // Versioned transaction - reconstruct from message and signatures
-                transaction = new web3_js_1.VersionedTransaction(response.message);
-                // Note: In a real scenario, signatures would be attached, but for testing we just need the message
-            }
-            else {
-                // Legacy transaction - reconstruct from compiled message and signatures
-                const compiledMessage = response.message;
-                transaction = web3_js_1.Transaction.populate(compiledMessage, response.signatures);
-            }
-            const meta = this.decodeMeta(transaction);
-            if (!meta) {
-                return false; // No protocol meta found
-            }
-            if (!meta.iss) {
-                return false; // No issuer field in meta
-            }
-            if (!actionCode.codeHash) {
-                return false; // No codeHash available
-            }
-            if (!meta.id || meta.id !== actionCode.codeHash) {
-                return false; // ID doesn't match expected value
-            }
-            if (meta.prefix !== actionCode.prefix) {
-                return false;
-            }
-            if (meta.initiator !== actionCode.pubkey) {
-                return false;
-            }
-            let userPubkey = null;
-            try {
-                userPubkey = new web3_js_1.PublicKey(actionCode.pubkey);
-            }
-            catch (error) {
-                return false;
-            }
-            if (userPubkey) {
-                if (transaction instanceof web3_js_1.VersionedTransaction) {
-                    const message = transaction.message;
-                    if (message instanceof web3_js_1.MessageV0) {
-                        // Check if user's public key is in the static account keys
-                        const userKeyIndex = message.staticAccountKeys.findIndex(key => key.equals(userPubkey));
-                        if (userKeyIndex === -1) {
-                            return false; // User's key not found in transaction
-                        }
-                        // Check if user's key is a signer (first bit of header indicates signer status)
-                        const isUserSigner = (message.header.numRequiredSignatures > 0) &&
-                            (userKeyIndex < message.header.numRequiredSignatures);
-                        if (!isUserSigner) {
-                            return false; // User didn't sign the transaction
-                        }
-                    }
-                    else {
-                        return false; // Unsupported message type
-                    }
-                }
-                else if (transaction instanceof web3_js_1.Transaction) {
-                    // For legacy transactions, check if user's key is in the account keys
-                    const accountKeys = transaction.compileMessage().accountKeys;
-                    const userKeyIndex = accountKeys.findIndex(key => key.equals(userPubkey));
-                    if (userKeyIndex === -1) {
-                        return false; // User's key not found in transaction
-                    }
-                    // Check if user's key is a signer
-                    const isUserSigner = userKeyIndex < transaction.compileMessage().header.numRequiredSignatures;
-                    if (!isUserSigner) {
-                        return false; // User didn't sign the transaction
-                    }
-                }
-                else {
-                    return false; // Invalid transaction type
-                }
-            }
-            // 5. Check that tx is signed by protocol (issuer)
-            if (!this.hasIssuerSignature(transaction, meta.iss)) {
-                return false; // Protocol didn't sign the transaction
-            }
-            // All checks passed
-            return true;
-        }
-        catch (error) {
-            // If any error occurs during verification, return false
-            return false;
-        }
-    }
-    /**
-     * Validate a signed message for sign-only mode
-     * @param message - The message that was signed
-     * @param signedMessage - The signed message (base64 or hex)
-     * @param pubkey - The public key that should have signed the message
-     * @returns True if the signature is valid
-     */
-    validateSignedMessage(message, signedMessage, pubkey) {
-        try {
-            // Decode the public key (base58)
-            const publicKeyBytes = bs58_1.default.decode(pubkey);
-            // Decode the signature as base58 (Solana convention)
-            const signature = bs58_1.default.decode(signedMessage);
-            const messageBuffer = buffer_1.Buffer.from(message, 'utf8');
-            return nacl.sign.detached.verify(messageBuffer, signature, publicKeyBytes);
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-exports.SolanaAdapter = SolanaAdapter;
-SolanaAdapter.MEMO_PROGRAM_ID = spl_memo_1.MEMO_PROGRAM_ID;

package/dist/codegen.d.ts

@@ -1,76 +0,0 @@
-export declare class CodeGenerator {
-    static TIME_WINDOW_MS: number;
-    static CODE_DIGITS: number;
-    static MIN_PREFIX_LENGTH: number;
-    static MAX_PREFIX_LENGTH: number;
-    /**
-     * Validate prefix format
-     * @param prefix - The prefix to validate
-     * @returns True if prefix is valid, false otherwise
-     */
-    static validatePrefix(prefix: string): boolean;
-    /**
-     * Validate generated code format (prefix + exactly 8 digits)
-     * @param code - The code to validate
-     * @returns True if code is valid, false otherwise
-     */
-    static validateCodeFormat(code: string): boolean;
-    /**
-     * Validate that the numeric part of a code is exactly 8 digits
-     * @param code - The code to validate (can include prefix)
-     * @returns True if numeric part is valid, false otherwise
-     */
-    static validateCodeDigits(code: string): boolean;
-    /**
-     * Normalize prefix - convert PROTOCOL_CODE_PREFIX to empty string, validate others
-     * @param prefix - The prefix to normalize
-     * @returns Normalized prefix
-     * @throws Error if prefix is invalid
-     */
-    static normalizePrefix(prefix: string): string;
-    /**
-     * Generate a deterministic 8-digit code based on public key, prefix, and timestamp
-     * @param pubkey - Solana wallet public key (base58)
-     * @param prefix - Optional namespace prefix (default: PROTOCOL_CODE_PREFIX)
-     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
-     * @returns Object containing code, issuedAt, and expiresAt timestamps
-     * @throws Error if generated code is invalid
-     */
-    static generateCode(pubkey: string, prefix?: string, timestamp?: number): {
-        code: string;
-        issuedAt: number;
-        expiresAt: number;
-    };
-    /**
-     * Derive the full SHA-256 hash for storage or encryption key generation
-     * @param pubkey - Solana wallet public key (base58)
-     * @param prefix - Optional namespace prefix (default: PROTOCOL_CODE_PREFIX)
-     * @param timestamp - UNIX timestamp in milliseconds (defaults to now)
-     * @returns Full SHA-256 hash string
-     */
-    static deriveCodeHash(pubkey: string, prefix?: string, timestamp?: number): string;
-    /**
-     * Get the expected code for a given public key and timestamp
-     * @param pubkey - Solana wallet public key (base58)
-     * @param timestamp - UNIX timestamp in milliseconds
-     * @param prefix - Optional namespace prefix (default: PROTOCOL_CODE_PREFIX)
-     * @returns Full code string with prefix + 8 digits
-     */
-    static getExpectedCode(pubkey: string, timestamp: number, prefix?: string): string;
-    /**
-     * Validate if a code matches the expected code for a given public key and timestamp
-     * @param code - The code to validate (can include prefix)
-     * @param pubkey - Solana wallet public key (base58)
-     * @param timestamp - UNIX timestamp in milliseconds
-     * @param prefix - Optional namespace prefix (default: PROTOCOL_CODE_PREFIX)
-     * @returns True if code matches expected code and timestamp is valid
-     */
-    static validateCode(code: string, pubkey: string, timestamp: number, prefix?: string): boolean;
-    /**
-     * Check if a timestamp falls within a valid time window
-     * @param timestamp - UNIX timestamp in milliseconds
-     * @returns True if timestamp is valid
-     */
-    static isValidTimestamp(timestamp: number): boolean;
-}
-//# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAiBA,qBAAa,aAAa;IACtB,MAAM,CAAC,cAAc,SAAY;IACjC,MAAM,CAAC,WAAW,SAAe;IACjC,MAAM,CAAC,iBAAiB,SAAqB;IAC7C,MAAM,CAAC,iBAAiB,SAAqB;IAE7C;;;;OAIG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAM9C;;;;OAIG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAoChD;;;;OAIG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAkChD;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAQ9C;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CACf,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAA6B,EACrC,SAAS,GAAE,MAAmB,GAC/B;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAiCxD;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAA6B,EACrC,SAAS,CAAC,EAAE,MAAM,GACnB,MAAM;IAQT;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAA6B,GACtC,MAAM;IAIT;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAA6B,GACtC,OAAO;IAgBV;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAGtD"}