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

package/dest/contracts/slasher_contract.d.ts

@@ -0,0 +1,44 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemClient } from '../types.js';
+/**
+ * Typescript wrapper around the Slasher contract.
+ */
+export declare class SlasherContract {
+    private readonly client;
+    private readonly address;
+    private readonly log;
+    private contract;
+    constructor(client: ViemClient, address: EthAddress, log?: import("@aztec/foundation/log").Logger);
+    /**
+     * Checks if a slash payload is vetoed.
+     * @param payloadAddress - The address of the payload to check
+     * @returns True if the payload is vetoed, false otherwise
+     */
+    isPayloadVetoed(payloadAddress: EthAddress): Promise<boolean>;
+    /**
+     * Checks if slashing is currently enabled. Slashing can be disabled by the vetoer.
+     * @returns True if slashing is enabled, false otherwise
+     */
+    isSlashingEnabled(): Promise<boolean>;
+    /**
+     * Gets the current vetoer address.
+     * @returns The vetoer address
+     */
+    getVetoer(): Promise<EthAddress>;
+    /**
+     * Gets the disable duration by the vetoer.
+     * @returns The disable duration in seconds
+     */
+    getSlashingDisableDuration(): Promise<number>;
+    /**
+     * Gets the current governance address.
+     * @returns The governance address
+     */
+    getGovernance(): Promise<EthAddress>;
+    /**
+     * Gets the current proposer address.
+     * @returns The proposer address
+     */
+    getProposer(): Promise<EthAddress>;
+}
+//# sourceMappingURL=slasher_contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slasher_contract.d.ts","sourceRoot":"","sources":["../../src/contracts/slasher_contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAM3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,qBAAa,eAAe;IAIxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG;IALtB,OAAO,CAAC,QAAQ,CAAuD;gBAGpD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,UAAU,EACnB,GAAG,yCAAmC;IASzD;;;;OAIG;IACU,eAAe,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1E;;;OAGG;IACU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IASlD;;;OAGG;IACU,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC;IAK7C;;;OAGG;IACU,0BAA0B,IAAI,OAAO,CAAC,MAAM,CAAC;IAK1D;;;OAGG;IACU,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC;IAKjD;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,UAAU,CAAC;CAIhD"}

package/dest/contracts/slasher_contract.js

@@ -0,0 +1,75 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
+import { getContract } from 'viem';
+/**
+ * Typescript wrapper around the Slasher contract.
+ */ export class SlasherContract {
+    client;
+    address;
+    log;
+    contract;
+    constructor(client, address, log = createLogger('slasher-contract')){
+        this.client = client;
+        this.address = address;
+        this.log = log;
+        this.contract = getContract({
+            address: this.address.toString(),
+            abi: SlasherAbi,
+            client: this.client
+        });
+    }
+    /**
+   * Checks if a slash payload is vetoed.
+   * @param payloadAddress - The address of the payload to check
+   * @returns True if the payload is vetoed, false otherwise
+   */ async isPayloadVetoed(payloadAddress) {
+        try {
+            return await this.contract.read.vetoedPayloads([
+                payloadAddress.toString()
+            ]);
+        } catch (error) {
+            this.log.error(`Error checking if payload ${payloadAddress} is vetoed`, error);
+            throw error;
+        }
+    }
+    /**
+   * Checks if slashing is currently enabled. Slashing can be disabled by the vetoer.
+   * @returns True if slashing is enabled, false otherwise
+   */ async isSlashingEnabled() {
+        try {
+            return await this.contract.read.isSlashingEnabled();
+        } catch (error) {
+            this.log.error(`Error checking if slashing is enabled`, error);
+            throw error;
+        }
+    }
+    /**
+   * Gets the current vetoer address.
+   * @returns The vetoer address
+   */ async getVetoer() {
+        const vetoer = await this.contract.read.VETOER();
+        return EthAddress.fromString(vetoer);
+    }
+    /**
+   * Gets the disable duration by the vetoer.
+   * @returns The disable duration in seconds
+   */ async getSlashingDisableDuration() {
+        const duration = await this.contract.read.SLASHING_DISABLE_DURATION();
+        return Number(duration);
+    }
+    /**
+   * Gets the current governance address.
+   * @returns The governance address
+   */ async getGovernance() {
+        const governance = await this.contract.read.GOVERNANCE();
+        return EthAddress.fromString(governance);
+    }
+    /**
+   * Gets the current proposer address.
+   * @returns The proposer address
+   */ async getProposer() {
+        const proposer = await this.contract.read.PROPOSER();
+        return EthAddress.fromString(proposer);
+    }
+}

