@apibara/beaconchain 2.1.0-beta.23 → 2.1.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/beaconchain",
-  "version": "2.1.0-beta.23",
+  "version": "2.1.0-beta.25",
   "type": "module",
   "files": [
     "dist",
@@ -35,8 +35,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/evm": "2.1.0-beta.23",
-    "@apibara/protocol": "2.1.0-beta.23",
+    "@apibara/protocol": "2.1.0-beta.25",
     "@effect/schema": "^0.67.15",
     "effect": "^3.2.6",
     "long": "^5.2.1",

package/src/block.ts

@@ -1,127 +1,134 @@
-import { AccessListItem } from "@apibara/evm";
 import { BytesFromUint8Array } from "@apibara/protocol";
-import { Schema } from "@effect/schema";
-
+import {
+  ArrayCodec,
+  BigIntCodec,
+  BooleanCodec,
+  type Codec,
+  type CodecType,
+  DateCodec,
+  MessageCodec,
+  NumberCodec,
+  OptionalCodec,
+  RequiredCodec,
+} from "@apibara/protocol/codec";
 import { Address, B256, B384, U128, U256, ValidatorStatus } from "./common";
 import * as proto from "./proto";
 
-export const ExecutionPayload = Schema.Struct({
-  parentHash: B256,
-  feeRecipient: Address,
-  stateRoot: B256,
-  receiptsRoot: B256,
-  logsBloom: BytesFromUint8Array,
-  prevRandao: B256,
-  blockNumber: Schema.BigIntFromSelf,
-  timestamp: Schema.DateFromSelf,
+export const ExecutionPayload = MessageCodec({
+  parentHash: RequiredCodec(B256),
+  feeRecipient: RequiredCodec(Address),
+  stateRoot: RequiredCodec(B256),
+  receiptsRoot: RequiredCodec(B256),
+  logsBloom: RequiredCodec(BytesFromUint8Array),
+  prevRandao: RequiredCodec(B256),
+  blockNumber: RequiredCodec(BigIntCodec),
+  timestamp: RequiredCodec(DateCodec),
+});
+
+export type ExecutionPayload = CodecType<typeof ExecutionPayload>;
+
+export const BlockHeader = MessageCodec({
+  slot: RequiredCodec(BigIntCodec),
+  proposerIndex: RequiredCodec(NumberCodec),
+  parentRoot: RequiredCodec(B256),
+  stateRoot: RequiredCodec(B256),
+  randaoReveal: RequiredCodec(BytesFromUint8Array),
+  depositCount: RequiredCodec(BigIntCodec),
+  depositRoot: RequiredCodec(B256),
+  blockHash: RequiredCodec(B256),
+  graffiti: RequiredCodec(B256),
+  executionPayload: OptionalCodec(ExecutionPayload),
+  blobKzgCommitments: ArrayCodec(B384),
 });
 
-export type ExecutionPayload = typeof ExecutionPayload.Type;
-
-export const BlockHeader = Schema.Struct({
-  slot: Schema.BigIntFromSelf,
-  proposerIndex: Schema.Number,
-  parentRoot: B256,
-  stateRoot: B256,
-  randaoReveal: BytesFromUint8Array,
-  depositCount: Schema.BigIntFromSelf,
-  depositRoot: B256,
-  blockHash: B256,
-  graffiti: B256,
-  executionPayload: Schema.optional(ExecutionPayload),
-  blobKzgCommitments: Schema.Array(B384),
+export type BlockHeader = CodecType<typeof BlockHeader>;
+
+export const Validator = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  validatorIndex: RequiredCodec(NumberCodec),
+  balance: RequiredCodec(BigIntCodec),
+  status: RequiredCodec(ValidatorStatus),
+  pubkey: RequiredCodec(B384),
+  withdrawalCredentials: RequiredCodec(B256),
+  effectiveBalance: RequiredCodec(BigIntCodec),
+  slashed: RequiredCodec(BooleanCodec),
+  activationEligibilityEpoch: RequiredCodec(BigIntCodec),
+  activationEpoch: RequiredCodec(BigIntCodec),
+  exitEpoch: RequiredCodec(BigIntCodec),
+  withdrawableEpoch: RequiredCodec(BigIntCodec),
 });
 
-export type BlockHeader = typeof BlockHeader.Type;
-
-export const Validator = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  validatorIndex: Schema.Number,
-  balance: Schema.BigIntFromSelf,
-  status: ValidatorStatus,
-  pubkey: B384,
-  withdrawalCredentials: B256,
-  effectiveBalance: Schema.BigIntFromSelf,
-  slashed: Schema.Boolean,
-  activationEligibilityEpoch: Schema.BigIntFromSelf,
-  activationEpoch: Schema.BigIntFromSelf,
-  exitEpoch: Schema.BigIntFromSelf,
-  withdrawableEpoch: Schema.BigIntFromSelf,
+export type Validator = CodecType<typeof Validator>;
+
+export const Blob = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  blobIndex: RequiredCodec(NumberCodec),
+  blob: RequiredCodec(BytesFromUint8Array),
+  kzgCommitment: RequiredCodec(B384),
+  kzgProof: RequiredCodec(B384),
+  kzgCommitmentInclusionProof: ArrayCodec(B256),
+  blobHash: RequiredCodec(B256),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
 });
 
-export type Validator = typeof Validator.Type;
-
-export const Blob = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  blobIndex: Schema.Number,
-  blob: Schema.Uint8ArrayFromSelf,
-  kzgCommitment: B384,
-  kzgProof: B384,
-  kzgCommitmentInclusionProof: Schema.Array(B256),
-  blobHash: B256,
-  transactionIndex: Schema.Number,
-  transactionHash: B256,
+export type Blob = CodecType<typeof Blob>;
+
+export const Signature = MessageCodec({
+  r: OptionalCodec(U256),
+  s: OptionalCodec(U256),
+  v: OptionalCodec(U256),
+  YParity: OptionalCodec(BooleanCodec),
 });
 
-export type Blob = typeof Blob.Type;
+export type Signature = CodecType<typeof Signature>;
 
-export const Signature = Schema.Struct({
-  r: Schema.optional(U256),
-  s: Schema.optional(U256),
-  v: Schema.optional(U256),
-  YParity: Schema.optional(Schema.Boolean),
+export const AccessListItem = MessageCodec({
+  address: RequiredCodec(Address),
+  storageKeys: ArrayCodec(B256),
 });
 
-export type Signature = typeof Signature.Type;
-
-export const Transaction = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionHash: B256,
-  nonce: Schema.BigIntFromSelf,
-  transactionIndex: Schema.Number,
-  from: Address,
-  to: Schema.optional(Address),
-  value: U256,
-  gasPrice: Schema.optional(U128),
-  gasLimit: Schema.optional(U128),
-  maxFeePerGas: Schema.optional(U128),
-  maxPriorityFeePerGas: Schema.optional(U128),
-  input: Schema.Uint8ArrayFromSelf,
-  signature: Schema.optional(Signature),
-  chainId: Schema.optional(Schema.BigIntFromSelf),
-  accessList: Schema.Array(AccessListItem),
-  transactionType: Schema.BigIntFromSelf,
-  maxFeePerBlobGas: Schema.optional(U128),
-  blobVersionedHashes: Schema.Array(B256),
+export type AccessListItem = CodecType<typeof AccessListItem>;
+
+export const Transaction = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
+  nonce: RequiredCodec(BigIntCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  from: RequiredCodec(Address),
+  to: OptionalCodec(Address),
+  value: RequiredCodec(U256),
+  gasPrice: OptionalCodec(U128),
+  gasLimit: OptionalCodec(U128),
+  maxFeePerGas: OptionalCodec(U128),
+  maxPriorityFeePerGas: OptionalCodec(U128),
+  input: RequiredCodec(BytesFromUint8Array),
+  signature: OptionalCodec(Signature),
+  chainId: OptionalCodec(BigIntCodec),
+  accessList: ArrayCodec(AccessListItem),
+  transactionType: RequiredCodec(BigIntCodec),
+  maxFeePerBlobGas: OptionalCodec(U128),
+  blobVersionedHashes: ArrayCodec(B256),
 });
 
-export type Transaction = typeof Transaction.Type;
+export type Transaction = CodecType<typeof Transaction>;
 
-export const Block = Schema.Struct({
-  header: BlockHeader,
-  validators: Schema.Array(Validator),
-  blobs: Schema.Array(Blob),
-  transactions: Schema.Array(Transaction),
+export const Block = MessageCodec({
+  header: RequiredCodec(BlockHeader),
+  validators: ArrayCodec(Validator),
+  blobs: ArrayCodec(Blob),
+  transactions: ArrayCodec(Transaction),
 });
 
-export type Block = typeof Block.Type;
-
-export const BlockFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Schema.NullOr(Block),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return proto.data.Block.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return proto.data.Block.encode(value).finish();
-    },
+export type Block = CodecType<typeof Block>;
+
+export const BlockFromBytes: Codec<Block, Uint8Array> = {
+  encode(x) {
+    const block = Block.encode(x);
+    return proto.data.Block.encode(block).finish();
+  },
+  decode(p) {
+    const block = proto.data.Block.decode(p);
+    return Block.decode(block);
   },
-);
+};

package/src/common.ts

@@ -1,97 +1,169 @@
-import { Schema } from "@effect/schema";
-import { hexToBytes, pad } from "viem";
-
+import type { Codec, CodecType } from "@apibara/protocol/codec";
 import * as proto from "./proto";
 
-// Re-export common types
-export { Address, U128, U256, B256 } from "@apibara/evm";
-
-export const ValidatorStatus = Schema.transform(
-  Schema.Enums(proto.common.ValidatorStatus),
-  Schema.Literal(
-    "pending_initialized",
-    "pending_queued",
-    "active_ongoing",
-    "active_exiting",
-    "active_slashed",
-    "exited_unslashed",
-    "exited_slashed",
-    "withdrawal_possible",
-    "withdrawal_done",
-    "unknown",
-  ),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.common.ValidatorStatus.PENDING_INITIALIZED]:
-          "pending_initialized",
-        [proto.common.ValidatorStatus.PENDING_QUEUED]: "pending_queued",
-        [proto.common.ValidatorStatus.ACTIVE_ONGOING]: "active_ongoing",
-        [proto.common.ValidatorStatus.ACTIVE_EXITING]: "active_exiting",
-        [proto.common.ValidatorStatus.ACTIVE_SLASHED]: "active_slashed",
-        [proto.common.ValidatorStatus.EXITED_UNSLASHED]: "exited_unslashed",
-        [proto.common.ValidatorStatus.EXITED_SLASHED]: "exited_slashed",
-        [proto.common.ValidatorStatus.WITHDRAWAL_POSSIBLE]:
-          "withdrawal_possible",
-        [proto.common.ValidatorStatus.WITHDRAWAL_DONE]: "withdrawal_done",
-        [proto.common.ValidatorStatus.UNKNOWN]: "unknown",
-        [proto.common.ValidatorStatus.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      const enumMap = {
-        pending_initialized: proto.common.ValidatorStatus.PENDING_INITIALIZED,
-        pending_queued: proto.common.ValidatorStatus.PENDING_QUEUED,
-        active_ongoing: proto.common.ValidatorStatus.ACTIVE_ONGOING,
-        active_exiting: proto.common.ValidatorStatus.ACTIVE_EXITING,
-        active_slashed: proto.common.ValidatorStatus.ACTIVE_SLASHED,
-        exited_unslashed: proto.common.ValidatorStatus.EXITED_UNSLASHED,
-        exited_slashed: proto.common.ValidatorStatus.EXITED_SLASHED,
-        withdrawal_possible: proto.common.ValidatorStatus.WITHDRAWAL_POSSIBLE,
-        withdrawal_done: proto.common.ValidatorStatus.WITHDRAWAL_DONE,
-        unknown: proto.common.ValidatorStatus.UNKNOWN,
-      } as const;
-
-      return enumMap[value] ?? proto.common.ValidatorStatus.UNKNOWN;
-    },
+const MAX_U64 = 0xffffffffffffffffn;
+const MAX_U32 = 0xffffffffn;
+
+/** An Ethereum address. */
+export const Address: Codec<`0x${string}`, proto.common.Address> = {
+  encode(x) {
+    const bn = BigInt(x);
+    // Ethereum address is 20 bytes (160 bits)
+    // Splitting into two 64-bit chunks and one 32-bit chunk
+    const x2 = bn & MAX_U32;
+    const x1 = (bn >> 32n) & MAX_U64;
+    const x0 = (bn >> 96n) & MAX_U64;
+    return { x0, x1, x2: Number(x2) };
+  },
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = BigInt(p.x2 ?? 0);
+    const bn = x2 + (x1 << 32n) + (x0 << 96n);
+    return `0x${bn.toString(16).padStart(40, "0")}` as `0x${string}`;
+  },
+};
+
+export type Address = CodecType<typeof Address>;
+
+/** Data with length 256 bits. */
+export const B256: Codec<`0x${string}`, proto.common.B256> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = (bn >> 64n) & MAX_U64;
+    const x1 = (bn >> 128n) & MAX_U64;
+    const x0 = (bn >> 192n) & MAX_U64;
+    return { x0, x1, x2, x3 };
+  },
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    const bn = x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+    return `0x${bn.toString(16).padStart(64, "0")}` as `0x${string}`;
   },
