@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/dest/{parse_args.d.ts → utils/commands.d.ts}

@@ -1,15 +1,47 @@
 import { FunctionSelector } from '@aztec/aztec.js/abi';
-import { AztecAddress } from '@aztec/aztec.js/aztec_address';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { EthAddress } from '@aztec/aztec.js/eth_address';
-import { Fr, GrumpkinScalar, Point } from '@aztec/aztec.js/fields';
+import { Fr } from '@aztec/aztec.js/fields';
 import { LogId } from '@aztec/aztec.js/log_id';
 import { TxHash } from '@aztec/aztec.js/tx_hash';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import { type Command, Option } from 'commander';
 /**
- * Parses a hex encoded string to an Fr integer to be used as salt
+ * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
+ * localhost as being host.docker.internal.
+ */
+export declare const getLocalhost: () => Promise<string>;
+export declare const LOCALHOST: string;
+export declare const ETHEREUM_HOSTS: string, PRIVATE_KEY: string | undefined, API_KEY: string | undefined, CLI_VERSION: string | undefined;
+export declare function addOptions(program: Command, options: Option[]): Command;
+export declare const makePxeOption: (mandatory: boolean) => Option;
+export declare const pxeOption: Option;
+export declare const l1ChainIdOption: Option;
+export declare const createSecretKeyOption: (description: string, mandatory: boolean, argsParser?: (value: string, previous: Fr) => Fr) => Option;
+export declare const logJson: (log: LogFn) => (obj: object) => void;
+/**
+ * Updates a file in place atomically.
+ * @param filePath - Path to file
+ * @param contents - New contents to write
+ */
+export declare function atomicUpdateFile(filePath: string, contents: string): Promise<void>;
+/**
+ * Utility to select a TX sender either from user input
+ * or from the first account that is found in a PXE instance.
+ * @param pxe - The PXE instance that will be checked for an account.
+ * @param _from - The user input.
+ * @returns An Aztec address. Will throw if one can't be found in either options.
+ */
+export declare function getTxSender(pxe: PXE, _from?: string): Promise<AztecAddress>;
+export declare function parseBigint(bigint: string): bigint | undefined;
+/**
+ * Parses a hex encoded string to an Fr integer
  * @param str - Hex encoded string
- * @returns A integer to be used as salt
+ * @returns A integer
  */
-export declare function parseSaltFromHexString(str: string): Fr;
+export declare function parseFieldFromHexString(str: string): Fr;
 /**
  * Parses an AztecAddress from a string.
  * @param address - A serialized Aztec address
@@ -70,11 +102,11 @@ export declare function parseTxHash(txHash: string): TxHash;
 export declare function parseOptionalTxHash(txHash: string): TxHash | undefined;
 /**
  * Parses a public key from a string.
- * @param publicKey - A public key
- * @returns A Point instance
+ * @param publicKey - A public keys object serialised as a string
+ * @returns A PublicKeys instance
  * @throws InvalidArgumentError if the input string is not valid.
  */
-export declare function parsePublicKey(publicKey: string): Point;
+export declare function parsePublicKey(publicKey: string): PublicKeys | undefined;
 /**
  * Parses a partial address from a string.
  * @param address - A partial address
@@ -83,12 +115,12 @@ export declare function parsePublicKey(publicKey: string): Point;
  */
 export declare function parsePartialAddress(address: string): Fr;
 /**
- * Parses a private key from a string.
+ * Parses a secret key from a string.
  * @param privateKey - A string
- * @returns A private key
+ * @returns A secret key
  * @throws InvalidArgumentError if the input string is not valid.
  */
-export declare function parsePrivateKey(privateKey: string): GrumpkinScalar;
+export declare function parseSecretKey(secretKey: string): Fr;
 /**
  * Parses a field from a string.
  * @param field - A string representing the field.
@@ -102,4 +134,10 @@ export declare function parseField(field: string): Fr;
  * @returns An array of Frs.
  */
 export declare function parseFields(fields: string[]): Fr[];
-//# sourceMappingURL=parse_args.d.ts.map
+/**
+ * Pretty prints an object as JSON
+ * @param data - The object to stringify
+ * @returns A JSON string
+ */
+export declare function prettyPrintJSON(data: Record<string, any>): string;
+//# sourceMappingURL=commands.d.ts.map

package/dest/utils/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/utils/commands.ts"],"names":[],"mappings":"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"}

