@lodestar/native 0.0.0-stage → 1.51.0-dev.8d8efcbf5f

package/src/execution-proof-verifier.js

@@ -0,0 +1,17 @@
+import bindings from "./bindings.js";
+
+const executionProofVerifier = bindings.executionProofVerifier;
+
+/** @type {typeof import("./execution-proof-verifier.d.ts").ZKVM_KIND} */
+export const ZKVM_KIND = executionProofVerifier.ZkvmKind;
+
+export const EXECUTION_PROOF_VERIFIER_AVAILABLE = executionProofVerifier.available;
+export const EXECUTION_PROOF_MAX_SIZE = executionProofVerifier.MAX_PROOF_SIZE;
+
+export const registerExecutionProofVerifier = executionProofVerifier.register;
+export const hasExecutionProofVerifier = executionProofVerifier.has;
+
+/** @type {typeof import("./execution-proof-verifier.d.ts").verifyExecutionProof} */
+export async function verifyExecutionProof(proofType, proofData) {
+  return executionProofVerifier.verify(proofType, proofData);
+}

package/src/index.d.ts

@@ -0,0 +1,513 @@
+// biome-ignore-all lint/style/useNamingConvention: spec-canonical fork names in `ForkName`
+
+interface BeaconBlockHeader {
+  slot: number;
+  proposerIndex: number;
+  parentRoot: Uint8Array;
+  stateRoot: Uint8Array;
+  bodyRoot: Uint8Array;
+}
+
+interface Checkpoint {
+  epoch: number;
+  root: Uint8Array;
+}
+
+export interface VoluntaryExit {
+  epoch: number;
+  validatorIndex: number;
+}
+
+export interface SignedVoluntaryExit {
+  message: VoluntaryExit;
+  signature: Uint8Array;
+}
+
+interface Eth1Data {
+  depositRoot: Uint8Array;
+  depositCount: bigint;
+  blockHash: Uint8Array;
+}
+
+interface ExecutionPayloadHeader {
+  parentHash: Uint8Array;
+  feeRecipient: Uint8Array;
+  stateRoot: Uint8Array;
+  receiptsRoot: Uint8Array;
+  logsBloom: Uint8Array;
+  prevRandao: Uint8Array;
+  blockNumber: number;
+  gasLimit: number;
+  gasUsed: number;
+  timestamp: number;
+  extraData: Uint8Array;
+  baseFeePerGas: bigint;
+  blockHash: Uint8Array;
+  transactionsRoot: Uint8Array;
+  withdrawalsRoot?: Uint8Array; // capella+
+  blobGasUsed?: bigint; // deneb+
+  excessBlobGas?: bigint; // deneb+
+}
+
+export interface ExecutionPayloadBid {
+  parentBlockHash: Uint8Array;
+  parentBlockRoot: Uint8Array;
+  blockHash: Uint8Array;
+  prevRandao: Uint8Array;
+  feeRecipient: Uint8Array;
+  gasLimit: bigint;
+  builderIndex: number;
+  slot: number;
+  value: number;
+  executionPayment: bigint;
+  blobKzgCommitments: Uint8Array[];
+  executionRequestsRoot: Uint8Array;
+}
+
+export interface HezeExecutionPayloadBid extends ExecutionPayloadBid {
+  inclusionListBits: {uint8Array: Uint8Array; bitLen: number};
+}
+
+export interface Builder {
+  pubkey: Uint8Array;
+  version: number;
+  executionAddress: Uint8Array;
+  balance: number;
+  depositEpoch: number;
+  withdrawableEpoch: number;
+}
+
+export interface BuilderPendingWithdrawal {
+  feeRecipient: Uint8Array;
+  amount: number;
+  builderIndex: number;
+}
+
+export interface BuilderPendingPayment {
+  weight: number;
+  withdrawal: BuilderPendingWithdrawal;
+  proposerIndex: number;
+}
+
+export interface Withdrawal {
+  index: number;
+  validatorIndex: number;
+  address: Uint8Array;
+  amount: bigint;
+}
+
+/*
+ * We don't need *all* the fields to check if a block
+ * is a pre-merge or a merge transition block, so we just
+ * have a minimum interface that is like a `BeaconBlock`.
+ */
+interface BeaconBlockLike {
+  body: {
+    randaoReveal: Uint8Array;
+    executionPayload?: {
+      parentHash: Uint8Array;
+      feeRecipient: Uint8Array;
+      stateRoot: Uint8Array;
+      receiptsRoot: Uint8Array;
+      logsBloom: Uint8Array;
+      prevRandao: Uint8Array;
+      blockNumber: number;
+      gasLimit: number;
+      gasUsed: number;
+      timestamp: number;
+      extraData: Uint8Array;
+      baseFeePerGas: bigint;
+      blockHash: Uint8Array;
+      transactions: {readonly length: number};
+    };
+    executionPayloadHeader?: ExecutionPayloadHeader;
+  };
+}
+
+interface Fork {
+  previousVersion: Uint8Array;
+  currentVersion: Uint8Array;
+  epoch: number;
+}
+
+export enum ForkName {
+  phase0 = "phase0",
+  altair = "altair",
+  bellatrix = "bellatrix",
+  capella = "capella",
+  deneb = "deneb",
+  electra = "electra",
+  fulu = "fulu",
+  gloas = "gloas",
+  heze = "heze",
+}
+
+export enum ForkSeq {
+  phase0 = 0,
+  altair = 1,
+  bellatrix = 2,
+  capella = 3,
+  deneb = 4,
+  electra = 5,
+  fulu = 6,
+  gloas = 7,
+  heze = 8,
+}
+
+interface SyncCommittee {
+  pubkeys: Uint8Array[];
+  aggregatePubkey: Uint8Array;
+}
+
+export interface ProcessSlotsOpts {
+  /** Default: false (cache is transferred). Set to true to opt out of cache transfer. */
+  dontTransferCache?: boolean;
+}
+
+interface CompactMultiProof {
+  // biome-ignore lint/suspicious/noExplicitAny: native returns string literal "compactMulti", IBeaconStateView uses @chainsafe/persistent-merkle-tree's ProofType
+  // TODO(bing): align types?
+  type: any;
+  leaves: Uint8Array[];
+  descriptor: Uint8Array;
+}
+
+/**
+ * Options to control how state transition is run.
+ */
+export interface TransitionOpts {
+  /** Verify the post-state root matches the block's state root. Default: true. */
+  verifyStateRoot?: boolean;
+  /** Verify the proposer signature on the signed block. Default: true. */
+  verifyProposer?: boolean;
+  /** Verify BLS signatures during block processing. Default: true. */
+  verifySignatures?: boolean;
+  /** Default: false (cache is transferred). Set to true to opt out of cache transfer. */
+  dontTransferCache?: boolean;
+  /** Execution engine result for payload validation. Default: "valid". */
+  executionPayloadStatus?: "valid" | "invalid" | "preMerge";
+  /** Data availability result; Gloas beacon blocks use "NotRequired". Default: "Available". */
+  dataAvailabilityStatus?: "Available" | "PreData" | "OutOfRange" | "NotRequired";
+  /** Source of block processing for the process-block timing metric. Default: "block". */
+  source?: "block" | "regen" | "get_historical_state";
+}
+
+interface ProposerRewards {
+  attestations: number;
+  syncAggregate: number;
+  slashing: number;
+}
+
+interface BlockRewards {
+  proposerIndex: number;
+  total: number;
+  attestations: number;
+  syncAggregate: number;
+  proposerSlashings: number;
+  attesterSlashings: number;
+}
+
+interface SyncCommitteeCache {
+  validatorIndices: Uint32Array;
+  validatorIndexMap: Map<number, number[]>;
+}
+
+interface EpochShuffling {
+  epoch: number;
+  activeIndices: Uint32Array;
+  shuffling: Uint32Array;
+  /** committees[slotInEpoch][committeeIndex] -> validator indices */
+  committees: Uint32Array[][];
+  committeesPerSlot: number;
+}
+
+interface HistoricalSummary {
+  blockSummaryRoot: Uint8Array;
+  stateSummaryRoot: Uint8Array;
+}
+
+interface Validator {
+  pubkey: Uint8Array;
+  withdrawalCredentials: Uint8Array;
+  effectiveBalance: number;
+  slashed: boolean;
+  activationEligibilityEpoch: number;
+  activationEpoch: number;
+  exitEpoch: number;
+  withdrawableEpoch: number;
+}
+
+type ValidatorStatus =
+  | "pending_initialized"
+  | "pending_queued"
+  | "active_ongoing"
+  | "active_exiting"
+  | "active_slashed"
+  | "exited_unslashed"
+  | "exited_slashed"
+  | "withdrawal_possible"
+  | "withdrawal_done";
+
+export type VoluntaryExitValidity =
+  | "valid"
+  | "inactive"
+  | "already_exited"
+  | "early_epoch"
+  | "short_time_active"
+  | "pending_withdrawals"
+  | "invalid_signature";
+
+export declare class BeaconStateView {
+  /** Requires state bytes with trusted provenance; SSZ decoding does not authenticate them. */
+  static createFromBytes(bytes: Uint8Array, config: BeaconConfig): BeaconStateView;
+
+  /**
+   * Idempotently release this view. Subsequent state access throws InvalidState.
+   * An already-running native call retains its resources until that call returns.
+   */
+  release(): void;
+  slot: number;
+  fork: Fork;
+  forkName: ForkName;
+  forkSeq: ForkSeq;
+  epoch: number;
+  genesisTime: number;
+  genesisValidatorsRoot: Uint8Array;
+  /** Throws on Heze and later, where legacy deposit fields are removed. */
+  eth1Data: Eth1Data;
+  latestBlockHeader: BeaconBlockHeader;
+  previousJustifiedCheckpoint: Checkpoint;
+  currentJustifiedCheckpoint: Checkpoint;
+  finalizedCheckpoint: Checkpoint;
+  getBlockRoot(epoch: number): Uint8Array;
+  getBlockRootAtSlot(slot: number): Uint8Array;
+  getBlockRootAtEpoch(epoch: number): Uint8Array;
+  getStateRootAtSlot(slot: number): Uint8Array;
+  getRandaoMix(epoch: number): Uint8Array;
+  previousEpochParticipation: Uint8Array;
+  currentEpochParticipation: Uint8Array;
+  getPreviousEpochParticipation(index: number): number;
+  getCurrentEpochParticipation(index: number): number;
+  latestExecutionPayloadHeader: ExecutionPayloadHeader;
+  payloadBlockNumber: number;
+  historicalSummaries: HistoricalSummary[];
+  pendingDeposits: Uint8Array;
+  pendingDepositsCount: number;
+  pendingPartialWithdrawals: Uint8Array;
+  pendingPartialWithdrawalsCount: number;
+  pendingConsolidations: Uint8Array;
+  pendingConsolidationsCount: number;
+  proposerLookahead: Uint32Array;
+  // Gloas fields throw when called on an earlier fork.
+  latestBlockHash: Uint8Array;
+  executionPayloadAvailability: {uint8Array: Uint8Array; bitLen: number};
+  latestExecutionPayloadBid: ExecutionPayloadBid | HezeExecutionPayloadBid;
+  payloadExpectedWithdrawals: Withdrawal[];
+  builderPendingPayments: BuilderPendingPayment[];
+  builderPendingWithdrawals: BuilderPendingWithdrawal[];
+  getBuilder(index: number): Builder;
+  canBuilderCoverBid(builderIndex: number, bidAmount: number): boolean;
+  getEpochPTCs(epoch: number): Uint32Array[];
+  getPayloadTimelinessCommittee(slot: number): Uint32Array;
+  getInclusionListCommittee(slot: number): Uint32Array;
+  getIndicesInPayloadTimelinessCommittee(validatorIndex: number, slot: number): number[];
+  /** Clone this view and apply serialized Gloas ExecutionRequests from the full parent. */
+  withParentPayloadApplied(executionRequestsBytes: Uint8Array): BeaconStateView;
+
+  getShufflingAtEpoch(epoch: number): EpochShuffling;
+  getPreviousShuffling(): EpochShuffling;
+  getCurrentShuffling(): EpochShuffling;
+  getNextShuffling(): EpochShuffling;
+  getBeaconCommittee(slot: number, index: number): Uint32Array;
+  getBeaconCommitteeCountPerSlot(epoch: number): number;
+  previousDecisionRoot: string;
+  currentDecisionRoot: string;
+  nextDecisionRoot: string;
+  getShufflingDecisionRoot(epoch: number): string;
+  previousProposers: number[] | null;
+  currentProposers: number[];
+  nextProposers: number[];
+  getBeaconProposer(slot: number): number;
+  getBeaconProposerOrNull(slot: number): number | null;
+  currentSyncCommittee: SyncCommittee;
+  nextSyncCommittee: SyncCommittee;
+  currentSyncCommitteeIndexed: SyncCommitteeCache;
+  /** Returns an owned copy in committee order, including repeated validators. */
+  readonly currentSyncCommitteeValidatorIndices: Uint32Array;
+  syncProposerReward: number;
+  getIndexedSyncCommitteeAtEpoch(epoch: number): SyncCommitteeCache;
+  getIndexedSyncCommittee(slot: number): SyncCommitteeCache;
+
+  effectiveBalanceIncrements: Uint16Array;
+  getEffectiveBalanceIncrementsZeroInactive(): Uint16Array;
+  getBalance(index: number): number;
+  getValidator(index: number): Validator;
+  getAllValidators(): Validator[];
+  getBuildersLength(): number;
+  getAllBalances(): number[];
+  getValidatorsByStatus(statuses: Set<string>, currentEpoch: number): Validator[];
+  // TODO wrong function
+  getValidatorStatus(index: number): ValidatorStatus;
+  validatorCount: number;
+  activeValidatorCount: number;
+
+  isExecutionStateType: boolean;
+  isMergeTransitionComplete: boolean;
+  /**
+   * Check whether execution is enabled for the given block at this state.
+   *
+   * For normal post-merge operation this short-circuits from state alone and does
+   * not inspect `block`. The block object is only read for the historical pre-merge
+   * Bellatrix case, where execution is enabled iff the block carries the first
+   * non-default execution payload.
+   */
+  isExecutionEnabled(block: BeaconBlockLike): boolean;
+
+  proposerRewards: ProposerRewards;
+  computeBlockRewards(
+    signedBlockBytes: Uint8Array,
+    isBlinded: boolean,
+    proposerRewards?: ProposerRewards
+  ): BlockRewards;
+  computeAttestationsRewards(validatorIds?: (number | string)[]): AttestationsRewards;
+  computeSyncCommitteeRewards(
+    block: SyncCommitteeRewardsBlock,
+    validatorIds?: (number | string)[]
+  ): SyncCommitteeReward[];
+  getLatestWeakSubjectivityCheckpointEpoch(): number;
+
+  getVoluntaryExitValidity(signedVoluntaryExit: SignedVoluntaryExit, verifySignature: boolean): VoluntaryExitValidity;
+  isValidVoluntaryExit(signedVoluntaryExit: SignedVoluntaryExit, verifySignature: boolean): boolean;
+
+  getFinalizedRootProof(): Uint8Array[];
+  getSyncCommitteesWitness(): {
+    /** Shared witness before Gloas; empty when separate committee branches are returned. */
+    witness: Uint8Array[];
+    currentSyncCommitteeRoot: Uint8Array;
+    nextSyncCommitteeRoot: Uint8Array;
+    currentSyncCommitteeBranch?: Uint8Array[];
+    nextSyncCommitteeBranch?: Uint8Array[];
+  };
+  getSingleProof(gindex: bigint): Uint8Array[];
+  /**
+   * Compute expected withdrawals for the next payload (capella+).
+   *
+   * processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas
+   * processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+   * processedBuildersSweepCount is withdrawals from builder sweep since gloas
+   * processedValidatorSweepCount is withdrawals coming from validator sweep
+
+   */
+  getExpectedWithdrawals(): {
+    expectedWithdrawals: Withdrawal[];
+    processedBuilderWithdrawalsCount: number;
+    processedPartialWithdrawalsCount: number;
+    processedBuildersSweepCount: number;
+    processedValidatorSweepCount: number;
+  };
+
+  /** On phase0, serialize this call with other STF operations and cache teardown within this thread. */
+  computeUnrealizedCheckpoints(): {
+    justifiedCheckpoint: Checkpoint;
+    finalizedCheckpoint: Checkpoint;
+  };
+  computeAnchorCheckpoint(): {
+    checkpoint: Checkpoint;
+    blockHeader: BeaconBlockHeader;
+  };
+
+  clonedCount: number;
+  clonedCountWithTransferCache: number;
+  createdWithTransferCache: boolean;
+  isStateValidatorsNodesPopulated(): boolean;
+
+  loadOtherState(
+    stateBytes: Uint8Array,
+    seedValidatorsBytes?: Uint8Array,
+    opts?: {preloadValidatorsAndBalances?: boolean}
+  ): BeaconStateView;
+  loadOtherStateBench(stateBytes: Uint8Array, seedValidatorsBytes?: Uint8Array): void;
+  // biome-ignore lint/suspicious/noExplicitAny: structurally a BeaconState (fork-narrowed),
+  // but typing the union here would duplicate types from @lodestar/types. Caller narrows by forkName.
+  toValue(): any;
+
+  serialize(): Uint8Array;
+  serializedSize(): number;
+  /** Takes a `@chainsafe/ssz` ByteViews `{uint8Array, dataView}`; native uses `uint8Array` only. */
+  serializeToBytes(output: {uint8Array: Uint8Array; dataView: DataView}, offset: number): number;
+  serializeValidators(): Uint8Array;
+  serializedValidatorsSize(): number;
+  serializeValidatorsToBytes(output: {uint8Array: Uint8Array; dataView: DataView}, offset: number): number;
+  hashTreeRoot(): Uint8Array;
+  createMultiProof(descriptor: Uint8Array): CompactMultiProof;
+
+  /** Serialize this call with other STF operations and cache teardown within this thread. */
+  processSlots(slot: number, options?: ProcessSlotsOpts): BeaconStateView;
+  /**
+   * Serialize this call with other STF operations and cache teardown within this thread.
+   * Throws an Error with the native error name in `code` and available diagnostic details in `message`.
+   */
+  stateTransition(signedBlockBytes: Uint8Array, isBlinded: boolean, options?: TransitionOpts): BeaconStateView;
+}
+
+/**
+ * Owns a copy of the configuration inputs; states retain it for their lifetime.
+ * Numeric u64 fields accept safe unsigned integers or Infinity as the maximum u64 sentinel.
+ */
+export declare class BeaconConfig {
+  private readonly _brand: void;
+  constructor(chainConfig: object, genesisValidatorsRoot: Uint8Array);
+}
+
+declare const bindings: {
+  stateTransition: {
+    /** Callers must exclude STF operations in this thread until teardown returns. */
+    deinitReusedEpochTransitionCache: () => void;
+  };
+  metrics: {
+    init: (options?: {historical?: boolean}) => void;
+    scrapeMetrics: () => string;
+    registerLocalValidator: (index: number) => void;
+    unregisterLocalValidator: (index: number) => void;
+  };
+  BeaconStateView: typeof BeaconStateView;
+  BeaconConfig: typeof BeaconConfig;
+};
+
+export default bindings;
+
+export interface SyncCommitteeRewardsBlock {
+  slot: number;
+  body: {
+    randaoReveal: Uint8Array;
+    syncAggregate?: {
+      syncCommitteeBits: {uint8Array: Uint8Array; bitLen: number};
+    };
+  };
+}
+
+export interface SyncCommitteeReward {
+  validatorIndex: number;
+  reward: number;
+}
+
+export interface AttestationReward {
+  head: number;
+  target: number;
+  source: number;
+  inclusionDelay: number;
+  inactivity: number;
+}
+
+export interface IdealAttestationsReward extends AttestationReward {
+  effectiveBalance: number;
+}
+
+export interface TotalAttestationsReward extends AttestationReward {
+  validatorIndex: number;
+}
+
+export interface AttestationsRewards {
+  idealRewards: IdealAttestationsReward[];
+  totalRewards: TotalAttestationsReward[];
+}

