@hawksightco/hawk-sdk 1.3.265 → 1.3.267

package/dist/classes/TransactionBatchExecute.js

@@ -0,0 +1,466 @@
+"use strict";
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBatchExecute = void 0;
+const web3 = __importStar(require("@solana/web3.js"));
+const Logging_1 = require("./Logging");
+/**
+ * Executes transactions in batches
+ */
+class TransactionBatchExecute {
+    /**
+     * Creates an instance of TransactionExecute class
+     *
+     * @param lookupTableAddresses Address lookup table addresses to be used by batch of transactions
+     * @param instructions Array of instructions to be batched into transactions
+     * @param payer Payer that will pay for the batch of transactions
+     * @param connection Connection to mainnet
+     * @param signers Required signers to fulfill the transactions
+     */
+    constructor(lookupTableAddresses, instructions, payer, connection, signers = [], jupiterAlts) {
+        this.lookupTableAddresses = lookupTableAddresses;
+        this.instructions = instructions;
+        this.payer = payer;
+        this.connection = connection;
+        this.signers = signers;
+        this.jupiterAlts = jupiterAlts;
+        this.MAX_SIZE = 1232;
+        /**
+         * Downloaded address lookup table accounts
+         */
+        this.alts = [];
+        /**
+         * Map of public keys to address lookup table
+         */
+        this.pubkeyToAlt = {};
+    }
+    ;
+    /**
+     * Download all jupiter alts (overridable)
+     */
+    jupiterDownloadAlts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.jupiterAlts) {
+                yield this.jupiterAlts.downloadAlts();
+            }
+            else {
+                throw new Error('Unexpected error: jupiterDownloadAlts not implemented!');
+            }
+        });
+    }
+    /**
+     * Find alt by pubkeys (overridable)
+     */
+    jupiterFindAltByPubkeys(pubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.jupiterAlts) {
+                return this.jupiterAlts.findAltByPubkeys(pubkeys);
+            }
+            else {
+                throw new Error('Unexpected error: jupiterFindAltByPubkeys not implemented!');
+            }
+        });
+    }
+    /**
+     * Downoad address lookup table from given cluster
+     */
+    downloadAlts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Public keys across all instructions
+            const pubkeys = this.getPubkeyFromInstruction();
+            // Download jupiter alts first
+            yield this.jupiterDownloadAlts();
+            // Then find alts from pubkeys
+            const jupAlts = yield this.jupiterFindAltByPubkeys(pubkeys);
+            // Then append jupiter alts in the lookup table address
+            this.lookupTableAddresses.push(...jupAlts);
+            // Then make sure lookup table addresses are unique
+            this.filterLookupTables();
+            // Get list of lookup tables to download
+            const lookupTableAddresses = this.getListOfAltsToDownload();
+            // Download if address lookup table does not match with downloaded alts
+            yield this.downloadAlts2(lookupTableAddresses);
+            // Map public key to alt
+            const s0 = new Date().getTime() / 1000;
+            this.mapPubkeyToAlt(pubkeys);
+            (0, Logging_1.Log)(`TransactionBatchExecute::downloadAlts(): this.mapPubkeyToAlt benchmark: ${(new Date().getTime() / 1000) - s0}`);
+        });
+    }
+    /**
+     * Downoad address lookup table from given cluster
+     */
+    downloadAlts2(lookupTableAddresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const lookupTable of lookupTableAddresses) {
+                const alt = yield this.connection.getAddressLookupTable(lookupTable);
+                if (alt.value === null) {
+                    throw new Error(`Address lookup table: ${lookupTable} does not exist on the blockchain.`);
+                }
+                this.alts.push(alt.value);
+            }
+        });
+    }
+    /**
+     * Map public key to alt
+     *
+     * @param pubkeys
+     */
+    mapPubkeyToAlt(pubkeys) {
+        const addressesInAlt = [];
+        const map = {};
+        for (const alt of this.alts) {
+            const addresses = alt.state.addresses.map(p => p.toString());
+            addressesInAlt.push(...addresses);
+            map[alt.key.toString()] = [alt, addresses];
+        }
+        for (const pubkey of pubkeys) {
+            // If pubkey is not in alt, then skip
+            const inAlt = addressesInAlt.includes(pubkey.toString());
+            if (!inAlt)
+                continue;
+            // Find the alt where public key is included
+            for (const key in map) {
+                if (map[key][1].includes(pubkey.toString())) {
+                    this.pubkeyToAlt[pubkey.toString()] = map[key][0];
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Get list of lookup tables to download
+     */
+    getListOfAltsToDownload() {
+        const alts = this.alts.map(alt => alt.key.toBase58());
+        const toDownload = [];
+        for (const alt of this.lookupTableAddresses) {
+            if (!alts.includes(alt.toBase58())) {
+                toDownload.push(alt);
+            }
+        }
+        return toDownload;
+    }
+    /**
+     * Filter lookup tables
+     */
+    filterLookupTables() {
+        const map = {};
+        for (const alt of this.lookupTableAddresses) {
+            map[alt.toBase58()] = 1;
+        }
+        const filtered = [];
+        for (const alt in map) {
+            filtered.push(new web3.PublicKey(alt));
+        }
+        this.lookupTableAddresses = filtered;
+    }
+    /**
+     * Get public keys from instruction
+     * @returns
+     */
+    getPubkeyFromInstruction() {
+        const pubkeys = [];
+        this.instructions.map(ix => {
+            pubkeys.push(...ix.keys.map(meta => meta.pubkey));
+        });
+        return pubkeys;
+    }
+    /**
+     * Override signers (in case that signers are set to empty array)
+     *
+     * @param signers
+     */
+    setSigners(signers) {
+        this.signers = signers;
+    }
+    /**
+     * Find missing signers
+     */
+    findMissingSigners() {
+        const requiredSigners = this.findRequiredSigningPubkeys();
+        if (requiredSigners.length > this.signers.length) {
+            return requiredSigners;
+        }
+        const missingSigners = [];
+        for (const requiredSigner of requiredSigners) {
+            const match = this.signers.find(v => v.publicKey.toBase58() === requiredSigner.toBase58());
+            if (!!match)
+                continue;
+            missingSigners.push(requiredSigner);
+        }
+        return missingSigners;
+    }
+    /**
+     * Returns list of public keys that are required to sign the batch of transaction
+     */
+    findRequiredSigningPubkeys() {
+        return this.findRequiredSignersFromIxs(this.instructions);
+    }
+    /**
+     * Generate dummy signers needed for simulation
+     *
+     * @returns
+     */
+    generateDummySigners() {
+        const requiredSigners = this.findRequiredSigningPubkeys();
+        const dummySigners = {};
+        for (const signer of requiredSigners) {
+            dummySigners[signer.toString()] = web3.Keypair.generate();
+        }
+        return dummySigners;
+    }
+    /**
+     * Generate instruction that has modified signers for simulation purposes
+     */
+    generateSimulationIxs() {
+        const dummySigners = this.generateDummySigners();
+        let simulationIxs = this.instructions;
+        for (const pubkey in dummySigners) {
+            simulationIxs = simulationIxs.map(ix => {
+                const keys = ix.keys.map(meta => {
+                    if (meta.pubkey.toString() === pubkey && meta.isSigner) {
+                        return Object.assign(Object.assign({}, meta), { pubkey: dummySigners[pubkey].publicKey });
+                    }
+                    return meta;
+                });
+                return Object.assign(Object.assign({}, ix), { keys });
+            });
+        }
+        return [simulationIxs, dummySigners];
+    }
+    /**
+     * Builds a batch of executable transaction instructions
+     */
+    buildBatch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Download address lookup table from given cluster
+            yield this.downloadAlts();
+            // Generate dummy instructions for batch calculation
+            const [simulationIxs, dummySigners] = this.generateSimulationIxs();
+            // Split simulation ixs
+            const dummyBatches = yield this.splitToTransactions(simulationIxs, dummySigners);
+            // Batch of actual instructions
+            const batch = [];
+            let index = 0;
+            for (const dummyIxs of dummyBatches) {
+                const currentBatch = [];
+                for (const dummyIx of dummyIxs) {
+                    currentBatch.push(this.instructions[index++]);
+                }
+                batch.push(currentBatch);
+            }
+            return batch;
+        });
+    }
+    /**
+     * Build versioned transactions from given batches of transactions
+     *
+     * @param batches
+     * @returns
+     */
+    buildV0Transactions(batches) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlockhash = yield this.connection.getLatestBlockhash();
+            const signedVersionedTxs = [];
+            for (const batch of batches) {
+                const alts = this.findRequiredAltsForBatch(batch);
+                const messageV0 = new web3.TransactionMessage({
+                    payerKey: this.payer.publicKey,
+                    instructions: batch,
+                    recentBlockhash: latestBlockhash.blockhash,
+                }).compileToV0Message(alts);
+                const versionedTx = new web3.VersionedTransaction(messageV0);
+                const signers = this.findSigningKeypairFromIxs(batch);
+                versionedTx.sign(signers);
+                signedVersionedTxs.push(versionedTx);
+            }
+            return signedVersionedTxs;
+        });
+    }
+    /**
+     * Split transactions
+     *
+     * @param simulationIxs
+     * @param dummySigners
+     * @returns
+     */
+    splitToTransactions(simulationIxs, dummySigners) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Fetch latest blockhash required to calculate transaction size
+            const latestBlockhash = yield this.connection.getLatestBlockhash();
+            // Run simulation
+            let batch = [];
+            let result = [];
+            for (const ix of simulationIxs) {
+                // Include dummy ix to transaction
+                batch.push(ix);
+                // Calculate transaction size
+                const txSize = this.calculateTransactionSize(latestBlockhash, batch, dummySigners);
+                if (txSize > this.MAX_SIZE) {
+                    batch.pop();
+                    result.push(batch);
+                    batch = [ix];
+                }
+            }
+            if (batch.length > 0 && simulationIxs.length !== 0) {
+                result.push(batch);
+            }
+            return result;
+        });
+    }
+    /**
+     * Calculate transaction size
+     *
+     * @param batch
+     */
+    calculateTransactionSize(latestBlockhash, batch, dummySigners) {
+        const alts = this.findRequiredAltsForBatch(batch);
+        const messageV0 = new web3.TransactionMessage({
+            payerKey: this.payer.publicKey,
+            instructions: batch,
+            recentBlockhash: latestBlockhash.blockhash,
+        }).compileToV0Message(alts);
+        const versionedTx = new web3.VersionedTransaction(messageV0);
+        const signers = this.findRequiredSignersFromBatch(batch, dummySigners);
+        versionedTx.sign(signers);
+        const bytes = versionedTx.serialize();
+        return bytes.length;
+    }
+    /**
+     * Find required signers from instructions
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    findRequiredSignersFromIxs(ixs) {
+        const signers = [];
+        signers.push(this.payer.publicKey);
+        for (const instruction of ixs) {
+            const _signers = instruction.keys
+                .filter(meta => meta.isSigner)
+                .map(meta => meta.pubkey);
+            if (_signers.length > 0) {
+                signers.push(..._signers);
+            }
+        }
+        const uniqueSigners = {};
+        for (const signer of signers) {
+            uniqueSigners[signer.toBase58()] = signer;
+        }
+        const result = [];
+        for (const id in uniqueSigners) {
+            result.push(uniqueSigners[id]);
+        }
+        return result;
+    }
+    /**
+     * Find required signers from batch
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    findRequiredSignersFromBatch(batch, dummySigners) {
+        const signers = this.findRequiredSignersFromIxs(batch);
+        const result = [];
+        for (const key in dummySigners) {
+            const dummySigner = signers.find(signer => signer.toBase58() === dummySigners[key].publicKey.toBase58());
+            if (dummySigner === undefined) {
+                throw new Error('Unexpected error: Dummy signer not found (it should never happen)');
+            }
+            result.push(dummySigners[key]);
+        }
+        return result;
+    }
+    /**
+     * Find signing keypairs from signers defined in instruction
+     *
+     * @param batch
+     * @returns
+     */
+    findSigningKeypairFromIxs(batch) {
+        const signers = this.findRequiredSignersFromIxs(batch);
+        const result = [];
+        for (const signer of signers) {
+            const keypair = this.signers.find(keypair => keypair.publicKey.toBase58() === signer.toBase58());
+            if (keypair === undefined) {
+                throw new Error(`Keypair ${signer} cannot be found in $this.signers array. Perhaps you forgot to add it?`);
+            }
+            result.push(keypair);
+        }
+        return result;
+    }
+    /**
+     * Find required address lookup table addresses for given batch of instructions
+     *
+     * @param batch
+     */
+    findRequiredAltsForBatch(batch) {
+        const uniquePubkeys = {};
+        batch.map(ix => {
+            const pubkeys = ix.keys.map(meta => meta.pubkey);
+            for (const pubkey of pubkeys) {
+                uniquePubkeys[pubkey.toBase58()] = 1;
+            }
+        });
+        const pubkeys = [];
+        for (const pubkey in uniquePubkeys) {
+            pubkeys.push(new web3.PublicKey(pubkey));
+        }
+        const alts = {};
+        for (const alt of this.alts) {
+            for (const pubkey of pubkeys) {
+                const match = alt.state.addresses.find(address => pubkey.toBase58() === address.toBase58());
+                if (!!match) {
+                    alts[alt.key.toString()] = alt;
+                }
+            }
+        }
+        const result = [];
+        for (const key in alts) {
+            result.push(alts[key]);
+        }
+        return result;
+    }
+}
+exports.TransactionBatchExecute = TransactionBatchExecute;

