@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/contract/utility_function_membership_proof.ts

@@ -1,118 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
-
-import { type ContractArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
-import {
-  computeArtifactFunctionTree,
-  computeArtifactHash,
-  computeArtifactHashPreimage,
-  computeFunctionArtifactHash,
-  computeFunctionMetadataHash,
-  getArtifactMerkleTreeHasher,
-} from './artifact_hash.js';
-import type {
-  ContractClassPublic,
-  UtilityFunctionMembershipProof,
-  UtilityFunctionWithMembershipProof,
-} from './interfaces/index.js';
-
-/**
- * Creates a membership proof for a utility  function in a contract class, to be verified via `isValidUtilityFunctionMembershipProof`.
- * @param selector - Selector of the function to create the proof for.
- * @param artifact - Artifact of the contract class where the function is defined.
- */
-export async function createUtilityFunctionMembershipProof(
-  selector: FunctionSelector,
-  artifact: ContractArtifact,
-): Promise<UtilityFunctionMembershipProof> {
-  const log = createLogger('circuits:function_membership_proof');
-
-  // Locate function artifact
-  const utilityFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UTILITY);
-  const utilityFunctionsAndSelectors = await Promise.all(
-    utilityFunctions.map(async fn => ({ fn, selector: await FunctionSelector.fromNameAndParameters(fn) })),
-  );
-  const fn = utilityFunctionsAndSelectors.find(fnAndSelector => selector.equals(fnAndSelector.selector))?.fn;
-  if (!fn) {
-    throw new Error(`Utility function with selector ${selector.toString()} not found`);
-  }
-  // Compute preimage for the artifact hash
-  const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } =
-    await computeArtifactHashPreimage(artifact);
-
-  // Compute the sibling path for the "artifact tree"
-  const functionMetadataHash = computeFunctionMetadataHash(fn);
-  const functionArtifactHash = await computeFunctionArtifactHash({ ...fn, functionMetadataHash });
-  const artifactTree = (await computeArtifactFunctionTree(artifact, FunctionType.UTILITY))!;
-  const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
-  const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
-
-  log.debug(`Computed proof for utility function with selector ${selector.toString()}`, {
-    functionArtifactHash,
-    functionMetadataHash,
-    artifactMetadataHash,
-    artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    privateFunctionsArtifactTreeRoot,
-  });
-
-  return {
-    artifactTreeSiblingPath,
-    artifactTreeLeafIndex,
-    artifactMetadataHash,
-    functionMetadataHash,
-    privateFunctionsArtifactTreeRoot,
-  };
-}
-
-/**
- * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
- * as defined in the protocol specs at contract-deployment/classes:
- *
- * ```
- * // Load contract class from local db
- * contract_class = db.get_contract_class(contract_class_id)
- *
- * // Compute artifact leaf and assert it belongs to the artifact
- * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
- * computed_artifact_utility_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
- * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_utility_function_tree_root, artifact_metadata_hash)
- * assert computed_artifact_hash == contract_class.artifact_hash
- * ```
- * @param fn - Function to check membership proof for.
- * @param contractClass - In which contract class the function is expected to be.
- */
-export async function isValidUtilityFunctionMembershipProof(
-  fn: UtilityFunctionWithMembershipProof,
-  contractClass: Pick<ContractClassPublic, 'artifactHash'>,
-) {
-  const log = createLogger('circuits:function_membership_proof');
-
-  const functionArtifactHash = await computeFunctionArtifactHash(fn);
-  const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(
-    functionArtifactHash.toBuffer(),
-    fn.artifactTreeSiblingPath.map(fr => fr.toBuffer()),
-    fn.artifactTreeLeafIndex,
-    getArtifactMerkleTreeHasher(),
-  );
-  const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
-  const computedArtifactHash = await computeArtifactHash({
-    privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
-    utilityFunctionRoot: computedArtifactFunctionTreeRoot,
-    metadataHash: fn.artifactMetadataHash,
-  });
-  if (!contractClass.artifactHash.equals(computedArtifactHash)) {
-    log.debug(`Artifact hash mismatch`, {
-      expected: contractClass.artifactHash,
-      computedArtifactHash,
-      computedFunctionArtifactHash: functionArtifactHash,
-      computedArtifactFunctionTreeRoot,
-      privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
-      metadataHash: fn.artifactMetadataHash,
-      artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map(fr => fr.toString()).join(','),
-    });
-    return false;
-  }
-
-  return true;
-}

