@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/wallet/wallet.ts

@@ -1,34 +1,363 @@
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import { BlockNumber, BlockNumberPositiveSchema } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  type AbiDecoded,
+  AbiTypeSchema,
+  type ContractArtifact,
+  ContractArtifactSchema,
+  type EventMetadataDefinition,
+  type FunctionCall,
+  FunctionType,
+} from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassMetadata,
+  ContractClassWithIdSchema,
+  type ContractInstanceWithAddress,
+  ContractInstanceWithAddressSchema,
+  type ContractMetadata,
+} from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import { AbiDecodedSchema, type ApiSchemaFor, type ZodFor, optional, schemas } from '@aztec/stdlib/schemas';
+import {
+  Capsule,
+  HashedValues,
+  TxHash,
+  TxProfileResult,
+  TxReceipt,
+  TxSimulationResult,
+  UtilitySimulationResult,
+  inTxSchema,
+} from '@aztec/stdlib/tx';
+import type { ExecutionPayload, InTx } from '@aztec/stdlib/tx';
 
-import type { AccountInterface } from '../account/interface.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
+import { z } from 'zod';
+
+import type {
+  FeeEstimationOptions,
+  GasSettingsOption,
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SimulateInteractionOptions,
+} from '../contract/interaction_options.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+
+/**
+ * A wrapper type that allows any item to be associated with an alias.
+ */
+export type Aliased<T> = {
+  /**
+   * The alias
+   */
+  alias: string;
+  /**
+   * The item being aliased.
+   */
+  item: T;
+};
+
+/**
+ * Options for simulating interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type SimulateOptions = Omit<SimulateInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption & FeeEstimationOptions;
+};
+
+/**
+ * Options for profiling interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type ProfileOptions = Omit<ProfileInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption;
+};
+
+/**
+ * Options for sending/proving interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type SendOptions = Omit<SendInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption;
+};
+
+/**
+ * Helper type that represents all methods that can be batched.
+ */
+export type BatchableMethods = Pick<
+  Wallet,
+  'registerContract' | 'sendTx' | 'registerSender' | 'simulateUtility' | 'simulateTx'
+>;
+
+/**
+ * From the batchable methods, we create a type that represents a method call with its name and arguments.
+ * This is what the wallet will accept as arguments to the `batch` method.
+ */
+export type BatchedMethod<T extends keyof BatchableMethods> = {
+  /** The method name */
+  name: T;
+  /** The method arguments */
+  args: Parameters<BatchableMethods[T]>;
+};
+
+/**
+ * Helper type to extract the return type of a batched method
+ */
+export type BatchedMethodResult<T> =
+  T extends BatchedMethod<infer K> ? Awaited<ReturnType<BatchableMethods[K]>> : never;
+
+/**
+ * Wrapper type for batch results that includes the method name for discriminated union deserialization.
+ * Each result is wrapped as \{ name: 'methodName', result: ActualResult \} to allow proper deserialization
+ * when AztecAddress and TxHash would otherwise be ambiguous (both are hex strings).
+ */
+export type BatchedMethodResultWrapper<T extends BatchedMethod<keyof BatchableMethods>> = {
+  /** The method name */
+  name: T['name'];
+  /** The method result */
+  result: BatchedMethodResult<T>;
+};
+
+/**
+ * Maps a tuple of BatchedMethod to a tuple of their wrapped return types
+ */
+export type BatchResults<T extends readonly BatchedMethod<keyof BatchableMethods>[]> = {
+  [K in keyof T]: BatchedMethodResultWrapper<T[K]>;
+};
+
+/**
+ * Filter options when querying private events.
+ */
+export type PrivateEventFilter = {
+  /** The address of the contract that emitted the events. */
+  contractAddress: AztecAddress;
+  /** Addresses of accounts that are in scope for this filter. */
+  scopes: AztecAddress[];
+  /** Transaction in which the events were emitted. */
+  txHash?: TxHash;
+  /** The block number from which to start fetching events (inclusive).
+   * Optional. If provided, it must be greater or equal than 1.
+   * Defaults to the initial L2 block number (INITIAL_L2_BLOCK_NUM).
+   * */
+  fromBlock?: BlockNumber;
+  /** The block number until which to fetch logs (not inclusive).
+   * Optional. If provided, it must be greater than fromBlock.
+   * Defaults to the latest known block to PXE + 1.
+   */
+  toBlock?: BlockNumber;
+};
+
+/**
+ * An ABI decoded private event with associated metadata.
+ */
+export type PrivateEvent<T> = {
+  /** The ABI decoded event */
+  event: T;
+  /** Metadata describing event context information such as tx and block */
+  metadata: InTx;
+};
 
 /**
  * The wallet interface.
  */
