@absol-labs/agent 0.11.0 → 0.12.0-rc.2

package/src/x402-opener/terms.ts

@@ -0,0 +1,453 @@
+import {
+  InvalidUpfrontTermsError,
+  validateUpfrontTerms,
+} from "@absol-labs/shared";
+import { getAddress, isAddress, isHex, type Address, type Hex } from "viem";
+
+/**
+ * Shared vocabulary of the x402 v2 escrow-opener path (metrik-agent#116).
+ *
+ * A standard x402 v2 `exact` payment (an EIP-3009 `transferWithAuthorization`)
+ * is settled through the ownerless `X402StreamOpenerFactory`
+ * (metrik-contracts#48): the x402 `payTo` is the CREATE2 address of the opener
+ * for one immutable set of stream {@link OpenerTerms}, so the payer's signature
+ * (which binds `to`) commits to those terms, and the opener turns the payment
+ * into an ordinary `StreamEscrowV2` stream with `deposit = amount`.
+ *
+ * This module has no network or package side effects: it is the pure,
+ * dependency-free part shared by the facilitator and the gateway.
+ */
+
+/** Scheme name. The standard x402 `exact` scheme, nothing Metrik-specific. */
+export const OPENER_SCHEME = "exact" as const;
+
+/*
+ * Network, USDC, escrow, factory and oracle defaults are NOT constants here:
+ * they come from the `@absol-labs/sdk` network registry (see `../network.ts`),
+ * so a new deployment is a registry change, never an edit to this module.
+ */
+
+/** Public docs for the x402 opener path, linked from the 402. */
+export const DEFAULT_OPENER_DOCS_URL =
+  "https://github.com/Absol-Labs/metrik-agent/blob/main/docs/x402.md";
+
+/** Longest informational link accepted in `extra.metrikStreamOpener`. */
+const MAX_LINK_LENGTH = 2048;
+
+/**
+ * Key under `PaymentRequirements.extra` that carries the opener terms. The
+ * facilitator reads the terms ONLY from here, recomputes the opener address
+ * on-chain and requires it to equal `payTo`, so a tampered value can never
+ * redirect funds: it just fails verification.
+ */
+export const OPENER_EXTRA_KEY = "metrikStreamOpener" as const;
+
+/** `uint64` ceiling for `maxDuration`. */
+const MAX_UINT64 = (1n << 64n) - 1n;
+
+/** Immutable per-listing stream terms, mirroring the Solidity `Terms` struct. */
+export interface OpenerTerms {
+  readonly operator: Address;
+  readonly serviceRef: Hex;
+  /** USDC base units per second. */
+  readonly ratePerSecond: bigint;
+  /** Seconds. */
+  readonly maxDuration: bigint;
+}
+
+/**
+ * Which opener contract a factory deploys: `"stream"` (`X402StreamOpener`,
+ * 4-field terms, the whole payment funds a stream) or `"upfront"`
+ * (`X402UpfrontStreamOpener`, 6-field terms: a fixed `price` whose
+ * non-refundable `upfrontAmount` is paid to the seller at settlement and whose
+ * remainder funds a stream). Decided by WHICH configured factory a quote names,
+ * never by the wire fields alone.
+ */
+export type OpenerKind = "stream" | "upfront";
+
+/** `termsVersion` of each opener kind's `extra.metrikStreamOpener` (as the SDK checks it). */
+export const OPENER_TERMS_VERSION = {
+  stream: "stream-1",
+  upfront: "upfront-1",
+} as const satisfies Record<OpenerKind, string>;
+
+/**
+ * The 6-field terms of an `X402UpfrontStreamOpener` (metrik-contracts#54),
+ * mirroring the Solidity struct. Every field is committed by the `payTo`.
+ */
+export interface UpfrontOpenerTerms extends OpenerTerms {
+  /** The exact x402 amount: the opener accepts this value and nothing else. */
+  readonly price: bigint;
+  /** NON-REFUNDABLE part paid to the seller (net of the protocol fee) at settlement. `<= price`. */
+  readonly upfrontAmount: bigint;
+}
+
+/** The refundable, metered part of an upfront opener's price (the stream deposit). */
+export function upfrontRefundable(terms: UpfrontOpenerTerms): bigint {
+  return terms.price - terms.upfrontAmount;
+}
+
+/** True when an upfront opener opens no stream at all (`upfrontAmount == price`). */
+export function isUpfrontOnly(terms: UpfrontOpenerTerms): boolean {
+  return terms.price > 0n && terms.upfrontAmount === terms.price;
+}
+
+/**
+ * The upfront terms a gateway may quote: exactly the factory's
+ * `validateTerms` (via `@absol-labs/shared`'s `validateUpfrontTerms`, so a
+ * `payTo` no transaction can deploy is never quoted), a fixed non-zero price,
+ * and a metered part (`price - upfrontAmount`) the stream can actually earn
+ * (`<= ratePerSecond * maxDuration`) — the SDK buyer refuses anything else.
+ */
+export function assertValidUpfrontTerms(terms: UpfrontOpenerTerms): void {
+  assertValidTerms(terms);
+  try {
+    validateUpfrontTerms({
+      operator: getAddress(terms.operator),
+      serviceRef: terms.serviceRef.toLowerCase() as Hex,
+      ratePerSecond: terms.ratePerSecond,
+      maxDuration: terms.maxDuration,
+      price: terms.price,
+      upfrontAmount: terms.upfrontAmount,
+    });
+  } catch (error) {
+    throw new InvalidOpenerTermsError(
+      error instanceof InvalidUpfrontTermsError || error instanceof Error
+        ? error.message
+        : String(error),
+    );
+  }
+  if (terms.price <= 0n) {
+    throw new InvalidOpenerTermsError(
+      "an upfront opener needs a fixed price > 0",
+    );
+  }
+  if (upfrontRefundable(terms) > maxEarnable(terms)) {
+    throw new InvalidOpenerTermsError(
+      `the metered part ${upfrontRefundable(terms)} (price - upfrontAmount) exceeds ratePerSecond * maxDuration (${maxEarnable(terms)})`,
+    );
+  }
+}
+
+/** Solidity-tuple view of 6-field upfront terms for viem contract calls. */
+export function upfrontTermsTuple(terms: UpfrontOpenerTerms): {
+  readonly operator: Address;
+  readonly serviceRef: Hex;
+  readonly ratePerSecond: bigint;
+  readonly maxDuration: bigint;
+  readonly price: bigint;
+  readonly upfrontAmount: bigint;
+} {
+  return {
+    ...termsTuple(terms),
+    price: terms.price,
+    upfrontAmount: terms.upfrontAmount,
+  };
+}
+
+/** JSON-safe projection of {@link OpenerTerms} plus the factory that prices them. */
+export interface OpenerTermsExtra {
+  readonly factory: Address;
+  readonly operator: Address;
+  readonly serviceRef: Hex;
+  readonly ratePerSecond: string;
+  readonly maxDuration: string;
+  /** Upfront openers only: the exact price (base units). */
+  readonly price?: string;
+  /** Upfront openers only: the non-refundable per-call part (base units). */
+  readonly upfrontAmount?: string;
+  /** `stream-1` / `upfront-1`; optional, must match the factory's kind when present. */
+  readonly termsVersion?: string;
+  /**
+   * Informational only (metrik-agent#119): where the payer gets unearned money
+   * back without ETH, as a template containing `{streamId}`. Never used for
+   * settlement; the facilitator validates it is an http(s) link and ignores it.
+   */
+  readonly refundUrl?: string;
+  /** Informational only: docs for this payment path. */
+  readonly docsUrl?: string;
+}
+
+/** True for an absolute http(s) URL of sane length. */
+export function isHttpLink(value: unknown): value is string {
+  if (typeof value !== "string" || value.length > MAX_LINK_LENGTH) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+
+export class InvalidOpenerTermsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidOpenerTermsError";
+  }
+}
+
+/** Parses a non-negative base-10 integer string. Throws on anything else. */
+export function parseUintString(value: unknown, field: string): bigint {
+  if (typeof value !== "string" || !/^(0|[1-9]\d*)$/.test(value)) {
+    throw new InvalidOpenerTermsError(
+      `${field} must be a base-10 integer string without sign or leading zeros`,
+    );
+  }
+  return BigInt(value);
+}
+
+/**
+ * Validates terms the way the factory's `deploy` does (non-zero operator, rate
+ * and duration, `maxDuration` within `uint64`) plus the shape checks the
+ * contract cannot do for us (32-byte serviceRef).
+ */
+export function assertValidTerms(terms: OpenerTerms): void {
+  if (!isAddress(terms.operator, { strict: false })) {
+    throw new InvalidOpenerTermsError("operator must be an EVM address");
+  }
+  if (/^0x0{40}$/i.test(terms.operator)) {
+    throw new InvalidOpenerTermsError("operator must not be the zero address");
+  }
+  if (
+    !isHex(terms.serviceRef, { strict: true }) ||
+    terms.serviceRef.length !== 66
+  ) {
+    throw new InvalidOpenerTermsError("serviceRef must be a 32-byte hex value");
+  }
+  if (terms.ratePerSecond <= 0n) {
+    throw new InvalidOpenerTermsError("ratePerSecond must be > 0");
+  }
+  if (terms.maxDuration <= 0n || terms.maxDuration > MAX_UINT64) {
+    throw new InvalidOpenerTermsError(
+      "maxDuration must be > 0 and fit in uint64",
+    );
+  }
+}
+
+/** The largest deposit a stream on these terms can ever earn out: `rate * maxDuration`. */
+export function maxEarnable(terms: OpenerTerms): bigint {
+  return terms.ratePerSecond * terms.maxDuration;
+}
+
+/**
+ * The price (= stream deposit) must be positive and must not exceed what the
+ * stream can ever accrue. A deposit above `rate * maxDuration` would lock money
+ * the seller can never earn, reclaimable only by a second buyer action.
+ */
+export function assertValidPrice(price: bigint, terms: OpenerTerms): void {
+  if (price <= 0n) {
+    throw new InvalidOpenerTermsError("price must be > 0");
+  }
+  if (price > maxEarnable(terms)) {
+    throw new InvalidOpenerTermsError(
+      `price ${price} exceeds ratePerSecond * maxDuration (${maxEarnable(terms)})`,
+    );
+  }
+}
+
+export function termsToExtra(
+  factory: Address,
+  terms: OpenerTerms,
+): OpenerTermsExtra {
+  return {
+    factory: getAddress(factory),
+    operator: getAddress(terms.operator),
+    serviceRef: terms.serviceRef.toLowerCase() as Hex,
+    ratePerSecond: terms.ratePerSecond.toString(),
+    maxDuration: terms.maxDuration.toString(),
+  };
+}
+
+/** The 402 `extra.metrikStreamOpener` terms of an upfront opener quote. */
+export function upfrontTermsToExtra(
+  factory: Address,
+  terms: UpfrontOpenerTerms,
+): OpenerTermsExtra {
+  return {
+    factory: getAddress(factory),
+    termsVersion: OPENER_TERMS_VERSION.upfront,
+    operator: getAddress(terms.operator),
+    serviceRef: terms.serviceRef.toLowerCase() as Hex,
+    ratePerSecond: terms.ratePerSecond.toString(),
+    maxDuration: terms.maxDuration.toString(),
+    price: terms.price.toString(),
+    upfrontAmount: terms.upfrontAmount.toString(),
+  };
+}
+
+/**
+ * Reads opener terms from an untrusted `PaymentRequirements.extra`. Every field
+ * is re-validated; unknown keys under the opener object are rejected so the
+ * wire shape cannot drift silently. `price` / `upfrontAmount` are returned as
+ * `upfront` when present (both or neither); whether they are REQUIRED or
+ * FORBIDDEN depends on the factory's kind, which only the caller knows.
+ */
+export function termsFromExtra(extra: unknown): {
+  readonly factory: Address;
+  readonly terms: OpenerTerms;
+  readonly upfront?: {
+    readonly price: bigint;
+    readonly upfrontAmount: bigint;
+  };
+  readonly termsVersion?: string;
+} {
+  if (typeof extra !== "object" || extra === null) {
+    throw new InvalidOpenerTermsError("requirements.extra is missing");
+  }
+  const raw = (extra as Record<string, unknown>)[OPENER_EXTRA_KEY];
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new InvalidOpenerTermsError(
+      `requirements.extra.${OPENER_EXTRA_KEY} is missing`,
+    );
+  }
+  const record = raw as Record<string, unknown>;
+  const allowed = new Set([
+    "factory",
+    "operator",
+    "serviceRef",
+    "ratePerSecond",
+    "maxDuration",
+    "price",
+    "upfrontAmount",
+    "termsVersion",
+    "refundUrl",
+    "docsUrl",
+  ]);
+  for (const key of Object.keys(record)) {
+    if (!allowed.has(key)) {
+      throw new InvalidOpenerTermsError(
+        `unknown key ${key} in requirements.extra.${OPENER_EXTRA_KEY}`,
+      );
+    }
+  }
+  for (const link of ["refundUrl", "docsUrl"] as const) {
+    if (record[link] !== undefined && !isHttpLink(record[link])) {
+      throw new InvalidOpenerTermsError(
+        `${link} in requirements.extra.${OPENER_EXTRA_KEY} must be an http(s) URL`,
+      );
+    }
+  }
+  const { factory, operator, serviceRef } = record;
+  if (typeof factory !== "string" || !isAddress(factory, { strict: false })) {
+    throw new InvalidOpenerTermsError("factory must be an EVM address");
+  }
+  if (typeof operator !== "string" || !isAddress(operator, { strict: false })) {
+    throw new InvalidOpenerTermsError("operator must be an EVM address");
+  }
+  if (typeof serviceRef !== "string") {
+    throw new InvalidOpenerTermsError("serviceRef must be a string");
+  }
+  const terms: OpenerTerms = {
+    operator: getAddress(operator),
+    serviceRef: serviceRef as Hex,
+    ratePerSecond: parseUintString(record.ratePerSecond, "ratePerSecond"),
+    maxDuration: parseUintString(record.maxDuration, "maxDuration"),
+  };
+  assertValidTerms(terms);
+  const termsVersion = record.termsVersion;
+  if (
+    termsVersion !== undefined &&
+    (typeof termsVersion !== "string" || termsVersion.length > 64)
+  ) {
+    throw new InvalidOpenerTermsError("termsVersion must be a short string");
+  }
+  if ((record.price === undefined) !== (record.upfrontAmount === undefined)) {
+    throw new InvalidOpenerTermsError(
+      "price and upfrontAmount must be given together (an upfront opener's terms) or not at all",
+    );
+  }
+  const upfront =
+    record.price === undefined
+      ? undefined
+      : {
+          price: parseUintString(record.price, "price"),
+          upfrontAmount: parseUintString(record.upfrontAmount, "upfrontAmount"),
+        };
+  return {
+    factory: getAddress(factory),
+    terms,
+    ...(upfront === undefined ? {} : { upfront }),
+    ...(termsVersion === undefined
+      ? {}
+      : { termsVersion: termsVersion as string }),
+  };
+}
+
+/** Chain id encoded in an `eip155:<id>` CAIP-2 identifier. Throws otherwise. */
+export function chainIdFromNetwork(network: string): number {
+  const match = /^eip155:([1-9]\d*)$/.exec(network);
+  if (match === null) {
+    throw new InvalidOpenerTermsError(
+      `network must be an eip155 CAIP-2 identifier, got ${network}`,
+    );
+  }
+  const chainId = Number(match[1]);
+  if (!Number.isSafeInteger(chainId)) {
+    throw new InvalidOpenerTermsError(`unsupported chain id in ${network}`);
+  }
+  return chainId;
+}
+
+/** Solidity-tuple view of terms for viem contract calls. */
+export function termsTuple(terms: OpenerTerms): {
+  readonly operator: Address;
+  readonly serviceRef: Hex;
+  readonly ratePerSecond: bigint;
+  readonly maxDuration: bigint;
+} {
+  return {
+    operator: getAddress(terms.operator),
+    serviceRef: terms.serviceRef,
+    ratePerSecond: terms.ratePerSecond,
+    maxDuration: terms.maxDuration,
+  };
+}
+
+/** A bazaar-shaped `{info: {input, output?}, schema?}` declaration. */
+export interface X402SchemaDeclaration {
+  readonly info: {
+    readonly input: { readonly type: "http" } & Record<string, unknown>;
+    readonly output?: Record<string, unknown>;
+  };
+  readonly schema?: Record<string, unknown>;
+}
+
+/** Largest accepted schema declaration, serialized bytes. */
+export const MAX_SCHEMA_DECLARATION_BYTES = 16 * 1024;
+
+/** Validates a bazaar-shaped schema declaration. Throws on anything else. */
+export function assertSchemaDeclaration(
+  value: unknown,
+): asserts value is X402SchemaDeclaration {
+  if (JSON.stringify(value ?? null).length > MAX_SCHEMA_DECLARATION_BYTES) {
+    throw new Error(
+      `the schema declaration exceeds ${MAX_SCHEMA_DECLARATION_BYTES} bytes`,
+    );
+  }
+  const record = value as Record<string, unknown> | null;
+  const info = record?.info as Record<string, unknown> | undefined;
+  const input = info?.input as Record<string, unknown> | undefined;
+  if (
+    typeof record !== "object" ||
+    record === null ||
+    Array.isArray(record) ||
+    typeof info !== "object" ||
+    info === null ||
+    typeof input !== "object" ||
+    input === null ||
+    input.type !== "http" ||
+    (info.output !== undefined &&
+      (typeof info.output !== "object" || info.output === null)) ||
+    (record.schema !== undefined &&
+      (typeof record.schema !== "object" || record.schema === null))
+  ) {
+    throw new Error(
+      'the schema declaration must be {info: {input: {type: "http", ...}, output?}, schema?}',
+    );
+  }
+  for (const key of Object.keys(record)) {
+    if (key !== "info" && key !== "schema") {
+      throw new Error(`unknown key ${key} in the schema declaration`);
+    }
+  }
+}