package/dist/classes/TransactionBatchExecute2.d.ts

@@ -0,0 +1,99 @@
+import * as web3 from '@solana/web3.js';
+import { TransactionBatchExecute, DummySigners } from './TransactionBatchExecute';
+import { CreateTxMetadata } from './CreateTxMetadata';
+import { InsertNonceAtOpt } from '../types';
+import { GeneralUtility } from './GeneralUtility';
+import { MultiTransaction } from './MultiTransaction';
+/**
+ * Executes transactions in batches
+ */
+export declare class TransactionBatchExecute2 extends TransactionBatchExecute {
+    protected lookupTableAddresses: web3.PublicKey[];
+    protected instructions: web3.TransactionInstruction[];
+    protected connection: web3.Connection;
+    protected createTxMetadataInstance: CreateTxMetadata;
+    protected latestBlockhash: web3.BlockhashWithExpiryBlockHeight;
+    protected payerKey: web3.PublicKey;
+    private _insertNonceAt;
+    /**
+     * Creates an instance of TransactionExecute class
+     *
+     * @param lookupTableAddresses Address lookup table addresses to be used by batch of transactions
+     * @param instructions Array of instructions to be batched into transactions
+     * @param payer Payer that will pay for the batch of transactions
+     * @param connection Connection to mainnet
+     */
+    constructor(lookupTableAddresses: web3.PublicKey[], instructions: web3.TransactionInstruction[], connection: web3.Connection, createTxMetadataInstance: CreateTxMetadata, latestBlockhash: web3.BlockhashWithExpiryBlockHeight, payerKey: web3.PublicKey);
+    /**
+     * Find alt by pubkeys (overridable)
+     *
+     * @param pubkeys
+     */
+    static jupiterFindAltByPubkeysFn: (pubkeys: web3.PublicKey[]) => Promise<web3.PublicKey[]>;
+    /**
+     * Download all jupiter alts (overridable)
+     */
+    protected jupiterDownloadAlts(): Promise<void>;
+    /**
+     * Find alt by pubkeys (overridable)
+     */
+    protected jupiterFindAltByPubkeys(pubkeys: web3.PublicKey[]): Promise<web3.PublicKey[]>;
+    /**
+     * Downoad address lookup table from given cluster
+     */
+    protected downloadAlts2(lookupTableAddresses: web3.PublicKey[]): Promise<void>;
+    /**
+     * Option to include nonce advance instruction
+     *
+     * @param opt
+     */
+    insertNonceAt(opt: InsertNonceAtOpt): void;
+    /**
+     * Builds a batch of executable transaction instructions
+     */
+    buildBatch(): Promise<web3.TransactionInstruction[][]>;
+    /**
+     * Builds a batch of executable transaction instructions
+     */
+    buildBatchWithAlts(description: string, generalUtility: GeneralUtility): Promise<MultiTransaction>;
+    /**
+     * Split transactions
+     *
+     * @param simulationIxs
+     * @param dummySigners
+     * @returns
+     */
+    protected splitToTransactions(simulationIxs: web3.TransactionInstruction[], dummySigners: DummySigners): Promise<web3.TransactionInstruction[][]>;
+    /**
+     * Generate nonde advance instruction (dummy instruction)
+     */
+    private generateNonceAdvanceIx;
+    private getEstimateSize;
+    /**
+     * Find required signers from instructions
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    protected findRequiredSignersFromIxs(ixs: web3.TransactionInstruction[]): web3.PublicKey[];
+    /**
+     * Calculate transaction size
+     *
+     * @param batch
+     */
+    protected calculateTransactionSize(latestBlockhash: web3.BlockhashWithExpiryBlockHeight, batch: web3.TransactionInstruction[], dummySigners: DummySigners): number;
+    /**
+     * Find required address lookup table addresses for given batch of instructions
+     *
+     * @param batch
+     */
+    findRequiredAltsForBatch2(batch: web3.TransactionInstruction[]): web3.AddressLookupTableAccount[];
+    /**
+     * Find required signers from batch
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    private findRequiredSignersFromBatch2;
+}
+//# sourceMappingURL=TransactionBatchExecute2.d.ts.map

package/dist/classes/TransactionBatchExecute2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBatchExecute2.d.ts","sourceRoot":"","sources":["../../src/classes/TransactionBatchExecute2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,uBAAuB;IAajE,SAAS,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,EAAE;IAChD,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,sBAAsB,EAAE;IACrD,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU;IACrC,SAAS,CAAC,wBAAwB,EAAE,gBAAgB;IACpD,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,8BAA8B;IAC9D,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS;IAhBpC,OAAO,CAAC,cAAc,CAAwB;IAE9C;;;;;;;OAOG;gBAES,oBAAoB,EAAE,IAAI,CAAC,SAAS,EAAE,EACtC,YAAY,EAAE,IAAI,CAAC,sBAAsB,EAAE,EAC3C,UAAU,EAAE,IAAI,CAAC,UAAU,EAC3B,wBAAwB,EAAE,gBAAgB,EAC1C,eAAe,EAAE,IAAI,CAAC,8BAA8B,EACpD,QAAQ,EAAE,IAAI,CAAC,SAAS;IAWpC;;;;OAIG;IACH,MAAM,CAAC,yBAAyB,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAEzF;IAED;;OAEG;cACa,mBAAmB;IAEnC;;OAEG;cACa,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;IAI7F;;OAEG;cACa,aAAa,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,EAAE;IAMpE;;;;OAIG;IACH,aAAa,CAAC,GAAG,EAAE,gBAAgB;IAInC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,CAAC;IAmC5D;;OAEG;IACG,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqCxG;;;;;;OAMG;cACa,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,sBAAsB,EAAE,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,CAAC;IAgDvJ;;OAEG;YACW,sBAAsB;IAWpC,OAAO,CAAC,eAAe;IAqBvB;;;;;OAKG;IACH,SAAS,CAAC,0BAA0B,CAAC,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE;IAsB1F;;;;OAIG;IACH,SAAS,CAAC,wBAAwB,CAAC,eAAe,EAAE,IAAI,CAAC,8BAA8B,EAAE,KAAK,EAAE,IAAI,CAAC,sBAAsB,EAAE,EAAE,YAAY,EAAE,YAAY,GAAG,MAAM;IAclK;;;;OAIG;IACI,yBAAyB,CAAC,KAAK,EAAE,IAAI,CAAC,sBAAsB,EAAE,GAAG,IAAI,CAAC,yBAAyB,EAAE;IAmBxG;;;;;OAKG;IACH,OAAO,CAAC,6BAA6B;CAStC"}