@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

package/src/exos/icq-connection-kit.js

@@ -0,0 +1,135 @@
+/** @file ICQConnection Exo */
+import { NonNullish } from '@agoric/assert';
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { makeQueryPacket, parseQueryPacket } from '../utils/packet.js';
+import { OutboundConnectionHandlerI } from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Connection, Port} from '@agoric/network';
+ * @import {Remote, VowTools} from '@agoric/vow';
+ * @import {JsonSafe} from '@agoric/cosmic-proto';
+ * @import {RequestQuery, ResponseQuery} from '@agoric/cosmic-proto/tendermint/abci/types.js';
+ * @import {LocalIbcAddress, RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('Orchestration:ICQConnection');
+
+export const ICQMsgShape = M.splitRecord(
+  { path: M.string(), data: M.string() },
+  { height: M.string(), prove: M.boolean() },
+);
+
+export const ICQConnectionI = M.interface('ICQConnection', {
+  getLocalAddress: M.call().returns(M.string()),
+  getRemoteAddress: M.call().returns(M.string()),
+  query: M.call(M.arrayOf(ICQMsgShape)).returns(M.promise()),
+});
+
+/**
+ * @typedef {{
+ *   port: Port;
+ *   connection: Remote<Connection> | undefined;
+ *   localAddress: LocalIbcAddress | undefined;
+ *   remoteAddress: RemoteIbcAddress | undefined;
+ * }} ICQConnectionKitState
+ */
+
+/**
+ * Prepares an ICQ Connection Kit based on the
+ * {@link https://github.com/cosmos/ibc-apps/blob/e9b46e4bf0ad0a66cf6bc53b5e5496f6e2b4b02b/modules/async-icq/README.md | `icq/v1` IBC application protocol}.
+ *
+ * `icq/v1`, also referred to as `async-icq`, is a protocol for asynchronous
+ * queries between IBC-enabled chains. It allows a chain to send queries to
+ * another chain and receive responses asynchronously.
+ *
+ * The ICQ connection kit provides the necessary functionality to establish and
+ * manage an ICQ connection between two chains. It includes methods for
+ * retrieving the local and remote addresses of the connection, as well as
+ * sending queries and handling connection events.
+ *
+ * @param {Zone} zone
+ * @param {VowTools} vowTools
+ */
+export const prepareICQConnectionKit = (zone, { watch, when }) =>
+  zone.exoClassKit(
+    'ICQConnectionKit',
+    {
+      connection: ICQConnectionI,
+      connectionHandler: OutboundConnectionHandlerI,
+      parseQueryPacketWatcher: M.interface('ParseQueryPacketWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // does not need watcherContext
+          .returns(M.arrayOf(M.record())),
+      }),
+    },
+    /** @param {Port} port */
+    port =>
+      /** @type {ICQConnectionKitState} */ ({
+        port,
+        connection: undefined,
+        remoteAddress: undefined,
+        localAddress: undefined,
+      }),
+    {
+      connection: {
+        getLocalAddress() {
+          return NonNullish(
+            this.state.localAddress,
+            'local address not available',
+          );
+        },
+        getRemoteAddress() {
+          return NonNullish(
+            this.state.remoteAddress,
+            'remote address not available',
+          );
+        },
+        /**
+         * @param {JsonSafe<RequestQuery>[]} msgs
+         * @returns {Promise<JsonSafe<ResponseQuery>[]>}
+         * @throws {Error} if packet fails to send or an error is returned
+         */
+        query(msgs) {
+          const { connection } = this.state;
+          // TODO #9281 do not throw synchronously when returning a promise; return a rejected Vow
+          /// see https://github.com/Agoric/agoric-sdk/pull/9454#discussion_r1626898694
+          if (!connection) throw Fail`connection not available`;
+          return when(
+            watch(
+              E(connection).send(makeQueryPacket(msgs)),
+              this.facets.parseQueryPacketWatcher,
+            ),
+          );
+        },
+      },
+      parseQueryPacketWatcher: {
+        /** @param {string} ack packet acknowledgement string */
+        onFulfilled(ack) {
+          return parseQueryPacket(ack);
+        },
+      },
+      connectionHandler: {
+        /**
+         * @param {Remote<Connection>} connection
+         * @param {LocalIbcAddress} localAddr
+         * @param {RemoteIbcAddress} remoteAddr
+         */
+        async onOpen(connection, localAddr, remoteAddr) {
+          trace(`ICQ Channel Opened for ${localAddr} at ${remoteAddr}`);
+          this.state.connection = connection;
+          this.state.remoteAddress = remoteAddr;
+          this.state.localAddress = localAddr;
+        },
+        async onClose(_connection, reason) {
+          trace(`ICQ Channel closed. Reason: ${reason}`);
+        },
+      },
+    },
+  );
+
+/** @typedef {ReturnType<ReturnType<typeof prepareICQConnectionKit>>} ICQConnectionKit */
+/** @typedef {ICQConnectionKit['connection']} ICQConnection */