-);
-
-export type ValidatorStatus = typeof ValidatorStatus.Type;
-
-const _B384 = Schema.TemplateLiteral(Schema.Literal("0x"), Schema.String);
-const B384Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf,
-  x4: Schema.BigIntFromSelf,
-  x5: Schema.BigIntFromSelf,
-});
-
-export const B384 = Schema.transform(B384Proto, _B384, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(16, "0");
-    const x3 = value.x3.toString(16).padStart(16, "0");
-    const x4 = value.x4.toString(16).padStart(16, "0");
-    const x5 = value.x5.toString(16).padStart(16, "0");
-    return `0x${x0}${x1}${x2}${x3}${x4}${x5}` as `0x${string}`;
+};
+
+export type B256 = CodecType<typeof B256>;
+
+/** Data with length 256 bits. */
+export const U256: Codec<bigint, proto.common.U256> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = (bn >> 64n) & MAX_U64;
+    const x1 = (bn >> 128n) & MAX_U64;
+    const x0 = (bn >> 192n) & MAX_U64;
+    return { x0, x1, x2, x3 };
+  },
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    return x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+  },
+};
+
+export type U256 = CodecType<typeof U256>;
+
+/** Data with length 128 bits. */
+export const U128: Codec<bigint, proto.common.U128> = {
+  encode(x) {
+    const x1 = x & MAX_U64;
+    const x0 = (x >> 64n) & MAX_U64;
+    return { x0, x1 };
   },
-  encode(value) {
-    const bytes = hexToBytes(pad(value, { size: 48, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getBigUint64(16);
-    const x3 = dv.getBigUint64(24);
-    const x4 = dv.getBigUint64(32);
-    const x5 = dv.getBigUint64(40);
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    return x1 + (x0 << 64n);
+  },
+};
+
+export type U128 = CodecType<typeof U128>;
+
+export const B384: Codec<`0x${string}`, proto.common.B384> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x5 = bn & MAX_U64;
+    const x4 = (bn >> 64n) & MAX_U64;
+    const x3 = (bn >> 128n) & MAX_U64;
+    const x2 = (bn >> 192n) & MAX_U64;
+    const x1 = (bn >> 256n) & MAX_U64;
+    const x0 = (bn >> 320n) & MAX_U64;
     return { x0, x1, x2, x3, x4, x5 };
   },
-});
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    const x4 = p.x4 ?? 0n;
+    const x5 = p.x5 ?? 0n;
+    const bn =
+      x5 +
+      (x4 << 64n) +
+      (x3 << 128n) +
+      (x2 << 192n) +
+      (x1 << 256n) +
+      (x0 << 320n);
+
+    return `0x${bn.toString(16).padStart(96, "0")}` as `0x${string}`;
+  },
+};
+
+export type B384 = CodecType<typeof B384>;
+
+export const ValidatorStatus: Codec<
+  | "pending_initialized"
+  | "pending_queued"
+  | "active_ongoing"
+  | "active_exiting"
+  | "active_slashed"
+  | "exited_unslashed"
+  | "exited_slashed"
+  | "withdrawal_possible"
+  | "withdrawal_done"
+  | "unknown",
+  proto.common.ValidatorStatus
+> = {
+  encode(x) {
+    const enumMap = {
+      pending_initialized: proto.common.ValidatorStatus.PENDING_INITIALIZED,
+      pending_queued: proto.common.ValidatorStatus.PENDING_QUEUED,
+      active_ongoing: proto.common.ValidatorStatus.ACTIVE_ONGOING,
+      active_exiting: proto.common.ValidatorStatus.ACTIVE_EXITING,
+      active_slashed: proto.common.ValidatorStatus.ACTIVE_SLASHED,
+      exited_unslashed: proto.common.ValidatorStatus.EXITED_UNSLASHED,
+      exited_slashed: proto.common.ValidatorStatus.EXITED_SLASHED,
+      withdrawal_possible: proto.common.ValidatorStatus.WITHDRAWAL_POSSIBLE,
+      withdrawal_done: proto.common.ValidatorStatus.WITHDRAWAL_DONE,
+      unknown: proto.common.ValidatorStatus.UNKNOWN,
+    } as const;
+
+    return enumMap[x] ?? proto.common.ValidatorStatus.UNKNOWN;
+  },
+
+  decode(p) {
+    const enumMap = {
+      [proto.common.ValidatorStatus.PENDING_INITIALIZED]: "pending_initialized",
+      [proto.common.ValidatorStatus.PENDING_QUEUED]: "pending_queued",
+      [proto.common.ValidatorStatus.ACTIVE_ONGOING]: "active_ongoing",
+      [proto.common.ValidatorStatus.ACTIVE_EXITING]: "active_exiting",
+      [proto.common.ValidatorStatus.ACTIVE_SLASHED]: "active_slashed",
+      [proto.common.ValidatorStatus.EXITED_UNSLASHED]: "exited_unslashed",
+      [proto.common.ValidatorStatus.EXITED_SLASHED]: "exited_slashed",
+      [proto.common.ValidatorStatus.WITHDRAWAL_POSSIBLE]: "withdrawal_possible",
+      [proto.common.ValidatorStatus.WITHDRAWAL_DONE]: "withdrawal_done",
+      [proto.common.ValidatorStatus.UNKNOWN]: "unknown",
+      [proto.common.ValidatorStatus.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
+  },
+};
 
-export type B384 = typeof B384.Type;
+export type ValidatorStatus = CodecType<typeof ValidatorStatus>;