package/src/index.js

@@ -0,0 +1,2 @@
+import bindings from "./bindings.js";
+export default bindings;

package/src/metrics.d.ts

@@ -0,0 +1,18 @@
+/** Initialize this environment's native state-transition metrics. */
+export declare function init(options?: {historical?: boolean}): void;
+
+/** Scrape native state-transition metrics in Prometheus text format. */
+export declare function scrapeMetrics(): string;
+
+/**
+ * Register a validator index with the native validator monitor. Metrics
+ * are recorded for registered validators on every epoch transition.
+ */
+export declare function registerLocalValidator(index: number): void;
+
+/**
+ * Remove a validator index from the native validator monitor, so its
+ * `validator_monitor_*` status metrics stop being recorded. Mirrors the pruning
+ * of stale registrations in lodestar's validator monitor.
+ */
+export declare function unregisterLocalValidator(index: number): void;

package/src/metrics.js

@@ -0,0 +1,8 @@
+import bindings from "./bindings.js";
+
+const native = bindings.metrics;
+
+export const init = native.init;
+export const scrapeMetrics = native.scrapeMetrics;
+export const registerLocalValidator = native.registerLocalValidator;
+export const unregisterLocalValidator = native.unregisterLocalValidator;

package/src/pubkeys.d.ts