package/dest/contracts/tally_slashing_proposer.d.ts

@@ -0,0 +1,138 @@
+import { type L1TxRequest, type ViemClient } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Hex, type Log, type TypedDataDefinition } from 'viem';
+/**
+ * Wrapper around the TallySlashingProposer contract that provides
+ * a TypeScript interface for interacting with the consensus-based slashing system.
+ */
+export declare class TallySlashingProposerContract {
+    readonly client: ViemClient;
+    private readonly contract;
+    readonly type: "tally";
+    constructor(client: ViemClient, address: Hex | EthAddress);
+    get address(): EthAddress;
+    getQuorumSize(): Promise<bigint>;
+    getRoundSize(): Promise<bigint>;
+    getCommitteeSize(): Promise<bigint>;
+    getRoundSizeInEpochs(): Promise<bigint>;
+    getLifetimeInRounds(): Promise<bigint>;
+    getExecutionDelayInRounds(): Promise<bigint>;
+    getSlashingAmounts(): Promise<[bigint, bigint, bigint]>;
+    getSlashOffsetInRounds(): Promise<bigint>;
+    getCurrentRound(): Promise<bigint>;
+    /**
+     * Get round information
+     * @param round - The round number to query
+     * @returns Round status information
+     */
+    getRound(round: bigint): Promise<{
+        isExecuted: boolean;
+        voteCount: bigint;
+    }>;
+    /**
+     * Check if a round is ready to execute at a given slot
+     * @param round - The round number to check
+     * @param slot - The slot number to check at
+     * @returns Whether the round is ready to execute
+     */
+    isRoundReadyToExecute(round: bigint, slot: bigint): Promise<boolean>;
+    /** Returns the slash actions and payload address for a given round (zero if no slash actions) */
+    getPayload(round: bigint): Promise<{
+        actions: {
+            slashAmount: bigint;
+            validator: EthAddress;
+        }[];
+        address: EthAddress;
+    }>;
+    /** Returns the slash actions to be executed for a given round based on votes */
+    getTally(round: bigint): Promise<{
+        actions: {
+            slashAmount: bigint;
+            validator: EthAddress;
+        }[];
+        committees: EthAddress[][];
+    }>;
+    private mapSlashActions;
+    /** Tries to extract a VoteCast event from the given logs. */
+    tryExtractVoteCastEvent(logs: Log[]): {
+        eventName: "VoteCast";
+        args: {
+            round: bigint;
+            slot: bigint;
+            proposer: `0x${string}`;
+        };
+    } | undefined;
+    /** Tries to extract a RoundExecuted event from the given logs. */
+    tryExtractRoundExecutedEvent(logs: Log[]): {
+        eventName: "RoundExecuted";
+        args: {
+            round: bigint;
+            slashCount: bigint;
+        };
+    } | undefined;
+    /**
+     * Create a transaction to vote for slashing offenses
+     * @param votes - The encoded votes for slashing
+     * @param slot - The slot number for the vote
+     * @param signer - The signer to produce the signature
+     * @returns L1 transaction request
+     */
+    buildVoteRequestFromSigner(votes: Hex, slot: bigint, signer: (msg: TypedDataDefinition) => Promise<Hex>): Promise<L1TxRequest>;
+    /** Returns the typed data definition to EIP712-sign for voting */
+    buildVoteTypedData(votes: Hex, slot: bigint): TypedDataDefinition;
+    /** Gets the digest to sign for voting directly from the contract */
+    getVoteDataDigest(votes: Hex, slot: bigint): Promise<Buffer32>;
+    /**
+     * Create a transaction to vote for slashing offenses
+     * @param votes - The encoded votes for slashing
+     * @param signature - The signature from the current proposer
+     * @returns L1 transaction request
+     */
+    buildVoteRequestWithSignature(votes: Hex, signature: {
+        v: number;
+        r: Hex;
+        s: Hex;
+    }): L1TxRequest;
+    /**
+     * Create a transaction to execute a slashing round
+     * @param round - The round number to execute
+     * @param committees - The committees for each epoch in the round
+     * @returns L1 transaction request
+     */
+    buildExecuteRoundRequest(round: bigint, committees: EthAddress[][]): L1TxRequest;
+    /** Returns the last vote emitted for a given round  */
+    getLastVote(round: bigint): Promise<{
+        validator: EthAddress;
+        slashAmount: bigint;
+    }[]>;
+    /**
+     * Listen for VoteCast events
+     * @param callback - Callback function to handle vote cast events
+     * @returns Unwatch function
+     */
+    listenToVoteCast(callback: (args: {
+        round: bigint;
+        proposer: string;
+    }) => void): () => void;
+    /**
+     * Listen for RoundExecuted events
+     * @param callback - Callback function to handle round executed events
+     * @returns Unwatch function
+     */
+    listenToRoundExecuted(callback: (args: {
+        round: bigint;
+        slashCount: bigint;
+        l1BlockHash: Hex;
+    }) => void): () => void;
+}
+/**
+ * Decodes a Buffer containing slash votes back into an array of numbers.
+ * Each vote is represented as a 2-bit value (0, 1, 2, or 3) representing slashing units.
+ * @dev This should live in stdlib next to encodeSlashConsensusVotes but is here since we
+ * do not have a dependency to stdlib from the ethereum package. We need a larger refactor to fix this.
+ * @param buffer - The Buffer containing encoded slash votes
+ * @returns An array of numbers representing the slash votes
+ */
+export declare function decodeSlashConsensusVotes(buffer: Buffer): number[];
+//# sourceMappingURL=tally_slashing_proposer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tally_slashing_proposer.d.ts","sourceRoot":"","sources":["../../src/contracts/tally_slashing_proposer.ts"],"names":[],"mappings":"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"}

