@bitgo-beta/sdk-coin-tempo 1.0.1-beta.31 → 1.0.1-beta.310

package/dist/src/lib/transaction.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * TIP-20 Transaction
+ *
+ * Represents a Tempo Account Abstraction (AA) transaction (type 0x76)
+ * Supports single or batch TIP-20 token transfers with memos
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20Transaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+class Tip20Transaction extends sdk_core_1.BaseTransaction {
+    constructor(_coinConfig, request, operations = [], rawCalls = []) {
+        super(_coinConfig);
+        this.txRequest = request;
+        this._operations = operations;
+        this._rawCalls = rawCalls;
+        this._outputs = [
+            ...operations.map((op) => ({
+                address: op.to,
+                value: (0, utils_1.amountToTip20Units)(op.amount).toString(),
+                coin: op.token,
+            })),
+            ...rawCalls.map((call) => ({
+                address: call.to,
+                value: call.value || '0',
+                coin: _coinConfig.name,
+            })),
+        ];
+        const totalUnits = operations.reduce((sum, op) => sum + (0, utils_1.amountToTip20Units)(op.amount), 0n);
+        this._inputs = [{ address: '', value: totalUnits.toString(), coin: _coinConfig.name }];
+    }
+    get type() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    canSign() {
+        return true;
+    }
+    async serialize(signature) {
+        const sig = signature || this._signature;
+        return this.serializeTransaction(sig);
+    }
+    /**
+     * Encode calls as RLP tuples for atomic batch execution
+     * @returns Array of [to, value, data] tuples
+     * @private
+     */
+    encodeCallsAsTuples() {
+        return this.txRequest.calls.map((call) => [call.to, this.bigintToHex(call.value), call.data]);
+    }
+    /**
+     * Encode EIP-2930 access list as RLP tuples
+     * @returns Array of [address, storageKeys[]] tuples
+     * @private
+     */
+    encodeAccessList() {
+        return (this.txRequest.accessList ?? []).map((item) => [item.address, item.storageKeys || []]);
+    }
+    /**
+     * Convert bigint to hex string for RLP encoding
+     * @param value bigint value to convert
+     * @returns Hex string
+     * @private
+     */
+    bigintToHex(value) {
+        if (value === 0n) {
+            return '0x';
+        }
+        const hex = value.toString(16);
+        return '0x' + (hex.length % 2 ? '0' : '') + hex;
+    }
+    /**
+     * Build base RLP data array per Tempo EIP-7702 specification
+     * @param callsTuples Encoded calls
+     * @param accessTuples Encoded access list
+     * @returns RLP-ready array of transaction fields
+     * @private
+     */
+    buildBaseRlpData(callsTuples, accessTuples) {
+        return [
+            ethers_1.ethers.utils.hexlify(this.txRequest.chainId),
+            this.txRequest.maxPriorityFeePerGas ? this.bigintToHex(this.txRequest.maxPriorityFeePerGas) : '0x',
+            this.bigintToHex(this.txRequest.maxFeePerGas),
+            this.bigintToHex(this.txRequest.gas),
+            callsTuples,
+            accessTuples,
+            '0x', // nonceKey (reserved for 2D nonce system)
+            this.txRequest.nonce ? this.bigintToHex(BigInt(this.txRequest.nonce)) : '0x',
+            '0x', // validBefore (reserved for time bounds)
+            '0x', // validAfter (reserved for time bounds)
+            this.txRequest.feeToken || '0x',
+            '0x', // feePayerSignature (reserved for sponsorship)
+            [], // authorizationList (EIP-7702)
+        ];
+    }
+    /**
+     * Encode secp256k1 signature as 65-byte envelope
+     * @param signature ECDSA signature components
+     * @returns Hex string of concatenated r (32) + s (32) + v (1) bytes
+     * @private
+     */
+    encodeSignature(signature) {
+        const v = signature.yParity + 27;
+        const signatureBytes = ethers_1.ethers.utils.concat([
+            ethers_1.ethers.utils.zeroPad(signature.r, 32),
+            ethers_1.ethers.utils.zeroPad(signature.s, 32),
+            ethers_1.ethers.utils.hexlify(v),
+        ]);
+        return ethers_1.ethers.utils.hexlify(signatureBytes);
+    }
+    /**
+     * RLP encode and prepend transaction type byte
+     * @param rlpData Transaction fields array
+     * @returns Hex string with 0x76 prefix
+     * @private
+     */
+    rlpEncodeWithTypePrefix(rlpData) {
+        try {
+            const encoded = ethers_1.ethers.utils.RLP.encode(rlpData);
+            return ('0x76' + encoded.slice(2));
+        }
+        catch (error) {
+            throw new sdk_core_1.ParseTransactionError(`Failed to RLP encode transaction: ${error}`);
+        }
+    }
+    /**
+     * Serialize Tempo AA transaction (type 0x76) per EIP-7702 specification
+     * Format: 0x76 || RLP([chainId, fees, gas, calls, accessList, nonce fields, feeToken, sponsorship, authList, signature?])
+     * @param signature Optional ECDSA signature (omit for unsigned transactions)
+     * @returns RLP-encoded transaction hex string
+     * @private
+     */
+    serializeTransaction(signature) {
+        const callsTuples = this.encodeCallsAsTuples();
+        const accessTuples = this.encodeAccessList();
+        const rlpData = this.buildBaseRlpData(callsTuples, accessTuples);
+        if (signature) {
+            rlpData.push(this.encodeSignature(signature));
+        }
+        return this.rlpEncodeWithTypePrefix(rlpData);
+    }
+    getOperations() {
+        return [...this._operations];
+    }
+    getRawCalls() {
+        return [...this._rawCalls];
+    }
+    getFeeToken() {
+        return this.txRequest.feeToken;
+    }
+    getOperationCount() {
+        return this._operations.length + this._rawCalls.length;
+    }
+    isBatch() {
+        return this.txRequest.calls.length > 1;
+    }
+    setSignature(signature) {
+        this._signature = signature;
+    }
+    getSignature() {
+        return this._signature;
+    }
+    /**
+     * Recover the signer address from the transaction signature.
+     * @returns Checksummed sender address, or undefined if unsigned
+     */
+    getSenderAddress() {
+        if (!this._signature) {
+            return undefined;
+        }
+        const unsignedHex = this.serializeTransaction();
+        const msgHash = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(unsignedHex));
+        return ethers_1.ethers.utils.recoverAddress(msgHash, {
+            r: this._signature.r,
+            s: this._signature.s,
+            recoveryParam: this._signature.yParity,
+        });
+    }
+    toJson() {
+        return {
+            type: this.txRequest.type,
+            chainId: this.txRequest.chainId,
+            nonce: this.txRequest.nonce,
+            maxFeePerGas: this.txRequest.maxFeePerGas.toString(),
+            maxPriorityFeePerGas: this.txRequest.maxPriorityFeePerGas.toString(),
+            gas: this.txRequest.gas.toString(),
+            callCount: this.txRequest.calls.length,
+            feeToken: this.txRequest.feeToken,
+            operations: this._operations,
+            rawCalls: this._rawCalls,
+            signature: this._signature,
+        };
+    }
+    async toBroadcastFormat() {
+        return await this.serialize(this._signature);
+    }
+    /** @inheritdoc */
+    get id() {
+        try {
+            const serialized = this.serializeTransaction(this._signature);
+            return ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(serialized));
+        }
+        catch {
+            return 'pending';
+        }
+    }
+    toString() {
+        return JSON.stringify(this.toJson(), null, 2);
+    }
+    canBroadcast() {
+        return this.txRequest.calls.length > 0 && this.txRequest.chainId > 0;
+    }
+}
+exports.Tip20Transaction = Tip20Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TIP-20 Transaction\n *\n * Represents a Tempo Account Abstraction (AA) transaction (type 0x76)\n * Supports single or batch TIP-20 token transfers with memos\n */\n\nimport { BaseTransaction, ParseTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { ethers } from 'ethers';\nimport { Address, Hex, RawContractCall, Tip20Operation } from './types';\nimport { amountToTip20Units } from './utils';\n\n/**\n * TIP-20 Transaction Request Structure\n * Represents the raw transaction data for Tempo Account Abstraction (EIP-7702)\n */\nexport interface Tip20TransactionRequest {\n  /** Transaction type (0x76 for Tempo AA) */\n  type: number | string;\n  /** Chain ID for the Tempo network */\n  chainId: number;\n  /** Transaction nonce */\n  nonce: number;\n  /** Maximum fee per gas (EIP-1559) */\n  maxFeePerGas: bigint;\n  /** Maximum priority fee per gas (EIP-1559) */\n  maxPriorityFeePerGas: bigint;\n  /** Gas limit for the transaction */\n  gas: bigint;\n  /** Array of calls to execute in this transaction */\n  calls: { to: Address; data: Hex; value: bigint }[];\n  /** Access list (optional, typically empty for TIP-20) */\n  accessList?: unknown[];\n  /** Optional TIP-20 token to use for paying fees */\n  feeToken?: Address;\n}\n\nexport interface TxData {\n  type: number | string;\n  chainId: number;\n  nonce: number;\n  maxFeePerGas: string;\n  maxPriorityFeePerGas: string;\n  gas: string;\n  callCount: number;\n  feeToken?: string;\n  operations: Tip20Operation[];\n  rawCalls: RawContractCall[];\n  signature?: { r: Hex; s: Hex; yParity: number };\n}\n\nexport class Tip20Transaction extends BaseTransaction {\n  private txRequest: Tip20TransactionRequest;\n  private _operations: Tip20Operation[];\n  private _rawCalls: RawContractCall[];\n  private _signature?: { r: Hex; s: Hex; yParity: number };\n\n  constructor(\n    _coinConfig: Readonly<CoinConfig>,\n    request: Tip20TransactionRequest,\n    operations: Tip20Operation[] = [],\n    rawCalls: RawContractCall[] = []\n  ) {\n    super(_coinConfig);\n    this.txRequest = request;\n    this._operations = operations;\n    this._rawCalls = rawCalls;\n    this._outputs = [\n      ...operations.map((op) => ({\n        address: op.to,\n        value: amountToTip20Units(op.amount).toString(),\n        coin: op.token,\n      })),\n      ...rawCalls.map((call) => ({\n        address: call.to,\n        value: call.value || '0',\n        coin: _coinConfig.name,\n      })),\n    ];\n    const totalUnits = operations.reduce((sum, op) => sum + amountToTip20Units(op.amount), 0n);\n    this._inputs = [{ address: '', value: totalUnits.toString(), coin: _coinConfig.name }];\n  }\n\n  get type(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  canSign(): boolean {\n    return true;\n  }\n\n  async serialize(signature?: { r: Hex; s: Hex; yParity: number }): Promise<Hex> {\n    const sig = signature || this._signature;\n    return this.serializeTransaction(sig);\n  }\n\n  /**\n   * Encode calls as RLP tuples for atomic batch execution\n   * @returns Array of [to, value, data] tuples\n   * @private\n   */\n  private encodeCallsAsTuples(): any[] {\n    return this.txRequest.calls.map((call) => [call.to, this.bigintToHex(call.value), call.data]);\n  }\n\n  /**\n   * Encode EIP-2930 access list as RLP tuples\n   * @returns Array of [address, storageKeys[]] tuples\n   * @private\n   */\n  private encodeAccessList(): any[] {\n    return (this.txRequest.accessList ?? []).map((item: any) => [item.address, item.storageKeys || []]);\n  }\n\n  /**\n   * Convert bigint to hex string for RLP encoding\n   * @param value bigint value to convert\n   * @returns Hex string\n   * @private\n   */\n  private bigintToHex(value: bigint): string {\n    if (value === 0n) {\n      return '0x';\n    }\n    const hex = value.toString(16);\n    return '0x' + (hex.length % 2 ? '0' : '') + hex;\n  }\n\n  /**\n   * Build base RLP data array per Tempo EIP-7702 specification\n   * @param callsTuples Encoded calls\n   * @param accessTuples Encoded access list\n   * @returns RLP-ready array of transaction fields\n   * @private\n   */\n  private buildBaseRlpData(callsTuples: any[], accessTuples: any[]): any[] {\n    return [\n      ethers.utils.hexlify(this.txRequest.chainId),\n      this.txRequest.maxPriorityFeePerGas ? this.bigintToHex(this.txRequest.maxPriorityFeePerGas) : '0x',\n      this.bigintToHex(this.txRequest.maxFeePerGas),\n      this.bigintToHex(this.txRequest.gas),\n      callsTuples,\n      accessTuples,\n      '0x', // nonceKey (reserved for 2D nonce system)\n      this.txRequest.nonce ? this.bigintToHex(BigInt(this.txRequest.nonce)) : '0x',\n      '0x', // validBefore (reserved for time bounds)\n      '0x', // validAfter (reserved for time bounds)\n      this.txRequest.feeToken || '0x',\n      '0x', // feePayerSignature (reserved for sponsorship)\n      [], // authorizationList (EIP-7702)\n    ];\n  }\n\n  /**\n   * Encode secp256k1 signature as 65-byte envelope\n   * @param signature ECDSA signature components\n   * @returns Hex string of concatenated r (32) + s (32) + v (1) bytes\n   * @private\n   */\n  private encodeSignature(signature: { r: Hex; s: Hex; yParity: number }): string {\n    const v = signature.yParity + 27;\n    const signatureBytes = ethers.utils.concat([\n      ethers.utils.zeroPad(signature.r, 32),\n      ethers.utils.zeroPad(signature.s, 32),\n      ethers.utils.hexlify(v),\n    ]);\n    return ethers.utils.hexlify(signatureBytes);\n  }\n\n  /**\n   * RLP encode and prepend transaction type byte\n   * @param rlpData Transaction fields array\n   * @returns Hex string with 0x76 prefix\n   * @private\n   */\n  private rlpEncodeWithTypePrefix(rlpData: any[]): Hex {\n    try {\n      const encoded = ethers.utils.RLP.encode(rlpData);\n      return ('0x76' + encoded.slice(2)) as Hex;\n    } catch (error) {\n      throw new ParseTransactionError(`Failed to RLP encode transaction: ${error}`);\n    }\n  }\n\n  /**\n   * Serialize Tempo AA transaction (type 0x76) per EIP-7702 specification\n   * Format: 0x76 || RLP([chainId, fees, gas, calls, accessList, nonce fields, feeToken, sponsorship, authList, signature?])\n   * @param signature Optional ECDSA signature (omit for unsigned transactions)\n   * @returns RLP-encoded transaction hex string\n   * @private\n   */\n  private serializeTransaction(signature?: { r: Hex; s: Hex; yParity: number }): Hex {\n    const callsTuples = this.encodeCallsAsTuples();\n    const accessTuples = this.encodeAccessList();\n    const rlpData = this.buildBaseRlpData(callsTuples, accessTuples);\n\n    if (signature) {\n      rlpData.push(this.encodeSignature(signature));\n    }\n\n    return this.rlpEncodeWithTypePrefix(rlpData);\n  }\n\n  getOperations(): Tip20Operation[] {\n    return [...this._operations];\n  }\n\n  getRawCalls(): RawContractCall[] {\n    return [...this._rawCalls];\n  }\n\n  getFeeToken(): Address | undefined {\n    return this.txRequest.feeToken;\n  }\n\n  getOperationCount(): number {\n    return this._operations.length + this._rawCalls.length;\n  }\n\n  isBatch(): boolean {\n    return this.txRequest.calls.length > 1;\n  }\n\n  setSignature(signature: { r: Hex; s: Hex; yParity: number }): void {\n    this._signature = signature;\n  }\n\n  getSignature(): { r: Hex; s: Hex; yParity: number } | undefined {\n    return this._signature;\n  }\n\n  /**\n   * Recover the signer address from the transaction signature.\n   * @returns Checksummed sender address, or undefined if unsigned\n   */\n  getSenderAddress(): string | undefined {\n    if (!this._signature) {\n      return undefined;\n    }\n\n    const unsignedHex = this.serializeTransaction();\n    const msgHash = ethers.utils.keccak256(ethers.utils.arrayify(unsignedHex));\n    return ethers.utils.recoverAddress(msgHash, {\n      r: this._signature.r,\n      s: this._signature.s,\n      recoveryParam: this._signature.yParity,\n    });\n  }\n\n  toJson(): TxData {\n    return {\n      type: this.txRequest.type,\n      chainId: this.txRequest.chainId,\n      nonce: this.txRequest.nonce,\n      maxFeePerGas: this.txRequest.maxFeePerGas.toString(),\n      maxPriorityFeePerGas: this.txRequest.maxPriorityFeePerGas.toString(),\n      gas: this.txRequest.gas.toString(),\n      callCount: this.txRequest.calls.length,\n      feeToken: this.txRequest.feeToken,\n      operations: this._operations,\n      rawCalls: this._rawCalls,\n      signature: this._signature,\n    };\n  }\n\n  async toBroadcastFormat(): Promise<string> {\n    return await this.serialize(this._signature);\n  }\n\n  /** @inheritdoc */\n  get id(): string {\n    try {\n      const serialized = this.serializeTransaction(this._signature);\n      return ethers.utils.keccak256(ethers.utils.arrayify(serialized));\n    } catch {\n      return 'pending';\n    }\n  }\n\n  toString(): string {\n    return JSON.stringify(this.toJson(), null, 2);\n  }\n\n  canBroadcast(): boolean {\n    return this.txRequest.calls.length > 0 && this.txRequest.chainId > 0;\n  }\n}\n"]}

package/dist/src/lib/transactionBuilder.d.ts

@@ -0,0 +1,139 @@
+/**
+ * TIP-20 Transaction Builder
+ *
+ * Unified builder for TIP-20 transactions supporting:
+ * - Single or batch operations
+ * - Per-operation memos for tracking
+ * - Custom fee token selection
+ * - EIP-7702 Account Abstraction (type 0x76)
+ */
+import { Transaction as EthTransaction, TransactionBuilder as AbstractTransactionBuilder, TransferBuilder } from '@bitgo-beta/abstract-eth';
+import { BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Address, RawContractCall, Tip20Operation } from './types';
+/**
+ * Transaction Builder for TIP-20 tokens on Tempo blockchain
+ * Extends abstract-eth TransactionBuilder with Tempo-specific features
+ */
+export declare class Tip20TransactionBuilder extends AbstractTransactionBuilder {
+    private operations;
+    private rawCalls;
+    private _feeToken?;
+    private _nonce?;
+    private _gas?;
+    private _maxFeePerGas?;
+    private _maxPriorityFeePerGas?;
+    private _restoredSignature?;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Implement the transfer method from abstract class
+     * Note: For TIP-20 transactions, use addOperation() instead
+     */
+    transfer(data?: string, isFirstSigner?: boolean): TransferBuilder;
+    /**
+     * Validate the transaction has all required fields for Tempo AA transactions.
+     * Overrides parent class validation since AA transactions use a different model
+     * (operations-based rather than single contract address).
+     *
+     * @throws BuildTransactionError if validation fails
+     */
+    validateTransaction(): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: any): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string, isFirstSigner?: boolean): EthTransaction;
+    /**
+     * Deserialize a type 0x76 transaction and restore builder state.
+     * RLP field layout mirrors buildBaseRlpData() in transaction.ts.
+     */
+    private fromTip20Transaction;
+    /**
+     * Decode a single AA call's data back into a Tip20Operation.
+     * Returns null if the call is not a transferWithMemo — it will be stored as a RawContractCall instead.
+     * This preserves calldata fidelity for arbitrary smart contract interactions.
+     */
+    private decodeCallToOperation;
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters.
+     * Signs with _sourceKeyPair if it has been set via sign({ key }).
+     */
+    protected buildImplementation(): Promise<BaseTransaction>;
+    /**
+     * Add a single operation to the transaction
+     * Can be called multiple times to create batch transactions
+     *
+     * @param operation - TIP-20 operation with token, recipient, amount, and optional memo
+     * @returns this builder instance for chaining
+     */
+    addOperation(operation: Tip20Operation): this;
+    /**
+     * Add a raw smart contract call with pre-encoded calldata
+     * Use this for arbitrary contract interactions where the UI provides ABI-encoded calldata
+     *
+     * @param call - Raw contract call with target address and pre-encoded calldata
+     * @returns this builder instance for chaining
+     */
+    addRawCall(call: RawContractCall): this;
+    /**
+     * Get all raw contract calls in this transaction
+     * @returns Array of raw contract calls
+     */
+    getRawCalls(): RawContractCall[];
+    /**
+     * Set which TIP-20 token will be used to pay transaction fees
+     * This is a global setting for the entire transaction
+     *
+     * @param tokenAddress - Address of the TIP-20 token to use for fees
+     * @returns this builder instance for chaining
+     */
+    feeToken(tokenAddress: string): this;
+    /**
+     * Set the transaction nonce
+     *
+     * @param nonce - Transaction nonce
+     * @returns this builder instance for chaining
+     */
+    nonce(nonce: number): this;
+    /**
+     * Set the gas limit for the transaction
+     *
+     * @param gas - Gas limit
+     * @returns this builder instance for chaining
+     */
+    gas(gas: string | bigint): this;
+    /**
+     * Set the maximum fee per gas (EIP-1559)
+     *
+     * @param maxFeePerGas - Maximum fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxFeePerGas(maxFeePerGas: string | bigint): this;
+    /**
+     * Set the maximum priority fee per gas (EIP-1559)
+     *
+     * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxPriorityFeePerGas(maxPriorityFeePerGas: string | bigint): this;
+    /**
+     * Get all operations in this transaction
+     * @returns Array of TIP-20 operations
+     */
+    getOperations(): Tip20Operation[];
+    /**
+     * Get the fee token address if set
+     * @returns Fee token address or undefined
+     */
+    getFeeToken(): Address | undefined;
+    /**
+     * Validate a single operation
+     * @param operation - Operation to validate
+     * @throws BuildTransactionError if invalid
+     */
+    private validateOperation;
+    /**
+     * Convert a TIP-20 operation to an AA call
+     */
+    private operationToCall;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

package/dist/src/lib/transactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,WAAW,IAAI,cAAc,EAC7B,kBAAkB,IAAI,0BAA0B,EAChD,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,eAAe,EAIhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,OAAO,EAAO,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAexE;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,0BAA0B;IACrE,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,kBAAkB,CAAC,CAAsC;gBAErD,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,eAAe;IASjE;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAsB3B,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,GAAG,GAAG,IAAI;IAYjD,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,cAAc;IAU7F;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAmF5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;;OAGG;cACa,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IA6D/D;;;;;;OAMG;IACH,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAM7C;;;;;;OAMG;IACH,UAAU,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAmBvC;;;OAGG;IACH,WAAW,IAAI,eAAe,EAAE;IAIhC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAQpC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ1B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAS/B;;;;;OAKG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjD;;;;;OAKG;IACH,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjE;;;OAGG;IACH,aAAa,IAAI,cAAc,EAAE;IAIjC;;;OAGG;IACH,WAAW,IAAI,OAAO,GAAG,SAAS;IAIlC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAUxB"}