package/src/database-version/index.ts

@@ -1 +0,0 @@
-export * from './version_manager.js';

package/src/interfaces/epoch-prover.ts

@@ -1,73 +0,0 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
-
-import type { Proof } from '../proofs/proof.js';
-import type { CheckpointConstantData } from '../rollup/checkpoint_constant_data.js';
-import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
-import type { BlockHeader } from '../tx/block_header.js';
-import type { Tx } from '../tx/tx.js';
-import type { UInt64 } from '../types/index.js';
-import type { IBlockFactory } from './block-builder.js';
-
-/** Coordinates the proving of an entire epoch. */
-export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | 'startNewBlock'> {
-  /**
-   * Starts a new epoch. Must be the first method to be called.
-   * @param epochNumber - The epoch number.
-   * @param totalNumCheckpoints - The total number of checkpoints expected in the epoch (must be at least one).
-   * @param finalBlobBatchingChallenges - The final blob batching challenges for the epoch.
-   **/
-  startNewEpoch(
-    epochNumber: number,
-    totalNumCheckpoints: number,
-    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
-  ): void;
-
-  /**
-   * Starts a new checkpoint.
-   * @param checkpointIndex - The index of the checkpoint in the epoch.
-   * @param constants - The constants for this checkpoint.
-   * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this checkpoint.
-   * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
-   * @param totalNumBlobFields - The total number of blob fields expected in the checkpoint.
-   * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
-   */
-  startNewCheckpoint(
-    checkpointIndex: number,
-    constants: CheckpointConstantData,
-    l1ToL2Messages: Fr[],
-    totalNumBlocks: number,
-    totalNumBlobFields: number,
-    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
-  ): Promise<void>;
-
-  /**
-   * Starts a new block.
-   * @param blockNumber - The block number.
-   * @param timestamp - The timestamp of the block.
-   * @param totalNumTxs - The total number of txs in the block.
-   */
-  startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void>;
-
-  /**
-   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the chonk verifier circuits are not started this way, they will be started nonetheless after processing.
-   */
-  startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
-
-  /** Returns the block. */
-  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;
-
-  /** Pads the epoch with empty block roots if needed and blocks until proven. Throws if proving has failed. */
-  finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }>;
-
-  /** Cancels all proving jobs. */
-  cancel(): void;
-
-  /** Returns an identifier for the prover or zero if not set. */
-  getProverId(): EthAddress;
-
-  /** Called when no longer required, cleans up internal resources */
-  stop(): Promise<void>;
-}