package/dest/utils/commands.js

@@ -0,0 +1,303 @@
+import { FunctionSelector } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { EthAddress } from '@aztec/aztec.js/eth_address';
+import { Fr } from '@aztec/aztec.js/fields';
+import { LogId } from '@aztec/aztec.js/log_id';
+import { TxHash } from '@aztec/aztec.js/tx_hash';
+import { PublicKeys } from '@aztec/stdlib/keys';
+import { CommanderError, InvalidArgumentError, Option } from 'commander';
+import { lookup } from 'dns/promises';
+import { rename, writeFile } from 'fs/promises';
+/**
+ * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
+ * localhost as being host.docker.internal.
+ */ export const getLocalhost = ()=>lookup('host.docker.internal').then(()=>'host.docker.internal').catch(()=>'localhost');
+export const LOCALHOST = await getLocalhost();
+export const { ETHEREUM_HOSTS = `http://${LOCALHOST}:8545`, PRIVATE_KEY, API_KEY, CLI_VERSION } = process.env;
+export function addOptions(program, options) {
+    options.forEach((option)=>program.addOption(option));
+    return program;
+}
+export const makePxeOption = (mandatory)=>new Option('-u, --rpc-url <string>', 'URL of the PXE').env('PXE_URL').default(`http://${LOCALHOST}:8080`).conflicts('remote-pxe').makeOptionMandatory(mandatory);
+export const pxeOption = makePxeOption(true);
+export const l1ChainIdOption = new Option('-c, --l1-chain-id <number>', 'Chain ID of the ethereum host').env('L1_CHAIN_ID').default(31337).argParser((value)=>{
+    const parsedValue = Number(value);
+    if (isNaN(parsedValue)) {
+        throw new Error('Chain ID must be a number.');
+    }
+    return parsedValue;
+});
+export const createSecretKeyOption = (description, mandatory, argsParser)=>new Option('-sk, --secret-key <string>', description).env('SECRET_KEY').argParser(argsParser ?? parseSecretKey).makeOptionMandatory(mandatory);
+export const logJson = (log)=>(obj)=>log(JSON.stringify(obj, null, 2));
+/**
+ * Updates a file in place atomically.
+ * @param filePath - Path to file
+ * @param contents - New contents to write
+ */ export async function atomicUpdateFile(filePath, contents) {
+    const tmpFilepath = filePath + '.tmp';
+    try {
+        await writeFile(tmpFilepath, contents, {
+            // let's crash if the tmp file already exists
+            flag: 'wx'
+        });
+        await rename(tmpFilepath, filePath);
+    } catch (e) {
+        if (e instanceof Error && 'code' in e && e.code === 'EEXIST') {
+            const commanderError = new CommanderError(1, e.code, `Temporary file already exists: ${tmpFilepath}. Delete this file and try again.`);
+            commanderError.nestedError = e.message;
+            throw commanderError;
+        } else {
+            throw e;
+        }
+    }
+}
+/**
+ * Utility to select a TX sender either from user input
+ * or from the first account that is found in a PXE instance.
+ * @param pxe - The PXE instance that will be checked for an account.
+ * @param _from - The user input.
+ * @returns An Aztec address. Will throw if one can't be found in either options.
+ */ export async function getTxSender(pxe, _from) {
+    let from;
+    if (_from) {
+        try {
+            from = AztecAddress.fromString(_from);
+        } catch  {
+            throw new InvalidArgumentError(`Invalid option 'from' passed: ${_from}`);
+        }
+    } else {
+        const accounts = await pxe.getRegisteredAccounts();
+        if (!accounts.length) {
+            throw new Error('No accounts found in PXE instance.');
+        }
+        from = accounts[0].address;
+    }
+    return from;
+}
+/**
+ * Removes the leading 0x from a hex string. If no leading 0x is found the string is returned unchanged.
+ * @param hex - A hex string
+ * @returns A new string with leading 0x removed
+ */ const stripLeadingHex = (hex)=>{
+    if (hex.length > 2 && hex.startsWith('0x')) {
+        return hex.substring(2);
+    }
+    return hex;
+};
+export function parseBigint(bigint) {
+    return bigint ? BigInt(bigint) : undefined;
+}
+/**
+ * Parses a hex encoded string to an Fr integer
+ * @param str - Hex encoded string
+ * @returns A integer
+ */ export function parseFieldFromHexString(str) {
+    const hex = stripLeadingHex(str);
+    // ensure it's a hex string
+    if (!hex.match(/^[0-9a-f]+$/i)) {
+        throw new InvalidArgumentError('Invalid hex string');
+    }
+    // pad it so that we may read it as a buffer.
+    // Buffer needs _exactly_ two hex characters per byte
+    const padded = hex.length % 2 === 1 ? '0' + hex : hex;
+    let buf = Buffer.from(padded, 'hex');
+    if (buf.length > Fr.SIZE_IN_BYTES) {
+        buf = buf.subarray(buf.length - Fr.SIZE_IN_BYTES);
+    }
+    const fr = Buffer.alloc(Fr.SIZE_IN_BYTES, 0);
+    fr.set(buf, Fr.SIZE_IN_BYTES - buf.length);
+    // finally, turn it into an integer
+    return Fr.fromBuffer(fr);
+}
+/**
+ * Parses an AztecAddress from a string.
+ * @param address - A serialized Aztec address
+ * @returns An Aztec address
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseAztecAddress(address) {
+    try {
+        return AztecAddress.fromString(address);
+    } catch  {
+        throw new InvalidArgumentError(`Invalid address: ${address}`);
+    }
+}
+/**
+ * Parses an Ethereum address from a string.
+ * @param address - A serialized Ethereum address
+ * @returns An Ethereum address
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseEthereumAddress(address) {
+    try {
+        return EthAddress.fromString(address);
+    } catch  {
+        throw new InvalidArgumentError(`Invalid address: ${address}`);
+    }
+}
+/**
+ * Parses an AztecAddress from a string.
+ * @param address - A serialized Aztec address
+ * @returns An Aztec address
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseOptionalAztecAddress(address) {
+    if (!address) {
+        return undefined;
+    }
+    return parseAztecAddress(address);
+}
+/**
+ * Parses an optional log ID string into a LogId object.
+ *
+ * @param logId - The log ID string to parse.
+ * @returns The parsed LogId object, or undefined if the log ID is missing or empty.
+ */ export function parseOptionalLogId(logId) {
+    if (!logId) {
+        return undefined;
+    }
+    return LogId.fromString(logId);
+}
+/**
+ * Parses a selector from a string.
+ * @param selector - A serialized selector.
+ * @returns A selector.
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseOptionalSelector(selector) {
+    if (!selector) {
+        return undefined;
+    }
+    try {
+        return FunctionSelector.fromString(selector);
+    } catch  {
+        throw new InvalidArgumentError(`Invalid selector: ${selector}`);
+    }
+}
+/**
+ * Parses a string into an integer or returns undefined if the input is falsy.
+ *
+ * @param value - The string to parse into an integer.
+ * @returns The parsed integer, or undefined if the input string is falsy.
+ * @throws If the input is not a valid integer.
+ */ export function parseOptionalInteger(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed)) {
+        throw new InvalidArgumentError('Invalid integer.');
+    }
+    return parsed;
+}
+/**
+ * Parses a TxHash from a string.
+ * @param txHash - A transaction hash
+ * @returns A TxHash instance
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseTxHash(txHash) {
+    try {
+        return TxHash.fromString(txHash);
+    } catch  {
+        throw new InvalidArgumentError(`Invalid transaction hash: ${txHash}`);
+    }
+}
+/**
+ * Parses an optional TxHash from a string.
+ * Calls parseTxHash internally.
+ * @param txHash - A transaction hash
+ * @returns A TxHash instance, or undefined if the input string is falsy.
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseOptionalTxHash(txHash) {
+    if (!txHash) {
+        return undefined;
+    }
+    return parseTxHash(txHash);
+}
+/**
+ * Parses a public key from a string.
+ * @param publicKey - A public keys object serialised as a string
+ * @returns A PublicKeys instance
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parsePublicKey(publicKey) {
+    if (!publicKey) {
+        return undefined;
+    }
+    try {
+        return PublicKeys.fromString(publicKey);
+    } catch (err) {
+        throw new InvalidArgumentError(`Invalid public key: ${publicKey}`);
+    }
+}
+/**
+ * Parses a partial address from a string.
+ * @param address - A partial address
+ * @returns A Fr instance
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parsePartialAddress(address) {
+    try {
+        return Fr.fromHexString(address);
+    } catch (err) {
+        throw new InvalidArgumentError(`Invalid partial address: ${address}`);
+    }
+}
+/**
+ * Parses a secret key from a string.
+ * @param privateKey - A string
+ * @returns A secret key
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseSecretKey(secretKey) {
+    try {
+        return Fr.fromHexString(secretKey);
+    } catch (err) {
+        throw new InvalidArgumentError(`Invalid encryption secret key: ${secretKey}`);
+    }
+}
+/**
+ * Parses a field from a string.
+ * @param field - A string representing the field.
+ * @returns A field.
+ * @throws InvalidArgumentError if the input string is not valid.
+ */ export function parseField(field) {
+    try {
+        const isHex = field.startsWith('0x') || field.match(new RegExp(`^[0-9a-f]{${Fr.SIZE_IN_BYTES * 2}}$`, 'i'));
+        if (isHex) {
+            return Fr.fromHexString(field);
+        }
+        if ([
+            'true',
+            'false'
+        ].includes(field)) {
+            return new Fr(field === 'true');
+        }
+        const isNumber = +field || field === '0';
+        if (isNumber) {
+            return new Fr(BigInt(field));
+        }
+        const isBigInt = field.endsWith('n');
+        if (isBigInt) {
+            return new Fr(BigInt(field.replace(/n$/, '')));
+        }
+        return new Fr(BigInt(field));
+    } catch (err) {
+        throw new InvalidArgumentError(`Invalid field: ${field}`);
+    }
+}
+/**
+ * Parses an array of strings to Frs.
+ * @param fields - An array of strings representing the fields.
+ * @returns An array of Frs.
+ */ export function parseFields(fields) {
+    return fields.map(parseField);
+}
+/**
+ * Pretty prints an object as JSON
+ * @param data - The object to stringify
+ * @returns A JSON string
+ */ export function prettyPrintJSON(data) {
+    return JSON.stringify(data, (_key, val)=>{
+        if (typeof val === 'bigint') {
+            return String(val);
+        } else if (val && typeof val === 'object' && 'toBuffer' in val) {
+            return '0x' + val.toBuffer().toString('hex');
+        } else {
+            return val;
+        }
+    }, 2);
+}