package/src/exos/local-chain-facade.d.ts

@@ -0,0 +1,81 @@
+export function prepareLocalChainFacade(zone: Zone, powers: LocalChainFacadePowers): (localChainInfo: Readonly<{
+    chainId: string;
+    connections?: Record<string, IBCConnectionInfo>;
+    icqEnabled?: boolean;
+    stakingTokens?: Readonly<Array<{
+        denom: string;
+    }>>;
+}>) => ReturnType<(localChainInfo: Readonly<{
+    chainId: string;
+    connections?: Record<string, IBCConnectionInfo>;
+    icqEnabled?: boolean;
+    stakingTokens?: Readonly<Array<{
+        denom: string;
+    }>>;
+}>) => import("@endo/exo").GuardedKit<{
+    public: {
+        getChainInfo(): Vow<Readonly<{
+            chainId: string;
+            connections?: Record<string, IBCConnectionInfo>;
+            icqEnabled?: boolean;
+            stakingTokens?: Readonly<Array<{
+                denom: string;
+            }>>;
+        }>>;
+        /** @returns {Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>} */
+        makeAccount(): Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>;
+    };
+    makeAccountWatcher: {
+        /**
+         * @param {[LocalChainAccount, ChainAddress['address']]} results
+         */
+        onFulfilled([account, address]: [LocalChainAccount, ChainAddress["address"]]): import("@endo/exo").Guarded<{
+            getBalance(denom: import("../orchestration-api.js").DenomArg): Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): Vow<never>;
+            getPublicTopics(): {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("./local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<Record<unknown, unknown>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<void | import("@agoric/time").TimestampRecord>;
+            deposit(payment: globalThis.Payment<"nat">): Vow<void>;
+            withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): Vow<globalThis.Payment<"nat"> | Vow<globalThis.Payment<"nat">>>;
+            executeTx(messages: {
+                '@type': string;
+            }[]): Vow<import("@agoric/cosmic-proto").JsonSafe<{
+                '@type': string;
+            }>[]>;
+            getAddress(): ChainAddress;
+            send(toAccount: any, amount: any): Vow<never>;
+            transfer(amount: import("../orchestration-api.js").AmountArg, destination: ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): Vow<void>;
+            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): Vow<void>;
+        }>;
+    };
+}>>["public"];
+export type LocalChainFacadePowers = {
+    makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+    orchestration: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    timer: Remote<TimerService>;
+    localchain: Remote<LocalChain>;
+    vowTools: VowTools;
+};
+export type MakeLocalChainFacade = ReturnType<typeof prepareLocalChainFacade>;
+import type { Zone } from '@agoric/base-zone';
+import type { IBCConnectionInfo } from '../types.js';
+import type { Vow } from '@agoric/vow';
+import type { ChainInfo } from '../types.js';
+import type { OrchestrationAccount } from '../types.js';
+import type { PromiseToVow } from '../types.js';
+import type { LocalChainAccount } from '@agoric/vats/src/localchain.js';
+import type { ChainAddress } from '../types.js';
+import type { MakeLocalOrchestrationAccountKit } from './local-orchestration-account.js';
+import type { OrchestrationService } from '../service.js';
+import type { Remote } from '@agoric/internal';
+import type { TimerService } from '@agoric/time';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { VowTools } from '@agoric/vow';
+//# sourceMappingURL=local-chain-facade.d.ts.map

package/src/exos/local-chain-facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AA0GO,8CAHI,IAAI,UACJ,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;QAtCzB,oEAAoE;uBAAtD,IAAI,aAAa,qBAAqB,SAAS,CAAC,CAAC,CAAC;;;QAchE;;WAEG;wCADQ,CAAC,iBAAiB,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cA4B9D;qCA1FY;IACZ,gCAAoC,EAAE,gCAAgC,CAAC;IACvE,aAAiB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IAChD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,KAAS,EAAE,OAAO,YAAY,CAAC,CAAC;IAChC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,QAAY,EAAE,QAAQ,CAAC;CACpB;mCAsFU,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAxGjC,mBAAmB;uCAOwE,aAAa;yBAH/F,aAAa;+BAGqE,aAAa;0CAAb,aAAa;kCAAb,aAAa;uCAJ/E,gCAAgC;kCAIkC,aAAa;sDAD5E,kCAAkC;0CAD9C,eAAe;4BAH7B,kBAAkB;kCADZ,cAAc;gCAEG,gCAAgC;8BAChD,aAAa"}