-export type Wallet = AccountInterface &
-  Pick<
-    PXE,
-    | 'simulateTx'
-    | 'simulateUtility'
-    | 'profileTx'
-    | 'sendTx'
-    | 'getContractClassMetadata'
-    | 'getContractMetadata'
-    | 'registerContract'
-    | 'registerContractClass'
-    | 'proveTx'
-    | 'getNodeInfo'
-    | 'getPXEInfo'
-    | 'getCurrentBaseFees'
-    | 'updateContract'
-    | 'registerSender'
-    | 'getSenders'
-    | 'removeSender'
-    | 'getTxReceipt'
-    | 'getPrivateEvents'
-    | 'getPublicEvents'
-  > & {
-    createAuthWit(intent: IntentInnerHash | IntentAction): Promise<AuthWitness>;
-  };
+export type Wallet = {
+  getContractClassMetadata(id: Fr, includeArtifact?: boolean): Promise<ContractClassMetadata>;
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
+  getPrivateEvents<T>(
+    eventMetadata: EventMetadataDefinition,
+    eventFilter: PrivateEventFilter,
+  ): Promise<PrivateEvent<T>[]>;
+  getChainInfo(): Promise<ChainInfo>;
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
+  registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress>;
+  getAddressBook(): Promise<Aliased<AztecAddress>[]>;
+  getAccounts(): Promise<Aliased<AztecAddress>[]>;
+  registerContract(
+    instance: ContractInstanceWithAddress,
+    artifact?: ContractArtifact,
+    secretKey?: Fr,
+  ): Promise<ContractInstanceWithAddress>;
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
+  simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult>;
+  profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
+  sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
+  createAuthWit(from: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent): Promise<AuthWitness>;
+  batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(methods: T): Promise<BatchResults<T>>;
+};
+
+export const FunctionCallSchema = z.object({
+  name: z.string(),
+  to: schemas.AztecAddress,
+  selector: schemas.FunctionSelector,
+  type: z.nativeEnum(FunctionType),
+  isStatic: z.boolean(),
+  hideMsgSender: z.boolean(),
+  args: z.array(schemas.Fr),
+  returnTypes: z.array(AbiTypeSchema),
+});
+
+export const ExecutionPayloadSchema = z.object({
+  calls: z.array(FunctionCallSchema),
+  authWitnesses: z.array(AuthWitness.schema),
+  capsules: z.array(Capsule.schema),
+  extraHashedArgs: z.array(HashedValues.schema),
+  feePayer: optional(schemas.AztecAddress),
+});
+
+export const GasSettingsOptionSchema = z.object({
+  gasSettings: optional(
+    z.object({
+      gasLimits: optional(Gas.schema),
+      teardownGasLimits: optional(Gas.schema),
+      maxFeePerGas: optional(z.object({ feePerDaGas: schemas.BigInt, feePerL2Gas: schemas.BigInt })),
+      maxPriorityFeePerGas: optional(z.object({ feePerDaGas: schemas.BigInt, feePerL2Gas: schemas.BigInt })),
+    }),
+  ),
+});
+
+export const WalletSimulationFeeOptionSchema = GasSettingsOptionSchema.extend({
+  estimatedGasPadding: optional(z.number()),
+  estimateGas: optional(z.boolean()),
+});
+
+export const SendOptionsSchema = z.object({
+  from: schemas.AztecAddress,
+  authWitnesses: optional(z.array(AuthWitness.schema)),
+  capsules: optional(z.array(Capsule.schema)),
+  fee: optional(GasSettingsOptionSchema),
+});
+
+export const SimulateOptionsSchema = z.object({
+  from: schemas.AztecAddress,
+  authWitnesses: optional(z.array(AuthWitness.schema)),
+  capsules: optional(z.array(Capsule.schema)),
+  fee: optional(WalletSimulationFeeOptionSchema),
+  skipTxValidation: optional(z.boolean()),
+  skipFeeEnforcement: optional(z.boolean()),
+  includeMetadata: optional(z.boolean()),
+});
+
+export const ProfileOptionsSchema = SimulateOptionsSchema.extend({
+  profileMode: z.enum(['gates', 'execution-steps', 'full']),
+  skipProofGeneration: optional(z.boolean()),
+});
+
+export const MessageHashOrIntentSchema = z.union([
+  schemas.Fr,
+  z.object({ consumer: schemas.AztecAddress, innerHash: schemas.Fr }),
+  z.object({
+    caller: schemas.AztecAddress,
+    call: FunctionCallSchema,
+  }),
+]);
+
+export const BatchedMethodSchema = z.union([
+  z.object({
+    name: z.literal('registerSender'),
+    args: z.tuple([schemas.AztecAddress, optional(z.string())]),
+  }),
+  z.object({
+    name: z.literal('registerContract'),
+    args: z.tuple([ContractInstanceWithAddressSchema, optional(ContractArtifactSchema), optional(schemas.Fr)]),
+  }),
+  z.object({
+    name: z.literal('sendTx'),
+    args: z.tuple([ExecutionPayloadSchema, SendOptionsSchema]),
+  }),
+  z.object({
+    name: z.literal('simulateUtility'),
+    args: z.tuple([FunctionCallSchema, optional(z.array(AuthWitness.schema))]),
+  }),
+  z.object({
+    name: z.literal('simulateTx'),
+    args: z.tuple([ExecutionPayloadSchema, SimulateOptionsSchema]),
+  }),
+]);
+
+export const ContractMetadataSchema = z.object({
+  contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
+  isContractInitialized: z.boolean(),
+  isContractPublished: z.boolean(),
+}) satisfies ZodFor<ContractMetadata>;
+
+export const ContractClassMetadataSchema = z.object({
+  contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
+  isContractClassPubliclyRegistered: z.boolean(),
+  artifact: z.union([ContractArtifactSchema, z.undefined()]),
+}) satisfies ZodFor<ContractClassMetadata>;
+
+export const EventMetadataDefinitionSchema = z.object({
+  eventSelector: schemas.EventSelector,
+  abiType: AbiTypeSchema,
+  fieldNames: z.array(z.string()),
+});
+
+export const PrivateEventSchema: ZodFor<PrivateEvent<AbiDecoded>> = z.object({
+  event: AbiDecodedSchema,
+  metadata: inTxSchema(),
+});
+
+export const PrivateEventFilterSchema = z.object({
+  contractAddress: schemas.AztecAddress,
+  scopes: z.array(schemas.AztecAddress),
+  txHash: optional(TxHash.schema),
+  fromBlock: optional(BlockNumberPositiveSchema),
+  toBlock: optional(BlockNumberPositiveSchema),
+});
+
+export const WalletSchema: ApiSchemaFor<Wallet> = {
+  getChainInfo: z
+    .function()
+    .args()
+    .returns(z.object({ chainId: schemas.Fr, version: schemas.Fr })),
+  getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),
+  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
+  getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
+  getPrivateEvents: z
+    .function()
+    .args(EventMetadataDefinitionSchema, PrivateEventFilterSchema)
+    .returns(z.array(PrivateEventSchema)),
+  registerSender: z.function().args(schemas.AztecAddress, optional(z.string())).returns(schemas.AztecAddress),
+  getAddressBook: z
+    .function()
+    .args()
+    .returns(z.array(z.object({ alias: z.string(), item: schemas.AztecAddress }))),
+  getAccounts: z
+    .function()
+    .args()
+    .returns(z.array(z.object({ alias: z.string(), item: schemas.AztecAddress }))),
+  registerContract: z
+    .function()
+    .args(ContractInstanceWithAddressSchema, optional(ContractArtifactSchema), optional(schemas.Fr))
+    .returns(ContractInstanceWithAddressSchema),
+  simulateTx: z.function().args(ExecutionPayloadSchema, SimulateOptionsSchema).returns(TxSimulationResult.schema),
+  simulateUtility: z
+    .function()
+    .args(FunctionCallSchema, optional(z.array(AuthWitness.schema)))
+    .returns(UtilitySimulationResult.schema),
+  profileTx: z.function().args(ExecutionPayloadSchema, ProfileOptionsSchema).returns(TxProfileResult.schema),
+  sendTx: z.function().args(ExecutionPayloadSchema, SendOptionsSchema).returns(TxHash.schema),
+  createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
+  // @ts-expect-error - ApiSchemaFor cannot properly type generic methods with readonly arrays
+  batch: z
+    .function()
+    .args(z.array(BatchedMethodSchema))
+    .returns(
+      z.array(
+        z.discriminatedUnion('name', [
+          z.object({ name: z.literal('registerSender'), result: schemas.AztecAddress }),
+          z.object({ name: z.literal('registerContract'), result: ContractInstanceWithAddressSchema }),
+          z.object({ name: z.literal('sendTx'), result: TxHash.schema }),
+          z.object({ name: z.literal('simulateUtility'), result: UtilitySimulationResult.schema }),
+          z.object({ name: z.literal('simulateTx'), result: TxSimulationResult.schema }),
+        ]),
+      ),
+    ),
+};