package/dest/{encoding.d.ts → utils/encoding.d.ts}

@@ -1,4 +1,4 @@
-import { ABIParameter, StructType } from '@aztec/foundation/abi';
+import type { ABIParameter, StructType } from '@aztec/stdlib/abi';
 /**
  * Parses a hex string into an ABI struct type.
  * @param str - The encoded hex string.

package/dest/utils/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/utils/encoding.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAW,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,OAcjE;AA4ED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,SAY7D"}

package/dest/utils/encoding.js

@@ -0,0 +1,103 @@
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * Parses a hex string into an ABI struct type.
+ * @param str - The encoded hex string.
+ * @param abiType - The ABI Struct type.
+ * @returns An object in the ABI struct type's format.
+ */ export function parseStructString(str, abiType) {
+    // Assign string bytes to struct fields.
+    const buf = Buffer.from(str.replace(/^0x/i, ''), 'hex');
+    const struct = {};
+    let byteIndex = 0;
+    let argIndex = 0;
+    while(byteIndex < buf.length){
+        const { name } = abiType.fields[argIndex];
+        struct[name] = Fr.fromBuffer(buf.subarray(byteIndex, byteIndex + 32));
+        byteIndex += 32;
+        argIndex += 1;
+    }
+    return struct;
+}
+/**
+ * Helper function to encode CLI string args to an appropriate JS type.
+ * @param arg - The CLI argument.
+ * @param abiType - The type as described by the contract's ABI.
+ * @returns The encoded argument.
+ */ function encodeArg(arg, abiType, name) {
+    const { kind } = abiType;
+    if (kind === 'field' || kind === 'integer') {
+        let res;
+        try {
+            res = BigInt(arg);
+        } catch (err) {
+            throw new Error(`Invalid value passed for ${name}. Could not parse ${arg} as a${kind === 'integer' ? 'n' : ''} ${kind}.`);
+        }
+        return res;
+    } else if (kind === 'boolean') {
+        if (arg === 'true') {
+            return true;
+        }
+        if (arg === 'false') {
+            return false;
+        } else {
+            throw Error(`Invalid boolean value passed for ${name}: ${arg}.`);
+        }
+    } else if (kind === 'string') {
+        return arg;
+    } else if (kind === 'array') {
+        let arr;
+        const res = [];
+        try {
+            arr = JSON.parse(arg);
+        } catch  {
+            throw new Error(`Unable to parse arg ${arg} as array for ${name} parameter`);
+        }
+        if (!Array.isArray(arr)) {
+            throw Error(`Invalid argument ${arg} passed for array parameter ${name}.`);
+        }
+        if (arr.length !== abiType.length) {
+            throw Error(`Invalid array length passed for ${name}. Expected ${abiType.length}, received ${arr.length}.`);
+        }
+        for(let i = 0; i < abiType.length; i += 1){
+            res.push(encodeArg(arr[i], abiType.type, name));
+        }
+        return res;
+    } else if (kind === 'struct') {
+        // check if input is encoded long string
+        if (arg.startsWith('0x')) {
+            return parseStructString(arg, abiType);
+        }
+        let obj;
+        try {
+            obj = JSON.parse(arg);
+        } catch  {
+            throw new Error(`Unable to parse arg ${arg} as struct`);
+        }
+        if (Array.isArray(obj)) {
+            throw Error(`Array passed for arg ${name}. Expected a struct.`);
+        }
+        const res = {};
+        for (const field of abiType.fields){
+            // Remove field name from list as it's present
+            const arg = obj[field.name];
+            if (!arg) {
+                throw Error(`Expected field ${field.name} not found in struct ${name}.`);
+            }
+            res[field.name] = encodeArg(obj[field.name], field.type, field.name);
+        }
+        return res;
+    }
+}
+/**
+ * Tries to encode function args to their equivalent TS type.
+ * @param args - An array of function's / constructor's args.
+ * @returns The encoded array.
+ */ export function encodeArgs(args, params) {
+    if (args.length !== params.length) {
+        throw new Error(`Invalid args provided.\nExpected args: [${params.map((param)=>param.name + ': ' + param.type.kind).join(', ')}]\nReceived args: ${args.join(', ')}`);
+    }
+    return args.map((arg, index)=>{
+        const { type, name } = params[index];
+        return encodeArg(arg, type, name);
+    });
+}