@@ -0,0 +1,59 @@
+import type {PublicKey} from "./blst.js";
+
+/**
+ * Append-only validator public-key cache.
+ *
+ * Throws when encountering:
+ * - An existing index with a different public key.
+ * - An existing public key at a different index.
+ *
+ * No-op for an exact index and public-key replay.
+ */
+export interface PubkeyCache {
+  /** Get a cached, deserialized PublicKey. */
+  get(index: number): PublicKey | undefined;
+  /** Same as get(), but throws if the index is not in the cache */
+  getOrThrow(index: number): PublicKey;
+  /** Get the cached 48-byte compressed pubkey bytes without materializing a PublicKey wrapper. */
+  getPubkeyBytes(index: number): Uint8Array | undefined;
+  /** Same as getPubkeyBytes(), but throws if the index is not in the cache. */
+  getPubkeyBytesOrThrow(index: number): Uint8Array;
+  /** Aggregate cached public keys by validator index */
+  aggregate(indices: number[]): PublicKey;
+  /** Get validator index by pubkey bytes */
+  getIndex(pubkey: Uint8Array): number | null;
+  /**
+   * Append a trusted public key at the next index. Before calling this method,
+   * the caller must cryptographically validate the public key.
+   *
+   * The method throws if:
+   *
+   * - Encodings are malformed.
+   * - Entries are sparse.
+   */
+  append(index: number, pubkey: Uint8Array): void;
+  /**
+   * Populate the cache from the missing suffix of a trusted validator list.
+   * This method decodes public keys but does not validate.
+   */
+  syncPubkeys(validators: {pubkey: Uint8Array}[]): void;
+  /** Current number of cached entries. */
+  readonly size: number;
+  /** Number of entries the current native allocation can hold without growing. */
+  readonly capacity: number;
+  /**
+   * Load a compatible, trusted PKIX file from the control environment while no workers are using the cache.
+   * Does not revalidate public keys. The explicit capacity
+   * limit bounds both the entry count and native allocation; spare capacity
+   * recorded in the file is discarded above this limit.
+   */
+  load(filepath: string, maxCapacity: number): void;
+  /** Testing-only reset from the control environment while no workers are using the cache. */
+  reset(): void;
+  /** Save from the control environment. */
+  save(filepath: string): void;
+  /** Reserve exact native capacity when growing; existing larger capacity is retained. */
+  ensureCapacity(capacity: number): void;
+}
+
+export declare const pubkeyCache: PubkeyCache;