package/src/interfaces/get_logs_response.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-
-import { ExtendedContractClassLog } from '../logs/extended_contract_class_log.js';
-import { ExtendedPublicLog } from '../logs/extended_public_log.js';
-import type { ZodFor } from '../schemas/index.js';
-
-/** Response for the getContractClassLogs archiver call. */
-export type GetContractClassLogsResponse = {
-  /** An array of ExtendedContractClassLog elements. */
-  logs: ExtendedContractClassLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetContractClassLogsResponseSchema: ZodFor<GetContractClassLogsResponse> = z.object({
-  logs: z.array(ExtendedContractClassLog.schema),
-  maxLogsHit: z.boolean(),
-});
-
-/** Response for the getPublicLogs archiver call. */
-export type GetPublicLogsResponse = {
-  /** An array of ExtendedPublicLog elements. */
-  logs: ExtendedPublicLog[];
-  /** Indicates if a limit has been reached. */
-  maxLogsHit: boolean;
-};
-
-export const GetPublicLogsResponseSchema = z.object({
-  logs: z.array(ExtendedPublicLog.schema),
-  maxLogsHit: z.boolean(),
-}) satisfies ZodFor<GetPublicLogsResponse>;

package/src/interfaces/prover-coordination.ts

@@ -1,17 +0,0 @@
-import { Tx } from '../tx/tx.js';
-import { TxHash } from '../tx/tx_hash.js';
-import type { P2PClient } from './p2p.js';
-
-/** Provides basic operations for ProverNodes to interact with other nodes in the network. */
-export interface ProverCoordination {
-  /**
-   * Returns a set of transactions given their hashes if available.
-   * @param txHashes - The hashes of the transactions, used as an ID.
-   * @returns The transactions found, no necessarily in the same order as the hashes.
-   */
-  getTxsByHash(txHashes: TxHash[]): Promise<Tx[]>;
-
-  gatherTxs(txHashes: TxHash[]): Promise<void>;
-
-  getP2PClient(): P2PClient | undefined;
-}

package/src/kernel/hints/key_validation_request_and_generator.ts

@@ -1,52 +0,0 @@
-import { KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { KeyValidationRequest } from './key_validation_request.js';
-
-/**
- * Request for validating keys used in the app and a generator.
- */
-export class KeyValidationRequestAndGenerator {
-  constructor(
-    /** The key validation request. */
-    public readonly request: KeyValidationRequest,
-    /**
-     * The generator index which can be used along with sk_m to derive the sk_app stored in the request.
-     * Note: This generator constrains that a correct key type gets validated in the kernel.
-     */
-    public readonly skAppGenerator: Fr,
-  ) {}
-
-  toBuffer() {
-    return serializeToBuffer(this.request, this.skAppGenerator);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new KeyValidationRequestAndGenerator(reader.readObject(KeyValidationRequest), Fr.fromBuffer(reader));
-  }
-
-  toFields(): Fr[] {
-    const fields = [...this.request.toFields(), this.skAppGenerator];
-    if (fields.length !== KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for KeyValidationRequestAndGenerator. Expected ${KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): KeyValidationRequestAndGenerator {
-    const reader = FieldReader.asReader(fields);
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.fromFields(reader), reader.readField());
-  }
-
-  isEmpty() {
-    return this.request.isEmpty() && this.skAppGenerator.isZero();
-  }
-
-  static empty() {
-    return new KeyValidationRequestAndGenerator(KeyValidationRequest.empty(), Fr.ZERO);
-  }
-}

package/src/kernel/hints/tree_leaf_read_request.ts

@@ -1,35 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-export class TreeLeafReadRequest {
-  constructor(
-    public value: Fr,
-    public leafIndex: Fr,
-  ) {}
-
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.leafIndex);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new TreeLeafReadRequest(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
-  }
-
-  toFields(): Fr[] {
-    return [this.value, this.leafIndex];
-  }
-
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new TreeLeafReadRequest(reader.readField(), reader.readField());
-  }
-
-  isEmpty() {
-    return this.value.isZero() && this.leafIndex.isZero();
-  }
-
-  static empty() {
-    return new TreeLeafReadRequest(Fr.zero(), Fr.zero());
-  }
-}

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

@@ -1,58 +0,0 @@
-import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import type { UInt64 } from '../types/shared.js';
-import { PaddedSideEffectAmounts } from './padded_side_effects.js';
-import { PrivateKernelData } from './private_kernel_data.js';
-
-/**
- * Input to the private kernel circuit - tail call.
- */
-export class PrivateKernelTailCircuitPrivateInputs {
-  constructor(
-    /**
-     * The previous kernel data
-     */
-    public previousKernel: PrivateKernelData,
-    /**
-     * The number of the padded side effects.
-     */
-    public paddedSideEffectAmounts: PaddedSideEffectAmounts,
-    /**
-     * The timestamp by which the transaction must be included in a block.
-     */
-    public includeByTimestampUpperBound: UInt64,
-  ) {}
-
-  isForPublic() {
-    return (
-      this.previousKernel.publicInputs.end.publicCallRequests.claimedLength > 0 ||
-      !this.previousKernel.publicInputs.publicTeardownCallRequest.isEmpty()
-    );
-  }
-
-  /**
-   * Serialize this as a buffer.
-   * @returns The buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(
-      this.previousKernel,
-      this.paddedSideEffectAmounts,
-      bigintToUInt64BE(this.includeByTimestampUpperBound),
-    );
-  }
-
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized instance.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelTailCircuitPrivateInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new PrivateKernelTailCircuitPrivateInputs(
-      reader.readObject(PrivateKernelData),
-      reader.readObject(PaddedSideEffectAmounts),
-      reader.readUInt64(),
-    );
-  }
-}

package/src/kernel/utils/optional_number.ts

@@ -1,50 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-export class OptionalNumber {
-  constructor(
-    /**
-     * Whether a value was set.
-     */
-    public isSome: boolean,
-    /**
-     * The actual number, if isSome is true.
-     */
-    public value: number,
-  ) {}
-
-  getSize() {
-    return this.toBuffer().length;
-  }
-
-  static getFields(fields: FieldsOf<OptionalNumber>) {
-    return [fields.isSome, fields.value] as const;
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...OptionalNumber.getFields(this));
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): OptionalNumber {
-    const reader = BufferReader.asReader(buffer);
-    return new OptionalNumber(reader.readBoolean(), reader.readNumber());
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(...OptionalNumber.getFields(this));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): OptionalNumber {
-    const reader = FieldReader.asReader(fields);
-    return new OptionalNumber(reader.readBoolean(), reader.readU32());
-  }
-
-  isEmpty(): boolean {
-    return !this.isSome && !this.value;
-  }
-
-  static empty() {
-    return new OptionalNumber(false, 0);
-  }
-}