package/dest/utils/github.d.ts

@@ -0,0 +1,4 @@
+export declare const GITHUB_OWNER = "AztecProtocol";
+export declare const GITHUB_REPO = "aztec-packages";
+export declare const GITHUB_TAG_PREFIX = "aztec-packages";
+//# sourceMappingURL=github.d.ts.map

package/dest/utils/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../src/utils/github.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,kBAAkB,CAAC;AAC5C,eAAO,MAAM,WAAW,mBAAmB,CAAC;AAC5C,eAAO,MAAM,iBAAiB,mBAAmB,CAAC"}

package/dest/utils/github.js

@@ -0,0 +1,3 @@
+export const GITHUB_OWNER = 'AztecProtocol';
+export const GITHUB_REPO = 'aztec-packages';
+export const GITHUB_TAG_PREFIX = 'aztec-packages';

package/dest/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './commands.js';
+export * from './aztec.js';
+export * from './encoding.js';
+export * from './github.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dest/utils/index.js

@@ -0,0 +1,4 @@
+export * from './commands.js';
+export * from './aztec.js';
+export * from './encoding.js';
+export * from './github.js';

package/dest/utils/inspect.d.ts

@@ -0,0 +1,17 @@
+import type { ContractArtifact, Fr } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { TxHash } from '@aztec/stdlib/tx';
+export declare function inspectBlock(pxe: PXE, blockNumber: number, log: LogFn, opts?: {
+    showTxs?: boolean;
+}): Promise<void>;
+export declare function inspectTx(pxe: PXE, txHash: TxHash, log: LogFn, opts?: {
+    includeBlockInfo?: boolean;
+    artifactMap?: ArtifactMap;
+}): Promise<void>;
+type ArtifactMap = Record<string, ContractArtifactWithClassId>;
+type ContractArtifactWithClassId = ContractArtifact & {
+    classId: Fr;
+};
+export {};
+//# sourceMappingURL=inspect.d.ts.map

package/dest/utils/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/utils/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,gBAAgB,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,wBAAsB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,iBA0B7G;AAED,wBAAsB,SAAS,CAC7B,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,KAAK,EACV,IAAI,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CAAO,iBAmGrE;AAyCD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;AAC/D,KAAK,2BAA2B,GAAG,gBAAgB,GAAG;IAAE,OAAO,EAAE,EAAE,CAAA;CAAE,CAAC"}