package/dest/account_manager/account_manager.d.ts

@@ -1,119 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { AccountContract } from '../account/account_contract.js';
-import type { Salt } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { type WaitOpts } from '../contract/sent_tx.js';
-import { AccountEntrypointMetaPaymentMethod } from '../fee/account_entrypoint_meta_payment_method.js';
-import { AztecAddress, type FeePaymentMethod } from '../index.js';
-import { AccountWalletWithSecretKey, type Wallet } from '../wallet/index.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-/**
- * Options to deploy an account contract.
- */
-export type DeployAccountOptions = Pick<DeployOptions, 'fee' | 'skipClassPublication' | 'skipInstancePublication' | 'skipInitialization'> & {
-    /**
-     * Wallet used for any txs to initialize and/or publish the account contract. Must be funded in order to pay for the fee.
-     */
-    deployWallet?: Wallet;
-};
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */
-export declare class AccountManager {
-    private pxe;
-    private secretKey;
-    private accountContract;
-    private instance;
-    /**
-     * Contract instantiation salt for the account contract
-     */
-    readonly salt: Salt;
-    private constructor();
-    static create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt): Promise<AccountManager>;
-    protected getPublicKeys(): import("@aztec/stdlib/keys").PublicKeys;
-    protected getPublicKeysHash(): Fr | Promise<Fr>;
-    /**
-     * Returns the entrypoint for this account as defined by its account contract.
-     * @returns An entrypoint.
-     */
-    getAccount(): Promise<AccountInterface>;
-    /**
-     * Gets the calculated complete address associated with this account.
-     * Does not require the account to have been published for public execution.
-     * @returns The address, partial address, and encryption public key.
-     */
-    getCompleteAddress(): Promise<CompleteAddress>;
-    /**
-     * Gets the address for this given account.
-     * Does not require the account to have been published for public execution.
-     * @returns The address.
-     */
-    getAddress(): AztecAddress;
-    /**
-     * Returns the contract instance definition associated with this account.
-     * Does not require the account to have been published for public execution.
-     * @returns ContractInstance instance.
-     */
-    getInstance(): ContractInstanceWithAddress;
-    /**
-     * Returns a Wallet instance associated with this account. Use it to create Contract
-     * instances to be interacted with from this account.
-     * @returns A Wallet instance.
-     */
-    getWallet(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Add this account in the PXE Service and returns the associated wallet. Adding
-     * the account to the PXE Service is required for managing private state associated with it.
-     * Use the returned wallet to create Contract instances to be interacted with from this account.
-     * @param opts - Options to wait for the account to be synched.
-     * @returns A Wallet instance.
-     */
-    register(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns the pre-populated ContractSetupMethods which can prepare a tx to
-     * initialize and/or publish this account's account contract (depending on the contract's design).
-     * If no wallet is provided, it uses a signerless wallet with the multi call entrypoint
-     * @param deployWallet - Wallet used for any txs that are needed to
-     * set up the account contract for use.
-     * @returns A ContractSetupMethods instance that can set up this account contract for use
-     */
-    getDeployMethod(deployWallet?: Wallet): Promise<DeployMethod>;
-    /**
-     * Returns a FeePaymentMethod that routes the original one provided as an argument
-     * through the account's entrypoint. This allows an account contract to pay
-     * for its own deployment and initialization.
-     *
-     * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
-     *
-     * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
-     * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
-     */
-    getSelfPaymentMethod(originalPaymentMethod?: FeePaymentMethod): Promise<AccountEntrypointMetaPaymentMethod>;
-    /**
-     * Submits a tx to initialize and/or publish this account's account contract
-     * (depending on the contract's design).
-     * Doesn't necessarily publish the class nor publish the instance.
-     * Uses the salt provided in the constructor or a randomly generated one.
-     * Adds the account to the PXE Service first.
-     * @param opts - Fee options to be used for the deployment.
-     * @returns A SentTx object that can be waited to get the associated Wallet.
-     */
-    deploy(opts?: DeployAccountOptions): DeployAccountSentTx;
-    /**
-     * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-     * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-     * is required it skips the transaction, and only registers the account in the PXE Service.
-     * @param opts - Options to wait for the tx to be mined.
-     * @returns A Wallet instance.
-     */
-    waitSetup(opts?: DeployAccountOptions & WaitOpts): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns whether this account contract has an initializer function.
-     */
-    hasInitializer(): Promise<boolean>;
-}
-//# sourceMappingURL=account_manager.d.ts.map

