@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/contracts/governance.js

@@ -1,9 +1,27 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { sleep } from '@aztec/foundation/sleep';
-import { GovernanceAbi } from '@aztec/l1-artifacts';
-import { encodeFunctionData, getContract } from 'viem';
-import { L1TxUtils } from '../l1_tx_utils.js';
-import { GovernanceProposerContract } from './governance_proposer.js';
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+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 DataStructures.ProposalState in l1-contracts
 export var ProposalState = /*#__PURE__*/ function(ProposalState) {
     ProposalState[ProposalState["Pending"] = 0] = "Pending";
@@ -16,89 +34,214 @@ export var ProposalState = /*#__PURE__*/ function(ProposalState) {
     ProposalState[ProposalState["Expired"] = 7] = "Expired";
     return ProposalState;
 }({});
-export class GovernanceContract {
-    publicClient;
-    walletClient;
-    publicGovernance;
-    walletGovernance;
-    constructor(address, publicClient, walletClient){
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
-        this.publicGovernance = getContract({
+/** Set of `ProposalState` values for which a proposal is fully immutable on-chain. */ const TERMINAL_PROPOSAL_STATES = new Set([
+    5,
+    4,
+    6,
+    7
+]);
+// 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 > 7) {
+        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;
+    constructor(address, client){
+        this.client = client;
+        this.proposalCache = new Map();
+        this.originalPayloadCache = new Map();
+        this.governanceContract = getContract({
             address,
             abi: GovernanceAbi,
-            client: publicClient
+            client: client
         });
-        this.walletGovernance = walletClient ? getContract({
-            address,
-            abi: GovernanceAbi,
-            client: walletClient
-        }) : undefined;
     }
     get address() {
-        return EthAddress.fromString(this.publicGovernance.address);
+        return EthAddress.fromString(this.governanceContract.address);
     }
-    async getProposer() {
-        const governanceProposerAddress = EthAddress.fromString(await this.publicGovernance.read.governanceProposer());
-        return new GovernanceProposerContract(this.publicClient, governanceProposerAddress.toString());
+    async getGovernanceProposerAddress() {
+        return EthAddress.fromString(await this.governanceContract.read.governanceProposer());
     }
-    async getGovernanceAddresses() {
-        const governanceProposer = await this.getProposer();
-        const [rollupAddress, registryAddress] = await Promise.all([
-            governanceProposer.getRollupAddress(),
-            governanceProposer.getRegistryAddress()
-        ]);
+    async getConfiguration() {
+        const raw = await this.governanceContract.read.getConfiguration();
         return {
-            governanceAddress: this.address,
-            rollupAddress,
-            registryAddress,
-            governanceProposerAddress: governanceProposer.address
+            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
         };
     }
-    getProposal(proposalId) {
-        return this.publicGovernance.read.getProposal([
-            proposalId
+    /**
+   * 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;
     }
-    async getProposalState(proposalId) {
-        const state = await this.publicGovernance.read.getProposalState([
+    /**
+   * 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
-        ]);
-        if (state < 0 || state > 7) {
-            throw new Error(`Invalid proposal state: ${state}`);
-        }
-        return state;
+        ]));
     }
-    assertWalletGovernance() {
-        if (!this.walletGovernance) {
-            throw new Error('Wallet client is required for this operation');
-        }
-        return this.walletGovernance;
+    getProposalCount() {
+        return this.governanceContract.read.proposalCount();
     }
-    async deposit(onBehalfOf, amount) {
-        const walletGovernance = this.assertWalletGovernance();
-        const depositTx = await walletGovernance.write.deposit([
-            onBehalfOf,
-            amount
-        ]);
-        await this.publicClient.waitForTransactionReceipt({
-            hash: depositTx
-        });
+    /**
+   * Checks whether the given original payload is currently the subject of a live (non-terminal)
+   * Governance proposal. Returns true only if a proposal references this payload and is still in
+   * Pending, Active, Queued, or Executable state. Terminal proposals (Executed, Rejected, Dropped,
+   * Expired) are ignored, because once a proposal reaches a terminal state the same original
+   * payload may legitimately be re-signaled and re-submitted via the GovernanceProposer (each round
+   * is independent and there is no payload-level uniqueness check on-chain).
+   *
+   * 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.
+   */ async hasActiveProposalWithPayload(payload) {
+        const proposalCount = await this.getProposalCount();
+        if (proposalCount === 0n) {
+            return false;
+        }
+        // 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;
+        const target = payload.toLowerCase();
+        // 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) {
+                return false;
+            }
+            const original = await this.getOriginalPayload(proposal.payload);
+            if (original === undefined || original.toLowerCase() !== target) {
+                continue;
+            }
+            // The wrapper unwraps to our payload. Only treat this as "already proposed" if the proposal
+            // is still live -- terminal states allow re-proposing the same payload in a later round.
+            if (TERMINAL_PROPOSAL_STATES.has(proposal.state)) {
+                continue;
+            }
+            return true;
+        }
+        return false;
     }
-    async proposeWithLock({ payloadAddress, withdrawAddress }) {
-        const walletGovernance = this.assertWalletGovernance();
-        const proposeTx = await walletGovernance.write.proposeWithLock([
-            payloadAddress,
-            withdrawAddress
-        ]);
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: proposeTx
-        });
-        if (receipt.status !== 'success') {
-            throw new Error(`Proposal failed: ${receipt.status}`);
+    /**
+   * 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;
         }
-        const proposalId = Number(receipt.logs[1].topics[1]);
-        return proposalId;
+        this.originalPayloadCache.set(key, original);
+        return original;
     }
     async awaitProposalActive({ proposalId, logger }) {
         const state = await this.getProposalState(proposalId);
@@ -109,7 +252,7 @@ export class GovernanceContract {
         } else {
             const proposal = await this.getProposal(proposalId);
             const startOfActive = proposal.creation + proposal.config.votingDelay;
-            const block = await this.publicClient.getBlock();
+            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();
@@ -135,7 +278,7 @@ export class GovernanceContract {
         } else {
             const proposal = await this.getProposal(proposalId);
             const startOfExecutable = proposal.creation + proposal.config.votingDelay + proposal.config.votingDuration + proposal.config.executionDelay;
-            const block = await this.publicClient.getBlock();
+            const block = await this.client.getBlock();
             const secondsToExecutable = Number(startOfExecutable - block.timestamp) + 12;
             const now = new Date();
             logger.info(`
@@ -146,19 +289,67 @@ export class GovernanceContract {
             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 walletGovernance = this.assertWalletGovernance();
-        const now = await this.publicClient.getBlock();
-        return walletGovernance.read.powerAt([
-            this.walletClient.account.address,
+        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 walletGovernance = this.assertWalletGovernance();
-        const l1TxUtils = new L1TxUtils(this.publicClient, this.walletClient, logger);
+        const l1TxUtils = createL1TxUtils(this.client, {
+            logger
+        });
         const retryDelaySeconds = 12;
-        voteAmount = voteAmount ?? await this.getPower();
+        voteAmount = voteAmount ?? await this.getPowerForProposal(proposalId);
         let success = false;
         for(let i = 0; i < retries; i++){
             try {
@@ -173,7 +364,8 @@ export class GovernanceContract {
                 };
                 const encodedVoteData = encodeFunctionData(voteFunctionData);
                 const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
-                    to: walletGovernance.address,
+                    to: this.governanceContract.address,
+                    abi: GovernanceAbi,
                     data: encodedVoteData
                 });
                 if (receipt.status === 'success') {
@@ -182,7 +374,7 @@ export class GovernanceContract {
                 } else {
                     const args = {
                         ...voteFunctionData,
-                        address: walletGovernance.address
+                        address: this.governanceContract.address
                     };
                     const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedVoteData, args, undefined, []);
                     logger.error(`Error voting on proposal ${proposalId}: ${errorMsg}`);
@@ -198,13 +390,14 @@ export class GovernanceContract {
         }
         logger.info(`Voted [${inFavor ? 'yea' : 'nay'}] on proposal [${proposalId}]`);
         const proposal = await this.getProposal(proposalId);
-        logger.info(`Proposal [${proposalId}] has state [${proposal.state}]`);
+        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 nea [${proposal.summedBallot.nea}]`);
+        logger.info(`Proposal [${proposalId}] has summedBallot nay [${proposal.summedBallot.nay}]`);
     }
     async executeProposal({ proposalId, retries = 10, logger }) {
-        const walletGovernance = this.assertWalletGovernance();
-        const l1TxUtils = new L1TxUtils(this.publicClient, this.walletClient, logger);
+        const l1TxUtils = createL1TxUtils(this.client, {
+            logger
+        });
         const retryDelaySeconds = 12;
         let success = false;
         for(let i = 0; i < retries; i++){
@@ -218,7 +411,8 @@ export class GovernanceContract {
                 };
                 const encodedExecuteData = encodeFunctionData(executeFunctionData);
                 const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
-                    to: walletGovernance.address,
+                    to: this.governanceContract.address,
+                    abi: GovernanceAbi,
                     data: encodedExecuteData
                 });
                 if (receipt.status === 'success') {
@@ -227,7 +421,7 @@ export class GovernanceContract {
                 } else {
                     const args = {
                         ...executeFunctionData,
-                        address: walletGovernance.address
+                        address: this.governanceContract.address
                     };
                     const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedExecuteData, args, undefined, []);
                     logger.error(`Error executing proposal ${proposalId}: ${errorMsg}`);

package/dest/contracts/governance_proposer.d.ts

@@ -1,28 +1,64 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type Hex, type TransactionReceipt } from 'viem';
-import type { GasPrice, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
-import type { ViemPublicClient } from '../types.js';
+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 { ReadOnlyGovernanceContract } from './governance.js';
 export declare class GovernanceProposerContract implements IEmpireBase {
-    readonly client: ViemPublicClient;
+    readonly client: ViemClient;
     private readonly proposer;
-    constructor(client: ViemPublicClient, address: Hex);
+    /**
+     * 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: bigint): Promise<bigint>;
+    getInstance(): Promise<`0x${string}`>;
+    computeRound(slot: SlotNumber): Promise<bigint>;
     getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{
-        lastVote: bigint;
-        leader: Hex;
+        lastSignalSlot: SlotNumber;
+        payloadWithMostSignals: Hex;
+        quorumReached: boolean;
         executed: boolean;
     }>;
-    getProposalVotes(rollupAddress: Hex, round: bigint, proposal: Hex): Promise<bigint>;
-    createVoteRequest(payload: Hex): L1TxRequest;
-    executeProposal(round: bigint, l1TxUtils: L1TxUtils): Promise<{
+    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>;
+    /**
+     * Returns true iff the given original payload is currently the subject of a live (non-terminal)
+     * Governance proposal. Delegates to `ReadOnlyGovernanceContract.hasActiveProposalWithPayload`, 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.
+     */
+    hasActiveProposalWithPayload(payload: Hex): Promise<boolean>;
+    /**
+     * 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;
-        gasPrice: GasPrice;
+        proposalId: bigint;
     }>;
 }
-//# sourceMappingURL=governance_proposer.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"governance_proposer.d.ts","sourceRoot":"","sources":["../../src/contracts/governance_proposer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAA8B,KAAK,GAAG,EAAE,KAAK,kBAAkB,EAAmC,MAAM,MAAM,CAAC;AAEtH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,KAAK,WAAW,EAAc,MAAM,kBAAkB,CAAC;AAEhE,qBAAa,0BAA2B,YAAW,WAAW;aAGhC,MAAM,EAAE,gBAAgB;IAFpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwE;gBAErE,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG;IAIlE,IAAW,OAAO,eAEjB;IAEY,gBAAgB;IAKhB,kBAAkB;IAIxB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAIhC,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrC,YAAY,CACvB,aAAa,EAAE,GAAG,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IASzD,gBAAgB,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAInF,iBAAiB,CAAC,OAAO,EAAE,GAAG,GAAG,WAAW;IAO5C,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC;QACT,OAAO,EAAE,kBAAkB,CAAC;QAC5B,QAAQ,EAAE,QAAQ,CAAC;KACpB,CAAC;CAUH"}
+{"version":3,"file":"governance_proposer.d.ts","sourceRoot":"","sources":["../../src/contracts/governance_proposer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,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,0BAA0B,EAA6B,MAAM,iBAAiB,CAAC;AAExF,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,eAEjB;IAEY,gBAAgB,wBAE5B;IAGY,kBAAkB,wBAE9B;IAEM,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAEtC;IAEM,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAErC;IAEM,WAAW,2BAEjB;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,4BAA4B,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAGxE;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"}