@aztec-labs/ethereum 6.0.0-nightly.20260829

package/dest/contracts/governance.js

@@ -0,0 +1,471 @@
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { encodeFunctionData, getContract, parseEventLogs } from 'viem';
+import { createL1TxUtils } from '../l1_tx_utils/index.js';
+import { isExtendedClient } from '../types.js';
+// Minimal ABI for IProposerPayload (`l1-contracts/src/governance/interfaces/IProposerPayload.sol`).
+// The GovernanceProposer wraps every original payload in a GSEPayload before submitting it to
+// Governance, so `Proposal.payload` on the Governance contract is the wrapper address rather than
+// the original. We only need `getOriginalPayload` to recover the underlying payload, so we inline
+// the ABI here instead of generating a full artifact.
+const ProposerPayloadAbi = [
+    {
+        type: 'function',
+        name: 'getOriginalPayload',
+        inputs: [],
+        outputs: [
+            {
+                type: 'address'
+            }
+        ],
+        stateMutability: 'view'
+    }
+];
+// NOTE: Must be kept in sync with IGovernance.ProposalState in l1-contracts
+export var ProposalState = /*#__PURE__*/ function(ProposalState) {
+    ProposalState[ProposalState["Pending"] = 0] = "Pending";
+    ProposalState[ProposalState["Active"] = 1] = "Active";
+    ProposalState[ProposalState["Queued"] = 2] = "Queued";
+    ProposalState[ProposalState["Executable"] = 3] = "Executable";
+    ProposalState[ProposalState["Rejected"] = 4] = "Rejected";
+    ProposalState[ProposalState["Executed"] = 5] = "Executed";
+    ProposalState[ProposalState["Droppable"] = 6] = "Droppable";
+    ProposalState[ProposalState["Dropped"] = 7] = "Dropped";
+    ProposalState[ProposalState["Expired"] = 8] = "Expired";
+    return ProposalState;
+}({});
+/** Set of `ProposalState` values for which a proposal is fully immutable on-chain. */ const TERMINAL_PROPOSAL_STATES = new Set([
+    5,
+    4,
+    7,
+    8
+]);
+// Set of `ProposalState` values in which a proposal is still progressing towards execution.
+// `Droppable` is deliberately excluded: it is neither live (it cannot progress on its own) nor
+// terminal (it can resume its lifecycle if the governanceProposer is restored), so it is handled
+// separately and is never memoized as immutable.
+const LIVE_PROPOSAL_STATES = new Set([
+    0,
+    1,
+    2,
+    3
+]);
+// Hard upper bound on the wall-clock lifetime of any Governance proposal, in seconds.
+// Each proposal stores its own snapshot of `ProposalConfiguration` at creation time and progresses
+// through Pending -> Active -> Queued -> Executable using those frozen durations
+// (see `ProposalLib.{pendingThrough,activeThrough,queuedThrough,executableThrough}`). Each of those
+// four durations is bounded by `ConfigurationLib.TIME_UPPER = 90 days` (validated in
+// `ConfigurationLib.assertValid`), so no proposal can be live for more than 4 * 90 days regardless
+// of what config it was created under. Once past this point, the proposal is guaranteed to be in a
+// terminal state (Executed / Rejected / Dropped / Expired).
+export const MAX_PROPOSAL_LIFETIME_SECONDS = 4n * 90n * 24n * 3600n;
+/**
+ * Validates a number returned by an on-chain `ProposalState` enum field and narrows it to the
+ * `ProposalState` enum. Throws if the value is out of range.
+ */ function asProposalState(raw) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    if (raw < 0 || raw > 8) {
+        throw new Error(`Invalid proposal state: ${raw}`);
+    }
+    return raw;
+}
+export function extractProposalIdFromLogs(logs) {
+    const parsedLogs = parseEventLogs({
+        abi: GovernanceAbi,
+        logs: logs,
+        eventName: 'Proposed'
+    });
+    if (parsedLogs.length === 0) {
+        throw new Error('Proposal log not found');
+    }
+    return parsedLogs[0].args.proposalId;
+}
+export class ReadOnlyGovernanceContract {
+    client;
+    governanceContract;
+    /**
+   * Cache of fully-resolved proposals keyed by id. We populate this lazily and only retain entries
+   * whose state is provably terminal -- once `cachedState` is `Executed` or `Dropped` the on-chain
+   * proposal struct is frozen and safe to memoize indefinitely. Other state transitions (e.g.
+   * Pending -> Active, or accumulating votes) leave the cache untouched and force a fresh fetch.
+   */ proposalCache;
+    /**
+   * Cache of `IProposerPayload.getOriginalPayload()` results keyed by wrapper address. The wrapper
+   * contract's bytecode is immutable, so this mapping never changes -- a value of `undefined`
+   * encodes a proposal whose payload doesn't implement `getOriginalPayload` (e.g. proposeWithLock
+   * proposals) and should be treated as "no original".
+   */ originalPayloadCache;
+    /**
+   * Payloads (lowercased hex) observed as the subject of an `Executed` Governance proposal. Execution
+   * is immutable on-chain, so this verdict never expires within a process. It restores the
+   * `'executed'` classification for payloads whose executed proposal has since aged past the bounded
+   * lookback below. Lost on restart, at which point the bounded-lookback limitation applies again.
+   */ executedPayloads;
+    constructor(address, client){
+        this.client = client;
+        this.proposalCache = new Map();
+        this.originalPayloadCache = new Map();
+        this.executedPayloads = new Set();
+        this.governanceContract = getContract({
+            address,
+            abi: GovernanceAbi,
+            client: client
+        });
+    }
+    get address() {
+        return EthAddress.fromString(this.governanceContract.address);
+    }
+    async getGovernanceProposerAddress() {
+        return EthAddress.fromString(await this.governanceContract.read.governanceProposer());
+    }
+    async getConfiguration() {
+        const raw = await this.governanceContract.read.getConfiguration();
+        return {
+            proposeConfig: {
+                lockDelay: raw.proposeConfig.lockDelay,
+                lockAmount: raw.proposeConfig.lockAmount
+            },
+            votingDelay: raw.votingDelay,
+            votingDuration: raw.votingDuration,
+            executionDelay: raw.executionDelay,
+            gracePeriod: raw.gracePeriod,
+            quorum: raw.quorum,
+            requiredYeaMargin: raw.requiredYeaMargin,
+            minimumVotes: raw.minimumVotes
+        };
+    }
+    /**
+   * Fetches a proposal by id together with its live state, returning the mapped {@link Proposal}
+   * type. Issues `getProposal` and `getProposalState` in parallel so the result carries both the
+   * raw stored `cachedState` and the time-derived `state` -- callers can use whichever they need
+   * without an extra round-trip.
+   *
+   * Backed by an in-memory cache that retains entries only when `state` is in one of the four
+   * terminal phases (`Executed` / `Rejected` / `Dropped` / `Expired`). At that point the entire
+   * proposal struct is provably immutable on-chain (no further votes can be cast and no
+   * state-mutating call can succeed), so caching is safe forever. Non-terminal states force a
+   * fresh fetch on every call so callers always see fresh `state` and `summedBallot` values.
+   */ async getProposal(proposalId) {
+        const cached = this.proposalCache.get(proposalId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const [raw, rawState] = await Promise.all([
+            this.governanceContract.read.getProposal([
+                proposalId
+            ]),
+            this.governanceContract.read.getProposalState([
+                proposalId
+            ])
+        ]);
+        const proposal = {
+            config: {
+                votingDelay: raw.config.votingDelay,
+                votingDuration: raw.config.votingDuration,
+                executionDelay: raw.config.executionDelay,
+                gracePeriod: raw.config.gracePeriod,
+                quorum: raw.config.quorum,
+                requiredYeaMargin: raw.config.requiredYeaMargin,
+                minimumVotes: raw.config.minimumVotes
+            },
+            cachedState: asProposalState(raw.cachedState),
+            state: asProposalState(rawState),
+            payload: EthAddress.fromString(raw.payload),
+            proposer: EthAddress.fromString(raw.proposer),
+            creation: raw.creation,
+            summedBallot: {
+                yea: raw.summedBallot.yea,
+                nay: raw.summedBallot.nay
+            }
+        };
+        if (TERMINAL_PROPOSAL_STATES.has(proposal.state)) {
+            this.proposalCache.set(proposalId, proposal);
+        }
+        return proposal;
+    }
+    /**
+   * Returns the live state of a proposal as computed by `Governance.getProposalState`. Prefer
+   * {@link getProposal} when you also need any other proposal data -- it returns this same value
+   * via {@link Proposal.state} alongside the rest of the struct in a single round-trip.
+   */ async getProposalState(proposalId) {
+        return asProposalState(await this.governanceContract.read.getProposalState([
+            proposalId
+        ]));
+    }
+    getProposalCount() {
+        return this.governanceContract.read.proposalCount();
+    }
+    /**
+   * Classifies the given original payload against the Governance proposal history. Distinguishes a
+   * payload that is still the subject of a live proposal (`'live'`) from one whose proposal was
+   * already executed (`'executed'`) from one that has no relevant proposal (`'none'`), so callers can
+   * stop re-signalling an executed payload while still re-signalling one whose proposal was merely
+   * rejected/dropped/expired (each GovernanceProposer round is independent and there is no
+   * payload-level uniqueness check on-chain).
+   *
+   * A proposal matches the payload either directly (its stored `payload` equals the target, as for
+   * `proposeWithLock` proposals) or via its `GSEPayload` wrapper unwrapping to the target. `'live'`
+   * (including `Droppable`) takes precedence over `'executed'`, so a payload re-submitted while a
+   * prior execution is still in the lookback window reads as `'live'`.
+   *
+   * Implemented as a bounded view-call sweep over `Governance.proposals` rather than an event scan,
+   * because `eth_getLogs` over the full deployment history of a long-lived rollup exceeds typical
+   * RPC block-range caps. The number of proposals (`proposalCount`) is small in practice, and we
+   * walk newest -> oldest with a hard early-stop on the protocol-wide proposal lifetime cap. This
+   * makes the `'executed'` verdict a *bounded lookback* rather than permanent suppression: a proposal
+   * executed longer ago than the lifetime cap is only reported once it has been observed and
+   * memoized in-process (memo is lost on restart).
+   */ async getPayloadProposalStatus(payload) {
+        const target = payload.toLowerCase();
+        const proposalCount = await this.getProposalCount();
+        if (proposalCount === 0n) {
+            return this.executedPayloads.has(target) ? 'executed' : 'none';
+        }
+        // Anything created before this cutoff is guaranteed terminal regardless of its frozen config.
+        const block = await this.client.getBlock();
+        const hardCutoff = block.timestamp - MAX_PROPOSAL_LIFETIME_SECONDS;
+        // Proposals are append-only with monotonically non-decreasing creation timestamps, so iterating
+        // from newest -> oldest lets us early-stop as soon as we cross the lifetime cutoff.
+        for(let id = proposalCount - 1n; id >= 0n; id--){
+            const proposal = await this.getProposal(id);
+            // Hard early-stop: every older proposal is also older than the cutoff and therefore terminal.
+            if (proposal.creation < hardCutoff) {
+                break;
+            }
+            const proposalPayload = proposal.payload.toString().toLowerCase();
+            const original = await this.getOriginalPayload(proposal.payload);
+            const matches = proposalPayload === target || original !== undefined && original.toLowerCase() === target;
+            if (!matches) {
+                continue;
+            }
+            // A live or Droppable proposal blocks re-signalling and wins over any executed one.
+            if (LIVE_PROPOSAL_STATES.has(proposal.state) || proposal.state === 6) {
+                return 'live';
+            }
+            if (proposal.state === 5) {
+                this.executedPayloads.add(target);
+            }
+        // Rejected/Dropped/Expired proposals allow re-proposing the same payload; keep scanning.
+        }
+        return this.executedPayloads.has(target) ? 'executed' : 'none';
+    }
+    /**
+   * Resolves the original payload behind a `GSEPayload` wrapper. Returns `undefined` if the
+   * wrapper does not implement `IProposerPayload.getOriginalPayload` (e.g. proposals created via
+   * `Governance.proposeWithLock`, which bypass GSEPayload entirely and store the raw `IPayload`
+   * directly). Results are memoized indefinitely because deployed wrapper bytecode is immutable.
+   */ async getOriginalPayload(wrapper) {
+        const key = wrapper.toString();
+        if (this.originalPayloadCache.has(key)) {
+            return this.originalPayloadCache.get(key);
+        }
+        let original;
+        try {
+            original = await this.client.readContract({
+                address: key,
+                abi: ProposerPayloadAbi,
+                functionName: 'getOriginalPayload'
+            });
+        } catch  {
+            original = undefined;
+        }
+        this.originalPayloadCache.set(key, original);
+        return original;
+    }
+    async awaitProposalActive({ proposalId, logger }) {
+        const state = await this.getProposalState(proposalId);
+        if (state === 1) {
+            return;
+        } else if (state !== 0) {
+            throw new Error(`Proposal ${proposalId} is in state [${state}]: it will never be active`);
+        } else {
+            const proposal = await this.getProposal(proposalId);
+            const startOfActive = proposal.creation + proposal.config.votingDelay;
+            const block = await this.client.getBlock();
+            // Add 12 seconds to the time to make sure we don't vote too early
+            const secondsToActive = Number(startOfActive - block.timestamp) + 12;
+            const now = new Date();
+            logger.info(`
+        The time is ${now.toISOString()}.
+        The proposal will be active at ${new Date(Number(startOfActive) * 1000).toISOString()}.
+        Waiting ${secondsToActive} seconds for proposal to be active.
+        `);
+            await sleep(secondsToActive * 1000);
+        }
+    }
+    async awaitProposalExecutable({ proposalId, logger }) {
+        const state = await this.getProposalState(proposalId);
+        if (state === 3) {
+            return;
+        } else if (![
+            0,
+            1,
+            2,
+            3
+        ].includes(state)) {
+            throw new Error(`Proposal ${proposalId} is in state [${state}]: it will never be executable`);
+        } else {
+            const proposal = await this.getProposal(proposalId);
+            const startOfExecutable = proposal.creation + proposal.config.votingDelay + proposal.config.votingDuration + proposal.config.executionDelay;
+            const block = await this.client.getBlock();
+            const secondsToExecutable = Number(startOfExecutable - block.timestamp) + 12;
+            const now = new Date();
+            logger.info(`
+        The time is ${now.toISOString()}.
+        The proposal will be executable at ${new Date(Number(startOfExecutable) * 1000).toISOString()}.
+        Waiting ${secondsToExecutable} seconds for proposal to be executable.
+        `);
+            await sleep(secondsToExecutable * 1000);
+        }
+    }
+}
+export class GovernanceContract extends ReadOnlyGovernanceContract {
+    client;
+    governanceContract;
+    constructor(address, client){
+        if (address instanceof EthAddress) {
+            address = address.toString();
+        }
+        super(address, client), this.client = client;
+        if (!isExtendedClient(client)) {
+            throw new Error('GovernanceContract has to be instantiated with a wallet client.');
+        }
+        this.governanceContract = getContract({
+            address,
+            abi: GovernanceAbi,
+            client
+        });
+    }
+    async deposit(onBehalfOf, amount) {
+        const depositTx = await this.governanceContract.write.deposit([
+            onBehalfOf,
+            amount
+        ]);
+        await this.client.waitForTransactionReceipt({
+            hash: depositTx
+        });
+    }
+    async proposeWithLock({ payloadAddress, withdrawAddress }) {
+        const proposeTx = await this.governanceContract.write.proposeWithLock([
+            payloadAddress,
+            withdrawAddress
+        ]);
+        const receipt = await this.client.waitForTransactionReceipt({
+            hash: proposeTx
+        });
+        if (receipt.status !== 'success') {
+            throw new Error(`Proposal failed: ${receipt.status}`);
+        }
+        return extractProposalIdFromLogs(receipt.logs);
+    }
+    async getPower() {
+        const now = await this.client.getBlock();
+        return this.governanceContract.read.powerAt([
+            this.client.account.address,
+            now.timestamp
+        ]);
+    }
+    /** Returns the user's voting power for a specific proposal, checked at pendingThrough timestamp. */ async getPowerForProposal(proposalId) {
+        const proposal = await this.getProposal(proposalId);
+        const pendingThrough = proposal.creation + proposal.config.votingDelay;
+        return this.governanceContract.read.powerAt([
+            this.client.account.address,
+            pendingThrough
+        ]);
+    }
+    async vote({ proposalId, voteAmount, inFavor, retries = 10, logger }) {
+        const l1TxUtils = createL1TxUtils(this.client, {
+            logger
+        });
+        const retryDelaySeconds = 12;
+        voteAmount = voteAmount ?? await this.getPowerForProposal(proposalId);
+        let success = false;
+        for(let i = 0; i < retries; i++){
+            try {
+                const voteFunctionData = {
+                    abi: GovernanceAbi,
+                    functionName: 'vote',
+                    args: [
+                        proposalId,
+                        voteAmount,
+                        inFavor
+                    ]
+                };
+                const encodedVoteData = encodeFunctionData(voteFunctionData);
+                const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+                    to: this.governanceContract.address,
+                    abi: GovernanceAbi,
+                    data: encodedVoteData
+                });
+                if (receipt.status === 'success') {
+                    success = true;
+                    break;
+                } else {
+                    const args = {
+                        ...voteFunctionData,
+                        address: this.governanceContract.address
+                    };
+                    const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedVoteData, args, undefined, []);
+                    logger.error(`Error voting on proposal ${proposalId}: ${errorMsg}`);
+                }
+            } catch (error) {
+                logger.error(`Error voting on proposal ${proposalId}: ${error}`);
+            }
+            logger.info(`Retrying vote on proposal ${proposalId} in ${retryDelaySeconds} seconds`);
+            await sleep(retryDelaySeconds * 1000);
+        }
+        if (!success) {
+            throw new Error(`Failed to vote on proposal ${proposalId} after ${retries} retries`);
+        }
+        logger.info(`Voted [${inFavor ? 'yea' : 'nay'}] on proposal [${proposalId}]`);
+        const proposal = await this.getProposal(proposalId);
+        logger.info(`Proposal [${proposalId}] has cached state [${proposal.cachedState}]`);
+        logger.info(`Proposal [${proposalId}] has summedBallot yea [${proposal.summedBallot.yea}]`);
+        logger.info(`Proposal [${proposalId}] has summedBallot nay [${proposal.summedBallot.nay}]`);
+    }
+    async executeProposal({ proposalId, retries = 10, logger }) {
+        const l1TxUtils = createL1TxUtils(this.client, {
+            logger
+        });
+        const retryDelaySeconds = 12;
+        let success = false;
+        for(let i = 0; i < retries; i++){
+            try {
+                const executeFunctionData = {
+                    abi: GovernanceAbi,
+                    functionName: 'execute',
+                    args: [
+                        proposalId
+                    ]
+                };
+                const encodedExecuteData = encodeFunctionData(executeFunctionData);
+                const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+                    to: this.governanceContract.address,
+                    abi: GovernanceAbi,
+                    data: encodedExecuteData
+                });
+                if (receipt.status === 'success') {
+                    success = true;
+                    break;
+                } else {
+                    const args = {
+                        ...executeFunctionData,
+                        address: this.governanceContract.address
+                    };
+                    const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedExecuteData, args, undefined, []);
+                    logger.error(`Error executing proposal ${proposalId}: ${errorMsg}`);
+                }
+            } catch (error) {
+                logger.error(`Error executing proposal ${proposalId}: ${error}`);
+            }
+            logger.info(`Retrying execute proposal ${proposalId} in ${retryDelaySeconds} seconds`);
+            await sleep(retryDelaySeconds * 1000);
+        }
+        if (!success) {
+            throw new Error(`Failed to execute proposal ${proposalId} after ${retries} retries`);
+        } else {
+            logger.info(`Executed proposal ${proposalId}`);
+        }
+    }
+}