package/dest/account_manager/account_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"account_manager.d.ts","sourceRoot":"","sources":["../../src/account_manager/account_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,kCAAkC,EAAE,MAAM,kDAAkD,CAAC;AACtG,OAAO,EAAE,YAAY,EAAyB,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACzF,OAAO,EAAE,0BAA0B,EAAoB,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,aAAa,EACb,KAAK,GAAG,sBAAsB,GAAG,yBAAyB,GAAG,oBAAoB,CAClF,GAAG;IACF;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAChB;;OAEG;aACa,IAAI,EAAE,IAAI;IAR5B,OAAO;WAWM,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,IAAI;IAoB1F,SAAS,CAAC,aAAa;IAIvB,SAAS,CAAC,iBAAiB;IAI3B;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAMpD;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAIrD;;;;OAIG;IACI,UAAU;IAIjB;;;;OAIG;IACI,WAAW,IAAI,2BAA2B;IAIjD;;;;OAIG;IACU,SAAS,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAK7D;;;;;;OAMG;IACU,QAAQ,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAW5D;;;;;;;OAOG;IACU,eAAe,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAgD1E;;;;;;;;;OASG;IACU,oBAAoB,CAAC,qBAAqB,CAAC,EAAE,gBAAgB;IAa1E;;;;;;;;OAQG;IACI,MAAM,CAAC,IAAI,CAAC,EAAE,oBAAoB,GAAG,mBAAmB;IA6B/D;;;;;;OAMG;IACU,SAAS,CAAC,IAAI,GAAE,oBAAoB,GAAG,QAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAKpH;;OAEG;IACU,cAAc;CAG5B"}