package/src/pubkeys.js

@@ -0,0 +1,72 @@
+import bindings from "./bindings.js";
+
+const native = bindings.pubkeys;
+
+/** @type {import("./pubkeys.d.ts").PubkeyCache} */
+export const pubkeyCache = {
+  get(index) {
+    return native.get(index);
+  },
+
+  getOrThrow(index) {
+    const pk = pubkeyCache.get(index);
+    if (pk === undefined) {
+      throw Error(`pubkeyCache: index ${index} not found`);
+    }
+    return pk;
+  },
+
+  getPubkeyBytes(index) {
+    return native.getPubkeyBytes(index);
+  },
+
+  getPubkeyBytesOrThrow(index) {
+     const pubkey = native.getPubkeyBytes(index);
+     if (pubkey === undefined) {
+       throw new Error(`pubkeyCache: index ${index} not found`);
+     }
+
+     return pubkey;
+   },
+
+  aggregate(indices) {
+    if (indices.length === 1) return pubkeyCache.getOrThrow(indices[0]);
+    return native.aggregate(indices);
+  },
+
+  getIndex(pubkey) {
+    return native.getIndex(pubkey);
+  },
+
+  append(index, pubkey) {
+    native.append(index, pubkey);
+  },
+
+  syncPubkeys(validators) {
+    native.syncPubkeys(validators);
+  },
+
+  get size() {
+    return native.size();
+  },
+
+  get capacity() {
+    return native.capacity();
+  },
+
+  load(filepath, maxCapacity) {
+    native.load(filepath, maxCapacity);
+  },
+
+  reset() {
+    native.reset();
+  },
+
+  save(filepath) {
+    native.save(filepath);
+  },
+
+  ensureCapacity(capacity) {
+    native.ensureCapacity(capacity);
+  },
+};