package/dest/contracts/tally_slashing_proposer.js

@@ -0,0 +1,313 @@
+import { tryExtractEvent } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { hexToBuffer } from '@aztec/foundation/string';
+import { TallySlashingProposerAbi } from '@aztec/l1-artifacts/TallySlashingProposerAbi';
+import { encodeFunctionData, getContract } from 'viem';
+/**
+ * Wrapper around the TallySlashingProposer contract that provides
+ * a TypeScript interface for interacting with the consensus-based slashing system.
+ */ export class TallySlashingProposerContract {
+    client;
+    contract;
+    type;
+    constructor(client, address){
+        this.client = client;
+        this.type = 'tally';
+        this.contract = getContract({
+            address: typeof address === 'string' ? address : address.toString(),
+            abi: TallySlashingProposerAbi,
+            client
+        });
+    }
+    get address() {
+        return EthAddress.fromString(this.contract.address);
+    }
+    getQuorumSize() {
+        return this.contract.read.QUORUM();
+    }
+    getRoundSize() {
+        return this.contract.read.ROUND_SIZE();
+    }
+    getCommitteeSize() {
+        return this.contract.read.COMMITTEE_SIZE();
+    }
+    getRoundSizeInEpochs() {
+        return this.contract.read.ROUND_SIZE_IN_EPOCHS();
+    }
+    getLifetimeInRounds() {
+        return this.contract.read.LIFETIME_IN_ROUNDS();
+    }
+    getExecutionDelayInRounds() {
+        return this.contract.read.EXECUTION_DELAY_IN_ROUNDS();
+    }
+    getSlashingAmounts() {
+        return Promise.all([
+            this.contract.read.SLASH_AMOUNT_SMALL(),
+            this.contract.read.SLASH_AMOUNT_MEDIUM(),
+            this.contract.read.SLASH_AMOUNT_LARGE()
+        ]);
+    }
+    getSlashOffsetInRounds() {
+        return this.contract.read.SLASH_OFFSET_IN_ROUNDS();
+    }
+    getCurrentRound() {
+        return this.contract.read.getCurrentRound();
+    }
+    /**
+   * Get round information
+   * @param round - The round number to query
+   * @returns Round status information
+   */ async getRound(round) {
+        const [isExecuted, voteCount] = await this.contract.read.getRound([
+            round
+        ]);
+        return {
+            isExecuted,
+            voteCount
+        };
+    }
+    /**
+   * Check if a round is ready to execute at a given slot
+   * @param round - The round number to check
+   * @param slot - The slot number to check at
+   * @returns Whether the round is ready to execute
+   */ async isRoundReadyToExecute(round, slot) {
+        return await this.contract.read.isRoundReadyToExecute([
+            round,
+            slot
+        ]);
+    }
+    /** Returns the slash actions and payload address for a given round (zero if no slash actions) */ async getPayload(round) {
+        const { result: committees } = await this.contract.simulate.getSlashTargetCommittees([
+            round
+        ]);
+        const tally = await this.contract.read.getTally([
+            round,
+            committees
+        ]);
+        const address = await this.contract.read.getPayloadAddress([
+            round,
+            tally
+        ]);
+        const actions = this.mapSlashActions(tally);
+        return {
+            actions,
+            address: EthAddress.fromString(address)
+        };
+    }
+    /** Returns the slash actions to be executed for a given round based on votes */ async getTally(round) {
+        const { result: committees } = await this.contract.simulate.getSlashTargetCommittees([
+            round
+        ]);
+        const tally = await this.contract.read.getTally([
+            round,
+            committees
+        ]);
+        return {
+            actions: this.mapSlashActions(tally),
+            committees: committees.map((c)=>c.map(EthAddress.fromString))
+        };
+    }
+    mapSlashActions(actions) {
+        return actions.map(({ validator, slashAmount })=>({
+                validator: EthAddress.fromString(validator),
+                slashAmount
+            }));
+    }
+    /** Tries to extract a VoteCast event from the given logs. */ tryExtractVoteCastEvent(logs) {
+        return tryExtractEvent(logs, this.address.toString(), TallySlashingProposerAbi, 'VoteCast');
+    }
+    /** Tries to extract a RoundExecuted event from the given logs. */ tryExtractRoundExecutedEvent(logs) {
+        return tryExtractEvent(logs, this.address.toString(), TallySlashingProposerAbi, 'RoundExecuted');
+    }
+    /**
+   * Create a transaction to vote for slashing offenses
+   * @param votes - The encoded votes for slashing
+   * @param slot - The slot number for the vote
+   * @param signer - The signer to produce the signature
+   * @returns L1 transaction request
+   */ async buildVoteRequestFromSigner(votes, slot, signer) {
+        const typedData = this.buildVoteTypedData(votes, slot);
+        const signature = Signature.fromString(await signer(typedData));
+        return {
+            to: this.contract.address,
+            data: encodeFunctionData({
+                abi: TallySlashingProposerAbi,
+                functionName: 'vote',
+                args: [
+                    votes,
+                    signature.toViemSignature()
+                ]
+            })
+        };
+    }
+    /** Returns the typed data definition to EIP712-sign for voting */ buildVoteTypedData(votes, slot) {
+        const domain = {
+            name: 'TallySlashingProposer',
+            version: '1',
+            chainId: this.client.chain.id,
+            verifyingContract: this.contract.address
+        };
+        const types = {
+            EIP712Domain: [
+                {
+                    name: 'name',
+                    type: 'string'
+                },
+                {
+                    name: 'version',
+                    type: 'string'
+                },
+                {
+                    name: 'chainId',
+                    type: 'uint256'
+                },
+                {
+                    name: 'verifyingContract',
+                    type: 'address'
+                }
+            ],
+            Vote: [
+                {
+                    name: 'votes',
+                    type: 'bytes'
+                },
+                {
+                    name: 'slot',
+                    type: 'uint256'
+                }
+            ]
+        };
+        return {
+            domain,
+            types,
+            primaryType: 'Vote',
+            message: {
+                votes,
+                slot
+            }
+        };
+    }
+    /** Gets the digest to sign for voting directly from the contract */ async getVoteDataDigest(votes, slot) {
+        return Buffer32.fromString(await this.contract.read.getVoteSignatureDigest([
+            votes,
+            slot
+        ]));
+    }
+    /**
+   * Create a transaction to vote for slashing offenses
+   * @param votes - The encoded votes for slashing
+   * @param signature - The signature from the current proposer
+   * @returns L1 transaction request
+   */ buildVoteRequestWithSignature(votes, signature) {
+        return {
+            to: this.contract.address,
+            data: encodeFunctionData({
+                abi: TallySlashingProposerAbi,
+                functionName: 'vote',
+                args: [
+                    votes,
+                    signature
+                ]
+            })
+        };
+    }
+    /**
+   * Create a transaction to execute a slashing round
+   * @param round - The round number to execute
+   * @param committees - The committees for each epoch in the round
+   * @returns L1 transaction request
+   */ buildExecuteRoundRequest(round, committees) {
+        return {
+            to: this.contract.address,
+            data: encodeFunctionData({
+                abi: TallySlashingProposerAbi,
+                functionName: 'executeRound',
+                args: [
+                    round,
+                    committees.map((c)=>c.map((addr)=>addr.toString()))
+                ]
+            })
+        };
+    }
+    /** Returns the last vote emitted for a given round  */ async getLastVote(round) {
+        const { voteCount } = await this.getRound(round);
+        const validators = (await this.contract.simulate.getSlashTargetCommittees([
+            round
+        ])).result.flat();
+        const vote = await this.contract.read.getVotes([
+            round,
+            voteCount - 1n
+        ]);
+        const decoded = decodeSlashConsensusVotes(hexToBuffer(vote));
+        const slashAmounts = await this.getSlashingAmounts();
+        return decoded.map((units, i)=>({
+                validator: EthAddress.fromString(validators[i]),
+                slashAmount: slashAmounts[units - 1] ?? 0n
+            })).filter((v)=>v.slashAmount > 0n);
+    }
+    /**
+   * Listen for VoteCast events
+   * @param callback - Callback function to handle vote cast events
+   * @returns Unwatch function
+   */ listenToVoteCast(callback) {
+        return this.contract.watchEvent.VoteCast({}, {
+            onLogs: (logs)=>{
+                for (const log of logs){
+                    const { round, proposer } = log.args;
+                    if (round !== undefined && proposer) {
+                        callback({
+                            round,
+                            proposer
+                        });
+                    }
+                }
+            }
+        });
+    }
+    /**
+   * Listen for RoundExecuted events
+   * @param callback - Callback function to handle round executed events
+   * @returns Unwatch function
+   */ listenToRoundExecuted(callback) {
+        return this.contract.watchEvent.RoundExecuted({}, {
+            onLogs: (logs)=>{
+                for (const log of logs){
+                    const { round, slashCount } = log.args;
+                    if (round !== undefined && slashCount !== undefined) {
+                        callback({
+                            round,
+                            slashCount,
+                            l1BlockHash: log.blockHash
+                        });
+                    }
+                }
+            }
+        });
+    }
+}
+/**
+ * Decodes a Buffer containing slash votes back into an array of numbers.
+ * Each vote is represented as a 2-bit value (0, 1, 2, or 3) representing slashing units.
+ * @dev This should live in stdlib next to encodeSlashConsensusVotes but is here since we
+ * do not have a dependency to stdlib from the ethereum package. We need a larger refactor to fix this.
+ * @param buffer - The Buffer containing encoded slash votes
+ * @returns An array of numbers representing the slash votes
+ */ export function decodeSlashConsensusVotes(buffer) {
+    const votes = [];
+    for(let i = 0; i < buffer.length; i++){
+        const voteByte = buffer.readUInt8(i);
+        // Decode votes from Solidity's bit order (LSB to MSB)
+        // Bits 0-1: validator at index i*4
+        // Bits 2-3: validator at index i*4+1
+        // Bits 4-5: validator at index i*4+2
+        // Bits 6-7: validator at index i*4+3
+        votes.push(voteByte >> 0 & 0x03);
+        votes.push(voteByte >> 2 & 0x03);
+        votes.push(voteByte >> 4 & 0x03);
+        votes.push(voteByte >> 6 & 0x03);
+    }
+    return votes;
+}

package/dest/contracts/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ViemClient } from '../types.js';
+export declare function checkBlockTag(block: bigint | undefined, publicClient: ViemClient): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/contracts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,UAAU,iBAQtF"}

package/dest/contracts/utils.js

@@ -0,0 +1,11 @@
+import { BlockTagTooOldError } from './errors.js';
+const L1_NON_ARCHIVE_BLOCK_HISTORY_LENGTH = 128n;
+export async function checkBlockTag(block, publicClient) {
+    if (block === undefined) {
+        return;
+    }
+    const latestBlock = await publicClient.getBlockNumber();
+    if (block < latestBlock - L1_NON_ARCHIVE_BLOCK_HISTORY_LENGTH) {
+        throw new BlockTagTooOldError(block, latestBlock);
+    }
+}