package/dist/gateway/x402-mode.d.ts

@@ -1,123 +0,0 @@
-import type { PaymentRequirements, SettleResponse, VerifyResponse } from "x402/types";
-import { type SignedListingPayee, type X402AssetConfig, type X402PaymentRequiredBody } from "../x402/payment-requirements.js";
-/**
- * Standard x402 mode for the seller-side gateway (Tier 1).
- *
- * The gateway already authorizes requests that carry a Metrik
- * `InvocationCapability` — a buyer with an open, funded, verified stream. That
- * path is untouched. This module adds a SECOND, independent way in: a request
- * with no capability gets an ordinary HTTP `402` carrying real x402
- * `PaymentRequirements`, so an agent holding nothing but `x402-fetch` can pay
- * per call without knowing Metrik exists.
- *
- * ## The two paths never overlap
- *
- * - capability header present -> stream path, exactly as before;
- * - capability header absent, x402 mode on -> `402` + `PaymentRequirements`;
- * - BOTH present -> rejected. A request that looks like both is ambiguous about
- *   which one is paying for it, and the failure mode of guessing is charging the
- *   caller twice for one call. Better a loud `400` than a silent double charge.
- *
- * ## The per-call price is the seller's, and is not signed
- *
- * `payTo` comes from the operator-signed descriptor (see
- * `../x402/payment-requirements.ts`). The price does not — the descriptor has no
- * per-call price field. It is the seller's own number on the seller's own
- * gateway, which is legitimate, but a buyer cannot cross-check it against the
- * registry the way they can cross-check the payee.
- */
-/** Request header carrying the x402 payment payload (x402 v1). */
-export declare const X402_PAYMENT_HEADER: "x-payment";
-/** Response header carrying the settlement result (x402 v1). */
-export declare const X402_PAYMENT_RESPONSE_HEADER: "x-payment-response";
-/** The facilitator the gateway delegates verify/settle to. */
-export interface X402FacilitatorClient {
-    verify(payload: unknown, requirements: PaymentRequirements): Promise<VerifyResponse>;
-    settle(payload: unknown, requirements: PaymentRequirements): Promise<SettleResponse>;
-}
-export interface HttpFacilitatorClientOptions {
-    /** Base URL of a facilitator exposing `/verify` and `/settle`. */
-    readonly url: string;
-    /**
-     * Shared secret for the facilitator's `/settle`. Sent as
-     * `Authorization: Bearer`. Metrik's own facilitator refuses to start a
-     * settling deployment without one, because `/settle` spends its gas.
-     */
-    readonly token?: string;
-    readonly headers?: Readonly<Record<string, string>>;
-    readonly timeoutMs?: number;
-    readonly fetch?: typeof globalThis.fetch;
-}
-/**
- * Talks to any x402 facilitator over HTTP — including Metrik's own
- * (`../x402/facilitator-server.ts`), which is the point: a seller who wires this
- * gateway to the Metrik facilitator gets a paywall whose payments stop when
- * their own delivery stops being verifiable.
- */
-export declare function createHttpFacilitatorClient(options: HttpFacilitatorClientOptions): X402FacilitatorClient;
-/** Builds the `PaymentRequirements` quoted for a given request. */
-export type X402Quoter = (request: {
-    readonly method: string;
-    readonly path: string;
-}) => readonly PaymentRequirements[] | Promise<readonly PaymentRequirements[]>;
-export interface ListingPriceQuoterOptions {
-    /** Projected from the OPERATOR-SIGNED descriptor. `payTo` comes from here. */
-    readonly listing: SignedListingPayee;
-    /** Public origin buyers reach this gateway on, e.g. `https://svc.example.com`. */
-    readonly resourceBaseUrl: string;
-    /** Per-call price in the asset's base units (micro-USDC). Seller-set, unsigned. */
-    readonly pricePerCallBaseUnits: bigint;
-    readonly chainId: number;
-    readonly description?: string;
-    readonly mimeType?: string;
-    readonly maxTimeoutSeconds?: number;
-    readonly asset?: X402AssetConfig;
-}
-/** One flat price per call, quoted against the request's own path. */
-export declare function createListingPriceQuoter(options: ListingPriceQuoterOptions): X402Quoter;
-export interface GatewayX402Mode {
-    readonly quote: X402Quoter;
-    readonly facilitator: X402FacilitatorClient;
-}
-/** Decoded, still-untrusted `X-PAYMENT` payload plus the quote it answers. */
-export interface AcceptedX402Payment {
-    readonly payload: unknown;
-    readonly requirements: PaymentRequirements;
-    readonly payer?: string;
-    /**
-     * Unix seconds after which the signed authorization is no longer settleable
-     * (`validBefore`), when the payload carried one.
-     *
-     * The upstream runs BEFORE settlement, so an upstream slower than this window
-     * would produce its side effects and then fail to be paid for. The server
-     * bounds the upstream call by this instead of letting that happen.
-     */
-    readonly validBefore?: number;
-}
-export type X402EvaluationOutcome = {
-    readonly outcome: "payment-required";
-    readonly body: X402PaymentRequiredBody;
-} | {
-    readonly outcome: "accepted";
-    readonly payment: AcceptedX402Payment;
-};
-/**
- * Evaluates the x402 half of a request. Returns either the `402` body to send or
- * an accepted payment to settle after the upstream has been called.
- */
-export declare function evaluateX402Request(request: {
-    readonly method: string;
-    readonly path: string;
-}, paymentHeader: string | undefined, mode: GatewayX402Mode): Promise<X402EvaluationOutcome>;
-/**
- * Seconds of headroom the settlement leg needs after the upstream returns.
- *
- * The x402 `exact` verifier rejects an authorization whose `validBefore` is less
- * than 6 s away, so an upstream allowed to run right up to the deadline would
- * hand back a response that can never be settled. This leaves room for that
- * check plus the settle round trip.
- */
-export declare const X402_SETTLEMENT_HEADROOM_SECONDS = 10;
-export declare function decodePaymentHeader(header: string): unknown;
-export declare function encodeSettleResponseHeader(response: SettleResponse): string;
-//# sourceMappingURL=x402-mode.d.ts.map

package/dist/gateway/x402-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"x402-mode.d.ts","sourceRoot":"","sources":["../../src/gateway/x402-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,kEAAkE;AAClE,eAAO,MAAM,mBAAmB,EAAG,WAAoB,CAAC;AAExD,gEAAgE;AAChE,eAAO,MAAM,4BAA4B,EAAG,oBAA6B,CAAC;AAE1E,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,MAAM,CACJ,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,mBAAmB,GAChC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3B,MAAM,CACJ,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,mBAAmB,GAChC,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,4BAA4B;IAC3C,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,4BAA4B,GACpC,qBAAqB,CAgDvB;AAED,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,KAAK,SAAS,mBAAmB,EAAE,GAAG,OAAO,CAAC,SAAS,mBAAmB,EAAE,CAAC,CAAC;AAE/E,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,kFAAkF;IAClF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,mFAAmF;IACnF,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,sEAAsE;AACtE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,yBAAyB,GACjC,UAAU,CAkBZ;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC;CAC7C;AAED,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,MAAM,qBAAqB,GAC7B;IACE,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;CACxC,GACD;IAAE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAE5E;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAC3D,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,qBAAqB,CAAC,CAqFhC;AAeD;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAmBnD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQ3D;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAE3E"}