package/src/exos/local-chain-facade.js

@@ -0,0 +1,113 @@
+/** @file ChainAccount exo */
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { pickFacet } from '@agoric/vat-data';
+
+import { ChainFacadeI } from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ * @import {LocalChain, LocalChainAccount} from '@agoric/vats/src/localchain.js';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
+ * @import {ChainAddress, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, PromiseToVow} from '../types.js';
+ */
+
+/**
+ * @typedef {{
+ *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+ *   orchestration: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timer: Remote<TimerService>;
+ *   localchain: Remote<LocalChain>;
+ *   vowTools: VowTools;
+ * }} LocalChainFacadePowers
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {LocalChainFacadePowers} powers
+ */
+const prepareLocalChainFacadeKit = (
+  zone,
+  {
+    makeLocalOrchestrationAccountKit,
+    localchain,
+    storageNode,
+    vowTools: { allVows, watch },
+  },
+) =>
+  zone.exoClassKit(
+    'LocalChainFacade',
+    {
+      public: ChainFacadeI,
+      makeAccountWatcher: M.interface('undelegateWatcher', {
+        onFulfilled: M.call([M.remotable('LCA Account'), M.string()])
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.remotable()),
+      }),
+    },
+    /**
+     * @param {CosmosChainInfo} localChainInfo
+     */
+    localChainInfo => {
+      return { localChainInfo };
+    },
+    {
+      public: {
+        getChainInfo() {
+          return watch(this.state.localChainInfo);
+        },
+
+        // FIXME parameterize on the remoteChainInfo to make()
+        // That used to work but got lost in the migration to Exo
+        /** @returns {Vow<PromiseToVow<OrchestrationAccount<ChainInfo>>>} */
+        makeAccount() {
+          const lcaP = E(localchain).makeAccount();
+          // TODO #9449 fix types
+          // @ts-expect-error Type 'Vow<Voidless>' is not assignable to type 'Vow<OrchestrationAccountI>'.
+          return watch(
+            // TODO #9449 fix types
+            // @ts-expect-error Property 'getAddress' does not exist on type 'EMethods<Required<Guarded<{ getAddress()...
+            allVows([lcaP, E(lcaP).getAddress()]),
+            this.facets.makeAccountWatcher,
+          );
+        },
+      },
+      makeAccountWatcher: {
+        /**
+         * @param {[LocalChainAccount, ChainAddress['address']]} results
+         */
+        onFulfilled([account, address]) {
+          const { localChainInfo } = this.state;
+          const { holder } = makeLocalOrchestrationAccountKit({
+            account,
+            address: harden({
+              address,
+              addressEncoding: 'bech32',
+              chainId: localChainInfo.chainId,
+            }),
+            // FIXME storage path https://github.com/Agoric/agoric-sdk/issues/9066
+            storageNode,
+          });
+          return holder;
+        },
+      },
+    },
+  );
+harden(prepareLocalChainFacadeKit);
+
+/**
+ * @param {Zone} zone
+ * @param {LocalChainFacadePowers} powers
+ */
+export const prepareLocalChainFacade = (zone, powers) => {
+  const makeLocalChainFacadeKit = prepareLocalChainFacadeKit(zone, powers);
+  return pickFacet(makeLocalChainFacadeKit, 'public');
+};
+harden(prepareLocalChainFacade);
+
+/** @typedef {ReturnType<typeof prepareLocalChainFacade>} MakeLocalChainFacade */

package/src/exos/local-orchestration-account.d.ts

