@autonomys/auto-utils 1.5.2 → 1.5.3

package/dist/utils/signAndSendTx.js

@@ -14,6 +14,77 @@ exports.signAndSendTx = void 0;
 const detectTxSuccess_1 = require("./detectTxSuccess");
 const events_1 = require("./events");
 const validateEvents_1 = require("./validateEvents");
+/**
+ * Signs and sends a transaction to the Autonomys Network, with comprehensive error handling and event validation.
+ *
+ * This function handles the complete transaction lifecycle: signing, sending, monitoring for inclusion,
+ * and validating expected events. It provides detailed error handling and supports custom error mapping
+ * for domain-specific error handling. The function waits for the transaction to be included in a block
+ * and validates that expected events were emitted.
+ *
+ * @param sender - The account to sign and send the transaction. Can be a KeyringPair, address string, or AddressOrPair.
+ * @param tx - The submittable extrinsic to sign and send.
+ * @param options - Optional signer options including nonce, tip, and other transaction parameters.
+ * @param eventsExpected - Array of expected event names to validate. Defaults to successful transaction events.
+ * @param log - Whether to log transaction progress to console. Defaults to false.
+ * @param mapErrorCodeToEnum - Optional function to map error codes to custom error enums for better error handling.
+ * @returns Promise resolving to transaction results including success status, hashes, events, and receipt.
+ *
+ * @example
+ * import { signAndSendTx, activate, setupWallet } from '@autonomys/auto-utils'
+ *
+ * // Basic transaction signing and sending
+ * const api = await activate({ networkId: 'taurus' })
+ * const wallet = setupWallet({ uri: '//Alice' })
+ *
+ * const tx = api.tx.balances.transfer('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 1000000000000000000n)
+ *
+ * const result = await signAndSendTx(wallet.keyringPair, tx)
+ * if (result.success) {
+ *   console.log('Transaction successful')
+ *   console.log('Transaction hash:', result.txHash)
+ *   console.log('Block hash:', result.blockHash)
+ * }
+ *
+ * // With custom options and event validation
+ * const transferTx = api.tx.balances.transfer(receiverAddress, amount)
+ * const transferResult = await signAndSendTx(
+ *   senderKeyringPair,
+ *   transferTx,
+ *   { tip: 1000000000000000n }, // Custom tip
+ *   ['balances.Transfer'], // Expected events
+ *   true // Enable logging
+ * )
+ *
+ * // With error mapping for custom error handling
+ * const stakingTx = api.tx.domains.nominateOperator(operatorId, amount)
+ * const stakingResult = await signAndSendTx(
+ *   nominatorKeyringPair,
+ *   stakingTx,
+ *   {},
+ *   ['domains.OperatorNominated'],
+ *   false,
+ *   (errorCode) => {
+ *     // Map error codes to custom error types
+ *     switch (errorCode) {
+ *       case '0': return 'InsufficientBalance'
+ *       case '1': return 'OperatorNotFound'
+ *       default: return undefined
+ *     }
+ *   }
+ * )
+ *
+ * // Handle Auto-ID registration with identifier extraction
+ * const autoIdTx = api.tx.autoId.registerAutoId(autoIdData)
+ * const autoIdResult = await signAndSendTx(sender, autoIdTx)
+ * if (autoIdResult.identifier) {
+ *   console.log('Auto-ID registered with identifier:', autoIdResult.identifier)
+ * }
+ *
+ * @throws {Error} When the transaction fails, times out, or expected events are not found.
+ * @throws {Error} When the transaction is retracted, dropped, or invalid.
+ * @throws {Error} When custom error mapping indicates a specific error condition.
+ */
 const signAndSendTx = (sender_1, tx_1, ...args_1) => __awaiter(void 0, [sender_1, tx_1, ...args_1], void 0, function* (sender, tx, options = {}, eventsExpected = events_1.expectSuccessfulTxEvent, log = false, mapErrorCodeToEnum) {
     let success = false;
     let txHashHex = undefined;

package/dist/utils/validateEvents.d.ts

@@ -1,3 +1,70 @@
 import type { EventRecord, Events, EventsValidated } from '../types';
+/**
+ * Validates that expected blockchain events were emitted during transaction execution.
+ *
+ * This function checks if all expected events were found in the transaction's event list.
+ * It's essential for ensuring that transactions not only succeeded but also produced
+ * the specific side effects (events) that were expected. The function supports both
+ * string and nested array formats for expected events.
+ *
+ * @param events - Array of EventRecord objects emitted by the transaction.
+ * @param eventsExpected - Expected events in various formats (string, array of strings, or nested arrays).
+ * @param tx - Transaction hash for logging purposes.
+ * @param block - Block hash where the transaction was included for logging purposes.
+ * @param log - Whether to log unexpected events and missing events. Defaults to false.
+ * @returns EventsValidated object containing arrays of expected (missing) and found events.
+ *
+ * @example
+ * import { validateEvents, expectSuccessfulTxEvent } from '@autonomys/auto-utils'
+ *
+ * // Basic validation with system success events
+ * const events = [] // event records from transaction
+ * const validation = validateEvents(
+ *   events,
+ *   expectSuccessfulTxEvent,
+ *   '0x1234...', // transaction hash
+ *   '0x5678...', // block hash
+ *   true // enable logging
+ * )
+ *
+ * if (validation.expected.length === 0) {
+ *   console.log('All expected events found:', validation.found)
+ * } else {
+ *   console.log('Missing events:', validation.expected)
+ * }
+ *
+ * // Validate multiple specific events
+ * const transferValidation = validateEvents(
+ *   events,
+ *   ['system.ExtrinsicSuccess', 'balances.Transfer'],
+ *   txHash,
+ *   blockHash
+ * )
+ *
+ * // Validate complex event patterns
+ * const stakingValidation = validateEvents(
+ *   events,
+ *   [
+ *     'system.ExtrinsicSuccess',
+ *     ['domains.OperatorNominated', 'domains.StakeAdded'], // Either of these
+ *     'balances.Transfer'
+ *   ],
+ *   txHash,
+ *   blockHash,
+ *   true
+ * )
+ *
+ * // Use in transaction monitoring
+ * const expectedDomainEvents = [
+ *   'system.ExtrinsicSuccess',
+ *   'domains.DomainInstantiated',
+ *   'balances.Transfer'
+ * ]
+ * const domainValidation = validateEvents(events, expectedDomainEvents, txHash, blockHash)
+ *
+ * // Check if validation passed
+ * const isValid = domainValidation.expected.length === 0
+ * console.log('Domain creation valid:', isValid)
+ */
 export declare const validateEvents: (events: EventRecord[], eventsExpected: Events | undefined, tx: string, block: string, log?: boolean) => EventsValidated;
 //# sourceMappingURL=validateEvents.d.ts.map

package/dist/utils/validateEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateEvents.d.ts","sourceRoot":"","sources":["../../src/utils/validateEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAGpE,eAAO,MAAM,cAAc,GACzB,QAAQ,WAAW,EAAE,EACrB,gBAAgB,MAAM,YAA0B,EAChD,IAAI,MAAM,EACV,OAAO,MAAM,EACb,MAAK,OAAe,KACnB,eAmBF,CAAA"}
+{"version":3,"file":"validateEvents.d.ts","sourceRoot":"","sources":["../../src/utils/validateEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,WAAW,EAAE,EACrB,gBAAgB,MAAM,YAA0B,EAChD,IAAI,MAAM,EACV,OAAO,MAAM,EACb,MAAK,OAAe,KACnB,eAoBF,CAAA"}

package/dist/utils/validateEvents.js

@@ -3,10 +3,77 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEvents = void 0;
 const events_1 = require("./events");
+/**
+ * Validates that expected blockchain events were emitted during transaction execution.
+ *
+ * This function checks if all expected events were found in the transaction's event list.
+ * It's essential for ensuring that transactions not only succeeded but also produced
+ * the specific side effects (events) that were expected. The function supports both
+ * string and nested array formats for expected events.
+ *
+ * @param events - Array of EventRecord objects emitted by the transaction.
+ * @param eventsExpected - Expected events in various formats (string, array of strings, or nested arrays).
+ * @param tx - Transaction hash for logging purposes.
+ * @param block - Block hash where the transaction was included for logging purposes.
+ * @param log - Whether to log unexpected events and missing events. Defaults to false.
+ * @returns EventsValidated object containing arrays of expected (missing) and found events.
+ *
+ * @example
+ * import { validateEvents, expectSuccessfulTxEvent } from '@autonomys/auto-utils'
+ *
+ * // Basic validation with system success events
+ * const events = [] // event records from transaction
+ * const validation = validateEvents(
+ *   events,
+ *   expectSuccessfulTxEvent,
+ *   '0x1234...', // transaction hash
+ *   '0x5678...', // block hash
+ *   true // enable logging
+ * )
+ *
+ * if (validation.expected.length === 0) {
+ *   console.log('All expected events found:', validation.found)
+ * } else {
+ *   console.log('Missing events:', validation.expected)
+ * }
+ *
+ * // Validate multiple specific events
+ * const transferValidation = validateEvents(
+ *   events,
+ *   ['system.ExtrinsicSuccess', 'balances.Transfer'],
+ *   txHash,
+ *   blockHash
+ * )
+ *
+ * // Validate complex event patterns
+ * const stakingValidation = validateEvents(
+ *   events,
+ *   [
+ *     'system.ExtrinsicSuccess',
+ *     ['domains.OperatorNominated', 'domains.StakeAdded'], // Either of these
+ *     'balances.Transfer'
+ *   ],
+ *   txHash,
+ *   blockHash,
+ *   true
+ * )
+ *
+ * // Use in transaction monitoring
+ * const expectedDomainEvents = [
+ *   'system.ExtrinsicSuccess',
+ *   'domains.DomainInstantiated',
+ *   'balances.Transfer'
+ * ]
+ * const domainValidation = validateEvents(events, expectedDomainEvents, txHash, blockHash)
+ *
+ * // Check if validation passed
+ * const isValid = domainValidation.expected.length === 0
+ * console.log('Domain creation valid:', isValid)
+ */
 const validateEvents = (events, eventsExpected = events_1.expectSuccessfulTxEvent, tx, block, log = false) => {
     const _eventsExpected = typeof eventsExpected === 'string'
         ? [eventsExpected]
-        : eventsExpected.map((e) => (typeof e === 'string' ? [e] : e)).flat();
+        : eventsExpected.reduce((acc, e) => acc.concat(typeof e === 'string' ? [e] : e), []);
     const found = [];
     events.forEach(({ event: { method, section } }) => {
         const index = _eventsExpected.indexOf(`${section}.${method}`);

package/dist/utils/verify.d.ts

@@ -1,4 +1,12 @@
 import { isHex } from '@polkadot/util';
 import { isAddress } from '@polkadot/util-crypto';
+/**
+ * Essential validation utilities re-exported from Polkadot.js for convenience.
+ *
+ * These functions provide validation capabilities for common Autonomys Network
+ * data types including addresses and hex strings.
+ *
+ * @see {@link https://polkadot.js.org/docs/ | Polkadot.js Documentation} for complete API details.
+ */
 export { isAddress, isHex };
 //# sourceMappingURL=verify.d.ts.map

package/dist/utils/verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/utils/verify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEjD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAA"}
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/utils/verify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEjD;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAA"}

package/dist/wallet.d.ts

@@ -1,8 +1,212 @@
 import type { DomainParams, NetworkParams } from './types';
 import type { ActivateWalletParams, ApiPromise, GeneratedWallet, KeypairType, SetupWalletParams, Wallet, WalletActivated } from './types/wallet';
+/**
+ * Sets up a wallet from a mnemonic phrase or derivation URI.
+ *
+ * This function creates a KeyringPair from either a mnemonic phrase or a derivation
+ * URI (like //Alice for development). It supports different key types including
+ * sr25519 (default) and ethereum for cross-chain compatibility.
+ *
+ * @param params - Wallet setup parameters containing either mnemonic or URI, plus optional key type.
+ * @returns A Wallet object containing the KeyringPair and standardized addresses.
+ *
+ * @example
+ * import { setupWallet } from '@autonomys/auto-utils'
+ *
+ * // Setup wallet from mnemonic (sr25519 default)
+ * const wallet = setupWallet({
+ *   mnemonic: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
+ * })
+ * console.log(wallet.address) // Standardized Autonomys address
+ * console.log(wallet.commonAddress) // Original address format
+ *
+ * // Setup wallet with ethereum key type
+ * const ethWallet = setupWallet({
+ *   mnemonic: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+ *   type: 'ethereum'
+ * })
+ * console.log(ethWallet.address) // Ethereum-format address (0x...)
+ *
+ * // Setup development wallet from URI
+ * const aliceWallet = setupWallet({ uri: '//Alice' })
+ * console.log(aliceWallet.address) // Alice's development address
+ *
+ * // Setup with custom derivation path
+ * const customWallet = setupWallet({
+ *   uri: '//Alice/stash'
+ * })
+ *
+ * @throws {Error} When neither mnemonic nor URI is provided, or when the input is invalid.
+ */
 export declare const setupWallet: (params: SetupWalletParams) => Wallet;
+/**
+ * Generates a new wallet with a random mnemonic phrase.
+ *
+ * This function creates a brand new wallet by generating a cryptographically secure
+ * mnemonic phrase and deriving the corresponding KeyringPair. It's useful for creating
+ * new user accounts or generating test wallets.
+ *
+ * @param type - The cryptographic key type to use. Defaults to 'sr25519'.
+ * @returns A GeneratedWallet object containing the mnemonic, KeyringPair, and addresses.
+ *
+ * @example
+ * import { generateWallet } from '@autonomys/auto-utils'
+ *
+ * // Generate new sr25519 wallet (default)
+ * const newWallet = generateWallet()
+ * console.log(newWallet.mnemonic) // 12-word mnemonic phrase
+ * console.log(newWallet.address) // Standardized Autonomys address
+ * console.log(newWallet.commonAddress) // Original address format
+ *
+ * // Generate ethereum-compatible wallet
+ * const ethWallet = generateWallet('ethereum')
+ * console.log(ethWallet.mnemonic) // Same 12-word mnemonic
+ * console.log(ethWallet.address) // Ethereum-format address (0x...)
+ *
+ * // Store the mnemonic securely for later use
+ * const mnemonic = newWallet.mnemonic
+ * // Use setupWallet later to recreate the same wallet
+ * const restoredWallet = setupWallet({ mnemonic })
+ * console.log(restoredWallet.address === newWallet.address) // true
+ */
 export declare const generateWallet: (type?: KeypairType) => GeneratedWallet;
+/**
+ * Activates a wallet and establishes connection to the Autonomys Network or domain.
+ *
+ * This comprehensive function handles wallet activation in both Node.js and browser
+ * environments. It can work with mnemonic phrases, URIs, or browser extensions,
+ * and automatically establishes the appropriate API connection.
+ *
+ * @param params - Wallet activation parameters including credentials, network, and options.
+ * @returns A WalletActivated object containing the API connection and account information.
+ *
+ * @example
+ * import { activateWallet } from '@autonomys/auto-utils'
+ *
+ * // Activate wallet with mnemonic on mainnet
+ * const { api, accounts } = await activateWallet({
+ *   mnemonic: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
+ * })
+ * console.log('Connected to mainnet')
+ * console.log('Account address:', accounts[0].address)
+ *
+ * // Activate on specific network
+ * const { api: taurusApi, accounts: taurusAccounts } = await activateWallet({
+ *   mnemonic: 'your mnemonic here',
+ *   networkId: 'taurus'
+ * })
+ *
+ * // Activate on domain
+ * const { api: domainApi, accounts: domainAccounts } = await activateWallet({
+ *   uri: '//Alice',
+ *   networkId: 'taurus',
+ *   domainId: '0' // Auto-EVM domain
+ * })
+ *
+ * // Activate with ethereum key type
+ * const { api: ethApi, accounts: ethAccounts } = await activateWallet({
+ *   mnemonic: 'your mnemonic here',
+ *   networkId: 'taurus',
+ *   type: 'ethereum'
+ * })
+ *
+ * // Use with existing API instance
+ * import { activate } from '@autonomys/auto-utils'
+ * const existingApi = await activate({ networkId: 'gemini-3h' })
+ * const { accounts } = await activateWallet({
+ *   uri: '//Bob',
+ *   api: existingApi
+ * })
+ *
+ * // Always disconnect when done
+ * await api.disconnect()
+ *
+ * @throws {Error} When no wallet credentials are provided or connection fails.
+ */
 export declare const activateWallet: (params: ActivateWalletParams) => Promise<WalletActivated>;
+/**
+ * Creates a collection of mock wallets for testing and development purposes.
+ *
+ * This function generates wallets for all predefined development accounts
+ * (Alice, Bob, Charlie, Dave, etc.) and establishes connections to the specified
+ * network. It's essential for testing applications and running development scenarios.
+ *
+ * @param network - Network parameters specifying which network to connect to. Defaults to mainnet.
+ * @param api - Optional existing API instance to reuse. If not provided, creates new connections.
+ * @param type - The cryptographic key type to use for all mock wallets. Defaults to 'sr25519'.
+ * @returns Promise resolving to an array of WalletActivated objects for all mock accounts.
+ *
+ * @example
+ * import { mockWallets, activate } from '@autonomys/auto-utils'
+ *
+ * // Create mock wallets for mainnet
+ * const wallets = await mockWallets()
+ * console.log('Created', wallets.length, 'mock wallets')
+ *
+ * // Create mock wallets for testnet
+ * const testWallets = await mockWallets({ networkId: 'taurus' })
+ *
+ * // Create mock wallets with existing API
+ * const api = await activate({ networkId: 'localhost' })
+ * const localWallets = await mockWallets({ networkId: 'localhost' }, api)
+ *
+ * // Create ethereum-type mock wallets
+ * const ethWallets = await mockWallets(
+ *   { networkId: 'taurus' },
+ *   undefined,
+ *   'ethereum'
+ * )
+ *
+ * // Use specific mock wallet
+ * const aliceWallet = wallets[0] // Alice is always first
+ * const bobWallet = wallets[1]   // Bob is always second
+ *
+ * // Access wallet details
+ * console.log('Alice address:', aliceWallet.accounts[0].address)
+ * console.log('Bob address:', bobWallet.accounts[0].address)
+ *
+ * // Disconnect all APIs when done
+ * for (const wallet of wallets) {
+ *   await wallet.api.disconnect()
+ * }
+ */
 export declare const mockWallets: (network?: NetworkParams | DomainParams, api?: ApiPromise, type?: KeypairType) => Promise<WalletActivated[]>;
+/**
+ * Retrieves a specific mock wallet by name from a collection of mock wallets.
+ *
+ * This utility function provides easy access to specific development accounts
+ * by name, making test code more readable and maintainable. It works with the
+ * standard set of development account names.
+ *
+ * @param name - The name of the mock wallet to retrieve (e.g., 'Alice', 'Bob').
+ * @param wallets - Array of WalletActivated objects from mockWallets().
+ * @returns The WalletActivated object for the specified mock account.
+ *
+ * @example
+ * import { mockWallets, getMockWallet } from '@autonomys/auto-utils'
+ *
+ * // Create mock wallets and get specific ones
+ * const wallets = await mockWallets({ networkId: 'localhost' })
+ *
+ * const alice = getMockWallet('Alice', wallets)
+ * const bob = getMockWallet('Bob', wallets)
+ * const charlie = getMockWallet('Charlie', wallets)
+ *
+ * console.log('Alice address:', alice.accounts[0].address)
+ * console.log('Bob address:', bob.accounts[0].address)
+ * console.log('Charlie address:', charlie.accounts[0].address)
+ *
+ * // Use in tests
+ * const sender = getMockWallet('Alice', wallets)
+ * const receiver = getMockWallet('Bob', wallets)
+ *
+ * // Perform transfer from Alice to Bob
+ * // ... transfer logic here ...
+ *
+ * // Available mock wallet names:
+ * // 'Alice', 'Bob', 'Charlie', 'Dave', 'Eve', 'Frank', 'Grace', 'Harry', 'Ivy', 'Jacob'
+ *
+ * @throws {Error} When the specified name is not found in the available mock wallets.
+ */
 export declare const getMockWallet: (name: string, wallets: WalletActivated[]) => WalletActivated;
 //# sourceMappingURL=wallet.d.ts.map

package/dist/wallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAY,aAAa,EAAO,MAAM,SAAS,CAAA;AACzE,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,MAAM,EACN,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAEvB,eAAO,MAAM,WAAW,GAAI,QAAQ,iBAAiB,KAAG,MAkBvD,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,OAAM,WAAuB,KAAG,eAU9D,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,QAAQ,oBAAoB,KAAG,OAAO,CAAC,eAAe,CAmC1F,CAAA;AAED,eAAO,MAAM,WAAW,GACtB,UAAS,aAAa,GAAG,YAA+C,EACxE,MAAM,UAAU,EAChB,OAAO,WAAW,KACjB,OAAO,CAAC,eAAe,EAAE,CAa3B,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,SAAS,eAAe,EAAE,KAAG,eAClB,CAAA"}
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAY,aAAa,EAAO,MAAM,SAAS,CAAA;AACzE,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,MAAM,EACN,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,iBAAiB,KAAG,MAkBvD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,cAAc,GAAI,OAAM,WAAuB,KAAG,eAU9D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,cAAc,GAAU,QAAQ,oBAAoB,KAAG,OAAO,CAAC,eAAe,CAmC1F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GACtB,UAAS,aAAa,GAAG,YAA+C,EACxE,MAAM,UAAU,EAChB,OAAO,WAAW,KACjB,OAAO,CAAC,eAAe,EAAE,CAa3B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,SAAS,eAAe,EAAE,KAAG,eAClB,CAAA"}