package/src/l1-contracts/slash_factory.ts

@@ -1,177 +0,0 @@
-import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
-import { maxBigint } from '@aztec/foundation/bigint';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
-
-import { type GetContractReturnType, type Hex, type Log, encodeFunctionData, getContract } from 'viem';
-
-import type { L1RollupConstants } from '../epoch-helpers/index.js';
-import {
-  OffenseToBigInt,
-  type SlashPayload,
-  type ValidatorSlash,
-  type ValidatorSlashOffense,
-  bigIntToOffense,
-} from '../slashing/index.js';
-
-export class SlashFactoryContract {
-  private readonly logger = createLogger('contracts:slash_factory');
-  private readonly contract: GetContractReturnType<typeof SlashFactoryAbi, ViemClient>;
-
-  constructor(
-    public readonly client: ViemClient,
-    address: Hex | EthAddress,
-  ) {
-    this.contract = getContract({
-      address: typeof address === 'string' ? address : address.toString(),
-      abi: SlashFactoryAbi,
-      client,
-    });
-  }
-
-  public get address() {
-    return EthAddress.fromString(this.contract.address);
-  }
-
-  public buildCreatePayloadRequest(slashes: ValidatorSlash[]): L1TxRequest {
-    const sorted = this.sortSlashes(slashes);
-
-    return {
-      to: this.contract.address,
-      data: encodeFunctionData({
-        abi: SlashFactoryAbi,
-        functionName: 'createSlashPayload',
-        args: [
-          sorted.map(d => d.validator.toString()),
-          sorted.map(d => d.amount),
-          sorted.map(d => d.offenses.map(packValidatorSlashOffense)),
-        ],
-      }),
-    };
-  }
-
-  /** Tries to extract a SlashPayloadCreated event from the given logs. */
-  public tryExtractSlashPayloadCreatedEvent(logs: Log[]) {
-    return tryExtractEvent(logs, this.address.toString(), SlashFactoryAbi, 'SlashPayloadCreated');
-  }
-
-  public async getSlashPayloadCreatedEvents(): Promise<SlashPayload[]> {
-    const events = await this.contract.getEvents.SlashPayloadCreated();
-    return Promise.all(
-      events.map(async event => {
-        const { validators, amounts, offenses } = event.args;
-        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
-          validator: EthAddress.fromString(validator),
-          amount: amounts![i],
-          offenses: offenses![i].map(unpackValidatorSlashOffense),
-        }));
-
-        const block = await this.client.getBlock({ blockNumber: event.blockNumber, includeTransactions: false });
-        return { address: EthAddress.fromString(event.args.payloadAddress!), slashes, timestamp: block.timestamp };
-      }),
-    );
-  }
-
-  /**
-   * Searches for a slash payload in the events emitted by the contract.
-   * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
-   * @param payloadAddress The address of the payload to search for.
-   * @param constants The L1 rollup constants needed for time calculations.
-   */
-  public async getSlashPayloadFromEvents(
-    payloadAddress: EthAddress,
-    settings: {
-      logsBatchSize?: number;
-      slashingRoundSize: number;
-      slashingPayloadLifetimeInRounds: number;
-    } & Pick<L1RollupConstants, 'slotDuration' | 'ethereumSlotDuration'>,
-  ): Promise<Omit<SlashPayload, 'votes'> | undefined> {
-    // We query for the log where the payload was emitted walking backwards until we go past payload expiration time
-    // Note that all log queries require a block range, and RPC providers cap the max range (eg quicknode is 10k blocks).
-    const { slashingRoundSize, slashingPayloadLifetimeInRounds, slotDuration, ethereumSlotDuration } = settings;
-    const currentBlockNumber = await this.client.getBlockNumber({ cacheTime: 0 });
-
-    // Why the +1 below? Just for good measure. Better err on the safe side.
-    const earliestBlockNumber = maxBigint(
-      0n,
-      currentBlockNumber -
-        ((BigInt(slashingPayloadLifetimeInRounds) + 1n) * BigInt(slashingRoundSize) * BigInt(slotDuration)) /
-          BigInt(ethereumSlotDuration),
-    );
-
-    this.logger.trace(
-      `Starting search for slash payload ${payloadAddress} from block ${currentBlockNumber} with earliest block ${earliestBlockNumber}`,
-    );
-    const batchSize = BigInt(settings.logsBatchSize ?? 10000);
-    let toBlock = currentBlockNumber;
-
-    do {
-      const fromBlock = maxBigint(earliestBlockNumber, toBlock - batchSize);
-      this.logger.trace(`Searching for slash payload ${payloadAddress} in blocks ${fromBlock} to ${toBlock}`);
-      const logs = await this.contract.getEvents.SlashPayloadCreated(
-        { payloadAddress: payloadAddress.toString() },
-        { fromBlock, toBlock, strict: true },
-      );
-
-      // We found the payload, return it
-      if (logs.length > 0) {
-        const log = logs[0];
-        const { validators, amounts, offenses } = log.args;
-
-        // Convert the data to our internal types
-        const slashes: ValidatorSlash[] = validators!.map((validator, i) => ({
-          validator: EthAddress.fromString(validator),
-          amount: amounts![i],
-          offenses: offenses![i].map(unpackValidatorSlashOffense),
-        }));
-
-        // Get the timestamp from the block
-        const block = await this.client.getBlock({ blockNumber: log.blockNumber, includeTransactions: false });
-
-        return { address: payloadAddress, slashes, timestamp: block.timestamp };
-      }
-
-      // If not found, we go back one batch
-      toBlock -= batchSize;
-    } while (toBlock > earliestBlockNumber);
-
-    return undefined;
-  }
-
-  public async getAddressAndIsDeployed(
-    slashes: ValidatorSlash[],
-  ): Promise<{ address: EthAddress; salt: Hex; isDeployed: boolean }> {
-    const sortedSlashes = this.sortSlashes(slashes);
-    const [address, salt, isDeployed] = await this.contract.read.getAddressAndIsDeployed([
-      sortedSlashes.map(s => s.validator.toString()),
-      sortedSlashes.map(s => s.amount),
-      sortedSlashes.map(s => s.offenses.map(packValidatorSlashOffense)),
-    ]);
-    return { address: EthAddress.fromString(address), salt, isDeployed };
-  }
-
-  private sortSlashes(slashes: ValidatorSlash[]): ValidatorSlash[] {
-    const offenseSorter = (a: ValidatorSlashOffense, b: ValidatorSlashOffense) => {
-      return a.epochOrSlot === b.epochOrSlot ? a.offenseType - b.offenseType : Number(a.epochOrSlot - b.epochOrSlot);
-    };
-    return [...slashes]
-      .map(slash => ({ ...slash, offenses: [...slash.offenses].sort(offenseSorter) }))
-      .sort((a, b) => a.validator.toString().localeCompare(b.validator.toString()));
-  }
-}
-
-export function packValidatorSlashOffense(offense: ValidatorSlashOffense): bigint {
-  const offenseId = OffenseToBigInt[offense.offenseType];
-  if (offenseId > (1 << 8) - 1) {
-    throw new Error(`Offense type ${offense.offenseType} cannot be packed into 8 bits`);
-  }
-  return (offenseId << 120n) + offense.epochOrSlot;
-}
-
-export function unpackValidatorSlashOffense(packed: bigint): ValidatorSlashOffense {
-  const offenseId = (packed >> 120n) & 0xffn;
-  const epochOrSlot = packed & ((1n << 120n) - 1n);
-  const offenseType = bigIntToOffense(offenseId);
-  return { epochOrSlot, offenseType };
-}