@@ -0,0 +1,176 @@
+export function prepareLocalOrchestrationAccountKit(zone: Zone, makeRecorderKit: MakeRecorderKit, zcf: ZCF, timerService: Remote<TimerService>, { watch, allVows, asVow }: VowTools, chainHub: ChainHub): (args_0: {
+    account: LocalChainAccount;
+    address: ChainAddress;
+    storageNode: Remote<StorageNode>;
+}) => import("@endo/exo").GuardedKit<{
+    invitationMakers: {
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Vow<Record<unknown, unknown>>, undefined>>;
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Vow<TimestampRecord>, undefined>>;
+        CloseAccount(): never;
+    };
+    undelegateWatcher: {
+        /**
+         * @param {[
+         *   JsonSafe<
+         *     TypedJson<'/cosmos.staking.v1beta1.MsgUndelegateResponse'>
+         *   >,
+         * ]} response
+         */
+        onFulfilled(response: [JsonSafe<TypedJson<"/cosmos.staking.v1beta1.MsgUndelegateResponse">>]): Vow<TimestampRecord>;
+    };
+    getChainInfoWatcher: {
+        /**
+         * @param {ChainInfo} agoricChainInfo
+         * @param {ChainAddress} destination
+         */
+        onFulfilled(agoricChainInfo: ChainInfo, destination: ChainAddress): Vow<IBCConnectionInfo>;
+    };
+    transferWatcher: {
+        /**
+         * @param {[
+         *   { transferChannel: IBCConnectionInfo['transferChannel'] },
+         *   bigint,
+         * ]} results
+         * @param {{
+         *   destination: ChainAddress;
+         *   opts: IBCMsgTransferOptions;
+         *   amount: DenomAmount;
+         * }} ctx
+         */
+        onFulfilled([{ transferChannel }, timeoutTimestamp]: [{
+            transferChannel: IBCConnectionInfo["transferChannel"];
+        }, bigint], { opts, amount, destination }: {
+            destination: ChainAddress;
+            opts: IBCMsgTransferOptions;
+            amount: DenomAmount;
+        }): Vow<JsonSafe<import("@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js").MsgTransferResponse & {
+            '@type': "/ibc.applications.transfer.v1.MsgTransferResponse";
+        }>[]>;
+    };
+    /**
+     * takes an array of results (from `executeEncodedTx`) and returns the
+     * first result
+     */
+    extractFirstResultWatcher: {
+        /**
+         * @param {Record<unknown, unknown>[]} results
+         */
+        onFulfilled(results: Record<unknown, unknown>[]): Record<unknown, unknown>;
+    };
+    /**
+     * takes an array of results (from `executeEncodedTx`) and returns void
+     * since we are not interested in the result
+     */
+    returnVoidWatcher: {
+        /**
+         * @param {unknown} _result
+         */
+        onFulfilled(_result: unknown): undefined;
+    };
+    /**
+     * handles a request for balance from a bank purse and returns the balance
+     * as a Chain Amount
+     */
+    getBalanceWatcher: {
+        /**
+         * @param {Amount<'nat'>} natAmount
+         * @param {DenomAmount['denom']} denom
+         * @returns {DenomAmount}
+         */
+        onFulfilled(natAmount: Amount<"nat">, denom: DenomAmount["denom"]): DenomAmount;
+    };
+    holder: {
+        /**
+         * TODO: balance lookups for non-vbank assets
+         *
+         * @type {PromiseToVow<OrchestrationAccount<any>['getBalance']>}
+         */
+        getBalance(denom: import("@agoric/orchestration").DenomArg): Vow<DenomAmount>;
+        getBalances(): Vow<never>;
+        getPublicTopics(): {
+            account: {
+                description: string;
+                subscriber: globalThis.Subscriber<LocalChainAccountNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<Record<unknown, unknown>>;
+        /**
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         * @returns {Vow<void | TimestampRecord>}
+         */
+        undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Vow<void | TimestampRecord>;
+        /**
+         * Starting a transfer revokes the account holder. The associated
+         * updater will get a special notification that the account is being
+         * transferred.
+         */
+        /** @type {PromiseToVow<OrchestrationAccount<any>['deposit']>} */
+        deposit(payment: globalThis.Payment<"nat">): Vow<void>;
+        /** @type {PromiseToVow<LocalChainAccount['withdraw']>} */
+        withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): Vow<globalThis.Payment<"nat"> | Vow<globalThis.Payment<"nat">>>;
+        /** @type {PromiseToVow<LocalChainAccount['executeTx']>} */
+        executeTx(messages: {
+            '@type': string;
+        }[]): Vow<JsonSafe<{
+            '@type': string;
+        }>[]>;
+        /** @type {OrchestrationAccount<any>['getAddress']} */
+        getAddress(): ChainAddress;
+        send(toAccount: any, amount: any): Vow<never>;
+        /**
+         * @param {AmountArg} amount an ERTP {@link Amount} or a
+         *   {@link DenomAmount}
+         * @param {ChainAddress} destination
+         * @param {IBCMsgTransferOptions} [opts] if either timeoutHeight or
+         *   timeoutTimestamp are not supplied, a default timeoutTimestamp will
+         *   be set for 5 minutes in the future
+         * @returns {Vow<void>}
+         */
+        transfer(amount: AmountArg, destination: ChainAddress, opts?: IBCMsgTransferOptions | undefined): Vow<void>;
+        /** @type {PromiseToVow<OrchestrationAccount<any>['transferSteps']>} */
+        transferSteps(amount: AmountArg, msg: import("@agoric/orchestration").TransferMsg): Vow<void>;
+    };
+}>;
+export type LocalChainAccountNotification = {
+    address: string;
+};
+export type State = {
+    topicKit: RecorderKit<LocalChainAccountNotification>;
+    account: LocalChainAccount;
+    address: ChainAddress;
+};
+export type MakeLocalOrchestrationAccountKit = ReturnType<typeof prepareLocalOrchestrationAccountKit>;
+export type LocalOrchestrationAccountKit = ReturnType<MakeLocalOrchestrationAccountKit>;
+import type { Zone } from '@agoric/zone';
+import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { TimerService } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
+import type { VowTools } from '@agoric/vow';
+import type { ChainHub } from './chain-hub.js';
+import type { LocalChainAccount } from '@agoric/vats/src/localchain.js';
+import type { ChainAddress } from '@agoric/orchestration';
+import type { Vow } from '@agoric/vow';
+import type { TimestampRecord } from '@agoric/time';
+import type { TypedJson } from '@agoric/cosmic-proto';
+import type { JsonSafe } from '@agoric/cosmic-proto';
+import type { ChainInfo } from '@agoric/orchestration';
+import type { IBCConnectionInfo } from '@agoric/orchestration';
+import type { IBCMsgTransferOptions } from '@agoric/orchestration';
+import type { DenomAmount } from '@agoric/orchestration';
+import type { AmountArg } from '@agoric/orchestration';
+import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+//# sourceMappingURL=local-orchestration-account.d.ts.map

package/src/exos/local-orchestration-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-orchestration-account.d.ts","sourceRoot":"","sources":["local-orchestration-account.js"],"names":[],"mappings":"AAwEO,0DAPI,IAAI,mBACJ,eAAe,OACf,GAAG,gBACH,OAAO,YAAY,CAAC,6BACpB,QAAQ,YACR,QAAQ;aA2DJ,iBAAiB;aACjB,YAAY;iBACZ,OAAO,WAAW,CAAC;;;QAY1B;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;QAiBxB;;;;;;WAMG;8BALQ,CACV,SACA,UAAgB,+CAA+C,CAAC,CAC3D,CACF;;;QAaJ;;;WAGG;6DADQ,YAAY;;;QAUvB;;;;;;;;;;WAUG;6DATQ,CACV;YAAM,eAAe,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;SAAE,EAC7D,MAAU,CACP,iCACO;YACV,WAAe,EAAE,YAAY,CAAC;YAC9B,IAAQ,EAAE,qBAAqB,CAAC;YAChC,MAAU,EAAE,WAAW,CAAC;SACrB;;;;IA4BN;;;OAGG;;QAED;;WAEG;6BADQ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;;IAQvC;;;OAGG;;QAED;;WAEG;6BADQ,OAAO;;IAMpB;;;OAGG;;QAED;;;;WAIG;+BAHQ,MAAM,CAAC,KAAK,CAAC,SACb,WAAW,CAAC,OAAO,CAAC,GAClB,WAAW;;;QAOxB;;;;WAIG;;;;;;;;;;QA8BH;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;QAqBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,IAAI,IAAI,GAAG,eAAe,CAAC;QAoBxC;;;;WAIG;QACH,iEAAiE;;QAOjE,0DAA0D;;QAI1D,2DAA2D;;;;;;QAI3D,sDAAsD;;;QAWtD;;;;;;;;WAQG;yBAPQ,SAAS,eAET,YAAY,6CAIV,IAAI,IAAI,CAAC;QA8BtB,uEAAuE;;;GAW9E;;aApZa,MAAM;;oBAIP;IACZ,QAAY,EAAE,YAAY,6BAA6B,CAAC,CAAC;IACzD,OAAW,EAAE,iBAAiB,CAAC;IAC/B,OAAW,EAAE,YAAY,CAAC;CACvB;+CA6YU,UAAU,CAAC,OAAO,mCAAmC,CAAC;2CACtD,UAAU,CAAC,gCAAgC,CAAC;0BAranC,cAAc;qCADU,6CAA6C;kCAGhC,cAAc;4BADjD,kBAAkB;8BAEC,aAAa;8BAE9B,gBAAgB;uCARP,gCAAgC;kCAC4E,uBAAuB;yBAK3H,aAAa;qCADG,cAAc;+BAEpC,sBAAsB;8BAAtB,sBAAsB;+BANoF,uBAAuB;uCAAvB,uBAAuB;2CAAvB,uBAAuB;iCAAvB,uBAAuB;+BAAvB,uBAAuB;iCACxH,6CAA6C"}