package/dest/contracts/governance_proposer.d.ts

@@ -0,0 +1,63 @@
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Hex, type TransactionReceipt, type TypedDataDefinition } from 'viem';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { ViemClient } from '../types.js';
+import { type IEmpireBase } from './empire_base.js';
+import { type PayloadProposalStatus, ReadOnlyGovernanceContract } from './governance.js';
+export declare class GovernanceProposerContract implements IEmpireBase {
+    readonly client: ViemClient;
+    private readonly proposer;
+    /**
+     * Cache of bytecode-existence checks keyed by payload address. The check is stable for a
+     * contract's lifetime -- a contract either has code or it does not, and code cannot be removed
+     * after deployment (selfdestruct aside, which is not relevant here). Safe to memoize
+     * indefinitely for the lifetime of this instance.
+     */
+    private readonly emptyPayloadCache;
+    constructor(client: ViemClient, address: Hex | EthAddress);
+    get address(): EthAddress;
+    getRollupAddress(): Promise<EthAddress>;
+    getRegistryAddress(): Promise<EthAddress>;
+    getQuorumSize(): Promise<bigint>;
+    getRoundSize(): Promise<bigint>;
+    computeRound(slot: SlotNumber): Promise<bigint>;
+    getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{
+        lastSignalSlot: SlotNumber;
+        payloadWithMostSignals: Hex;
+        quorumReached: boolean;
+        executed: boolean;
+    }>;
+    getPayloadSignals(rollupAddress: Hex, round: bigint, payload: Hex): Promise<bigint>;
+    createSignalRequest(payload: Hex): L1TxRequest;
+    createSignalRequestWithSignature(payload: Hex, slot: SlotNumber, chainId: number, signerAddress: Hex, signer: (msg: TypedDataDefinition) => Promise<Hex>): Promise<L1TxRequest>;
+    /**
+     * Resolves the Governance contract this proposer submits winners to. Lazily reads
+     * `GovernanceProposer.getGovernance()` (which itself looks the address up via the registry) and
+     * memoizes the resulting wrapper.
+     */
+    getGovernance(): Promise<ReadOnlyGovernanceContract>;
+    /**
+     * Classifies the given original payload against the Governance proposal history (`'live'` /
+     * `'executed'` / `'none'`). Delegates to `ReadOnlyGovernanceContract.getPayloadProposalStatus`,
+     * which implements the actual sweep against the Governance contract -- this method exists only as
+     * a convenience wrapper so callers that already hold a GovernanceProposer reference don't have to
+     * resolve the Governance address themselves.
+     */
+    getPayloadProposalStatus(payload: Hex): Promise<PayloadProposalStatus>;
+    /**
+     * Returns true if the given payload address has no deployed bytecode. Used as a cheap
+     * pre-flight check before casting a governance signal — voting for a zero-code address
+     * is unrecoverable.
+     *
+     * We only cache the `false` result (address has bytecode). The `true` result is NOT
+     * cached because a CREATE2-redeployed address could go from empty to populated, and
+     * caching `true` would make us keep skipping a payload that later becomes valid.
+     */
+    isPayloadEmpty(payload: EthAddress): Promise<boolean>;
+    submitRoundWinner(round: bigint, l1TxUtils: L1TxUtils): Promise<{
+        receipt: TransactionReceipt;
+        proposalId: bigint;
+    }>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/contracts/governance_proposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance_proposer.d.ts","sourceRoot":"","sources":["../../src/contracts/governance_proposer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAElE,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGzB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,KAAK,WAAW,EAA8D,MAAM,kBAAkB,CAAC;AAChH,OAAO,EAAE,KAAK,qBAAqB,EAAE,0BAA0B,EAA6B,MAAM,iBAAiB,CAAC;AAEpH,qBAAa,0BAA2B,YAAW,WAAW;aAY1C,MAAM,EAAE,UAAU;IAXpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkE;IAE3F;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgC;IAElE,YACkB,MAAM,EAAE,UAAU,EAClC,OAAO,EAAE,GAAG,GAAG,UAAU,EAM1B;IAED,IAAW,OAAO,IAAI,UAAU,CAE/B;IAEY,gBAAgB,IAAI,OAAO,CAAC,UAAU,CAAC,CAEnD;IAGY,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAErD;IAEM,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAEtC;IAEM,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAErC;IAEM,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAErD;IAEY,YAAY,CACvB,aAAa,EAAE,GAAG,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,cAAc,EAAE,UAAU,CAAC;QAAC,sBAAsB,EAAE,GAAG,CAAC;QAAC,aAAa,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAYjH;IAEM,iBAAiB,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAEzF;IAEM,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,WAAW,CAMpD;IAEY,gCAAgC,CAC3C,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,GAAG,EAClB,MAAM,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,GAAG,CAAC,GACjD,OAAO,CAAC,WAAW,CAAC,CActB;IAED;;;;OAIG;IAEU,aAAa,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAGhE;IAED;;;;;;OAMG;IACU,wBAAwB,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAGlF;IAED;;;;;;;;OAQG;IACU,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAWjE;IAEY,iBAAiB,CAC5B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC;QACT,OAAO,EAAE,kBAAkB,CAAC;QAC5B,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAYD;CACF"}