@apibara/evm 2.1.0-beta.23 → 2.1.0-beta.24

package/src/block.ts

@@ -1,361 +1,365 @@
-import { Bytes, BytesFromUint8Array } from "@apibara/protocol";
-import { Schema } from "@effect/schema";
-
+import { BytesFromUint8Array } from "@apibara/protocol";
+
+import {
+  ArrayCodec,
+  BigIntCodec,
+  BooleanCodec,
+  type Codec,
+  type CodecType,
+  DateCodec,
+  MessageCodec,
+  NumberCodec,
+  OneOfCodec,
+  OptionalCodec,
+  StringCodec,
+} from "@apibara/protocol/codec";
+import { RequiredCodec } from "@apibara/protocol/codec";
 import { Address, B256, U128, U256 } from "./common";
-import { tag } from "./helpers";
 import * as proto from "./proto";
 
-export const Bloom = Schema.transform(
-  Schema.Struct({
-    value: BytesFromUint8Array,
-  }),
-  Bytes,
-  {
-    strict: false,
-    encode(value) {
-      throw new Error("Not implemented");
-    },
-    decode({ value }) {
-      return value;
-    },
+export const Bloom: Codec<
+  `0x${string}` | undefined,
+  { value?: Uint8Array | undefined }
+> = {
+  encode(x) {
+    return { value: BytesFromUint8Array.encode(x) };
+  },
+  decode({ value }) {
+    return BytesFromUint8Array.decode(value);
   },
-);
-
-export type Bloom = typeof Bloom.Type;
-
-export const TransactionStatus = Schema.transform(
-  Schema.Enums(proto.data.TransactionStatus),
-  Schema.Literal("unknown", "succeeded", "reverted"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.data.TransactionStatus.SUCCEEDED]: "succeeded",
-        [proto.data.TransactionStatus.REVERTED]: "reverted",
-        [proto.data.TransactionStatus.UNSPECIFIED]: "unknown",
-        [proto.data.TransactionStatus.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    },
+};
+
+export type Bloom = CodecType<typeof Bloom>;
+
+export const TransactionStatus: Codec<
+  "unknown" | "succeeded" | "reverted",
+  proto.data.TransactionStatus
+> = {
+  encode(x) {
+    const enumMap = {
+      unknown: proto.data.TransactionStatus.UNSPECIFIED,
+      succeeded: proto.data.TransactionStatus.SUCCEEDED,
+      reverted: proto.data.TransactionStatus.REVERTED,
+    } as const;
+
+    return enumMap[x] ?? proto.data.TransactionStatus.UNSPECIFIED;
   },
-);
-
-export type TransactionStatus = typeof TransactionStatus.Type;
-
-export const BlockHeader = Schema.Struct({
-  blockNumber: Schema.BigIntFromSelf,
-  blockHash: B256,
-  parentBlockHash: B256,
-  unclesHash: B256,
-  miner: Address,
-  stateRoot: B256,
-  transactionsRoot: B256,
-  receiptsRoot: B256,
-  logsBloom: Bloom,
-  difficulty: U256,
-  gasLimit: U128,
-  gasUsed: U128,
-  timestamp: Schema.DateFromSelf,
-  extraData: BytesFromUint8Array,
-  mixHash: Schema.optional(B256),
-  nonce: Schema.optional(Schema.BigIntFromSelf),
-  baseFeePerGas: Schema.optional(U128),
-  withdrawalsRoot: Schema.optional(B256),
-  totalDifficulty: Schema.optional(U256),
-  blobGasUsed: Schema.optional(U128),
-  excessBlobGas: Schema.optional(U128),
-  parentBeaconBlockRoot: Schema.optional(B256),
-  requestsHash: Schema.optional(B256),
+  decode(p) {
+    const enumMap = {
+      [proto.data.TransactionStatus.SUCCEEDED]: "succeeded",
+      [proto.data.TransactionStatus.REVERTED]: "reverted",
+      [proto.data.TransactionStatus.UNSPECIFIED]: "unknown",
+      [proto.data.TransactionStatus.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
+  },
+};
+
+export type TransactionStatus = CodecType<typeof TransactionStatus>;
+
+export const BlockHeader = MessageCodec({
+  blockNumber: RequiredCodec(BigIntCodec),
+  blockHash: RequiredCodec(B256),
+  parentBlockHash: RequiredCodec(B256),
+  unclesHash: RequiredCodec(B256),
+  miner: RequiredCodec(Address),
+  stateRoot: RequiredCodec(B256),
+  transactionsRoot: RequiredCodec(B256),
+  receiptsRoot: RequiredCodec(B256),
+  logsBloom: RequiredCodec(Bloom),
+  difficulty: RequiredCodec(U256),
+  gasLimit: RequiredCodec(U128),
+  gasUsed: RequiredCodec(U128),
+  timestamp: RequiredCodec(DateCodec),
+  extraData: RequiredCodec(BytesFromUint8Array),
+  mixHash: OptionalCodec(B256),
+  nonce: OptionalCodec(BigIntCodec),
+  baseFeePerGas: OptionalCodec(U128),
+  withdrawalsRoot: OptionalCodec(B256),
+  totalDifficulty: OptionalCodec(U256),
+  blobGasUsed: OptionalCodec(U128),
+  excessBlobGas: OptionalCodec(U128),
+  parentBeaconBlockRoot: OptionalCodec(B256),
+  requestsHash: OptionalCodec(B256),
 });
 
-export type BlockHeader = typeof BlockHeader.Type;
+export type BlockHeader = CodecType<typeof BlockHeader>;
 
-export const Withdrawal = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  withdrawalIndex: Schema.Number,
-  index: Schema.BigIntFromSelf,
-  validatorIndex: Schema.Number,
-  address: Address,
-  amount: Schema.BigIntFromSelf,
+export const Withdrawal = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  withdrawalIndex: RequiredCodec(NumberCodec),
+  index: RequiredCodec(BigIntCodec),
+  validatorIndex: RequiredCodec(NumberCodec),
+  address: RequiredCodec(Address),
+  amount: RequiredCodec(BigIntCodec),
 });
 
-export type Withdrawal = typeof Withdrawal.Type;
+export type Withdrawal = CodecType<typeof Withdrawal>;
 
-export const AccessListItem = Schema.Struct({
-  address: Address,
-  storageKeys: Schema.Array(B256),
+export const AccessListItem = MessageCodec({
+  address: RequiredCodec(Address),
+  storageKeys: ArrayCodec(B256),
 });
 
-export type AccessListItem = typeof AccessListItem.Type;
+export type AccessListItem = CodecType<typeof AccessListItem>;
 
-export const Signature = Schema.Struct({
-  r: U256,
-  s: U256,
-  v: Schema.optional(U256),
-  YParity: Schema.optional(Schema.Boolean),
+export const Signature = MessageCodec({
+  r: RequiredCodec(U256),
+  s: RequiredCodec(U256),
+  v: OptionalCodec(U256),
+  YParity: OptionalCodec(BooleanCodec),
 });
 
-export type Signature = typeof Signature.Type;
-
-export const Transaction = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256,
-  nonce: Schema.BigIntFromSelf,
-  from: Address,
-  to: Schema.optional(Address),
-  value: U256,
-  gasPrice: Schema.optional(U128),
-  gas: U128,
-  maxFeePerGas: Schema.optional(U128),
-  maxPriorityFeePerGas: Schema.optional(U128),
-  input: BytesFromUint8Array,
-  signature: Schema.optional(Signature),
-  chainId: Schema.optional(Schema.BigIntFromSelf),
-  accessList: Schema.Array(AccessListItem),
-  transactionType: Schema.BigIntFromSelf,
-  maxFeePerBlobGas: Schema.optional(U128),
-  blobVersionedHashes: Schema.Array(B256),
-  transactionStatus: TransactionStatus,
+export type Signature = CodecType<typeof Signature>;
+
+export const Transaction = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
+  nonce: RequiredCodec(BigIntCodec),
+  from: RequiredCodec(Address),
+  to: OptionalCodec(Address),
+  value: RequiredCodec(U256),
+  gasPrice: OptionalCodec(U128),
+  gas: RequiredCodec(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),
+  transactionStatus: RequiredCodec(TransactionStatus),
 });
 
-export type Transaction = typeof Transaction.Type;
-
-export const TransactionReceipt = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256,
-  cumulativeGasUsed: U128,
-  gasUsed: U128,
-  effectiveGasPrice: U128,
-  from: Address,
-  to: Schema.optional(Address),
-  contractAddress: Schema.optional(Address),
-  logsBloom: Bloom,
-  transactionType: Schema.BigIntFromSelf,
-  blobGasUsed: Schema.optional(U128),
-  blobGasPrice: Schema.optional(U128),
-  transactionStatus: TransactionStatus,
+export type Transaction = CodecType<typeof Transaction>;
+
+export const TransactionReceipt = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
+  cumulativeGasUsed: RequiredCodec(U128),
+  gasUsed: RequiredCodec(U128),
+  effectiveGasPrice: RequiredCodec(U128),
+  from: RequiredCodec(Address),
+  to: OptionalCodec(Address),
+  contractAddress: OptionalCodec(Address),
+  logsBloom: RequiredCodec(Bloom),
+  transactionType: RequiredCodec(BigIntCodec),
+  blobGasUsed: OptionalCodec(U128),
+  blobGasPrice: OptionalCodec(U128),
+  transactionStatus: RequiredCodec(TransactionStatus),
 });
 
-export type TransactionReceipt = typeof TransactionReceipt.Type;
-
-export const Log = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  address: Address,
-  topics: Schema.Array(B256),
-  data: BytesFromUint8Array,
-  logIndex: Schema.Number,
-  logIndexInTransaction: Schema.Number,
-  transactionIndex: Schema.Number,
-  transactionHash: B256,
-  transactionStatus: TransactionStatus,
+export type TransactionReceipt = CodecType<typeof TransactionReceipt>;
+
+export const Log = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  address: RequiredCodec(Address),
+  topics: ArrayCodec(B256),
+  data: RequiredCodec(BytesFromUint8Array),
+  logIndex: RequiredCodec(NumberCodec),
+  logIndexInTransaction: RequiredCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
+  transactionStatus: RequiredCodec(TransactionStatus),
 });
 
-export type Log = typeof Log.Type;
-
-export const CallType = Schema.transform(
-  Schema.Enums(proto.data.CallType),
-  Schema.Literal(
-    "unknown",
-    "call",
-    "delegateCall",
-    "callCode",
-    "delegateCall",
-    "staticCall",
-    "authCall",
-  ),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.data.CallType.CALL]: "call",
-        [proto.data.CallType.CALL_CODE]: "callCode",
-        [proto.data.CallType.DELEGATE_CALL]: "delegateCall",
-        [proto.data.CallType.STATIC_CALL]: "staticCall",
-        [proto.data.CallType.AUTH_CALL]: "authCall",
-        [proto.data.CallType.UNSPECIFIED]: "unknown",
-        [proto.data.CallType.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    },
+export type Log = CodecType<typeof Log>;
+
+export const CallType: Codec<
+  "unknown" | "call" | "delegateCall" | "callCode" | "staticCall" | "authCall",
+  proto.data.CallType
+> = {
+  encode(x) {
+    const enumMap = {
+      unknown: proto.data.CallType.UNSPECIFIED,
+      call: proto.data.CallType.CALL,
+      callCode: proto.data.CallType.CALL_CODE,
+      delegateCall: proto.data.CallType.DELEGATE_CALL,
+      staticCall: proto.data.CallType.STATIC_CALL,
+      authCall: proto.data.CallType.AUTH_CALL,
+    } as const;
+
+    return enumMap[x] ?? proto.data.CallType.UNSPECIFIED;
   },
-);
-
-export type CallType = typeof CallType.Type;
-
-export const CreationMethod = Schema.transform(
-  Schema.Enums(proto.data.CreationMethod),
-  Schema.Literal("unknown", "create", "create2", "eofCreate"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.data.CreationMethod.CREATE]: "create",
-        [proto.data.CreationMethod.CREATE2]: "create2",
-        [proto.data.CreationMethod.EOF_CREATE]: "eofCreate",
-        [proto.data.CallType.UNSPECIFIED]: "unknown",
-        [proto.data.CallType.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    },
+  decode(p) {
+    const enumMap = {
+      [proto.data.CallType.CALL]: "call",
+      [proto.data.CallType.CALL_CODE]: "callCode",
+      [proto.data.CallType.DELEGATE_CALL]: "delegateCall",
+      [proto.data.CallType.STATIC_CALL]: "staticCall",
+      [proto.data.CallType.AUTH_CALL]: "authCall",
+      [proto.data.CallType.UNSPECIFIED]: "unknown",
+      [proto.data.CallType.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
   },
-);
-
-export type CreationMethod = typeof CreationMethod.Type;
-
-export const CallAction = Schema.Struct({
-  _tag: tag("call"),
-  call: Schema.Struct({
-    fromAddress: Address,
-    type: CallType,
-    gas: Schema.BigIntFromSelf,
-    input: BytesFromUint8Array,
-    toAddress: Address,
-    value: U256,
-  }),
+};
+
+export type CallType = CodecType<typeof CallType>;
+
+export const CreationMethod: Codec<
+  "unknown" | "create" | "create2" | "eofCreate",
+  proto.data.CreationMethod
+> = {
+  encode(x) {
+    const enumMap = {
+      unknown: proto.data.CreationMethod.UNSPECIFIED,
+      create: proto.data.CreationMethod.CREATE,
+      create2: proto.data.CreationMethod.CREATE2,
+      eofCreate: proto.data.CreationMethod.EOF_CREATE,
+    } as const;
+
+    return enumMap[x] ?? proto.data.CreationMethod.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.data.CreationMethod.CREATE]: "create",
+      [proto.data.CreationMethod.CREATE2]: "create2",
+      [proto.data.CreationMethod.EOF_CREATE]: "eofCreate",
+      [proto.data.CreationMethod.UNSPECIFIED]: "unknown",
+      [proto.data.CreationMethod.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
+  },
+};
+
+export type CreationMethod = CodecType<typeof CreationMethod>;
+
+export const CallAction = MessageCodec({
+  fromAddress: RequiredCodec(Address),
+  type: RequiredCodec(CallType),
+  gas: RequiredCodec(BigIntCodec),
+  input: RequiredCodec(BytesFromUint8Array),
+  toAddress: RequiredCodec(Address),
+  value: RequiredCodec(U256),
 });
 
-export type CallAction = typeof CallAction.Type;
-
-export const CreateAction = Schema.Struct({
-  _tag: tag("create"),
-  create: Schema.Struct({
-    fromAddress: Address,
-    gas: Schema.BigIntFromSelf,
-    init: BytesFromUint8Array,
-    value: U256,
-    creationMethod: CreationMethod,
-  }),
+export type CallAction = CodecType<typeof CallAction>;
+
+export const CreateAction = MessageCodec({
+  fromAddress: RequiredCodec(Address),
+  gas: RequiredCodec(BigIntCodec),
+  init: RequiredCodec(BytesFromUint8Array),
+  value: RequiredCodec(U256),
+  creationMethod: RequiredCodec(CreationMethod),
 });
 
-export type CreateAction = typeof CreateAction.Type;
+export type CreateAction = CodecType<typeof CreateAction>;
 
-export const SelfDestructAction = Schema.Struct({
-  _tag: tag("selfDestruct"),
-  selfDestruct: Schema.Struct({
-    address: Address,
-    balance: U256,
-    refundAddress: Address,
-  }),
+export const SelfDestructAction = MessageCodec({
+  address: RequiredCodec(Address),
+  balance: RequiredCodec(U256),
+  refundAddress: RequiredCodec(Address),
 });
 
-export type SelfDestructAction = typeof SelfDestructAction.Type;
-
-export const RewardType = Schema.transform(
-  Schema.Enums(proto.data.RewardType),
-  Schema.Literal("unknown", "block", "uncle"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.data.RewardType.BLOCK]: "block",
-        [proto.data.RewardType.UNCLE]: "uncle",
-        [proto.data.RewardType.UNSPECIFIED]: "unknown",
-        [proto.data.RewardType.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    },
+export type SelfDestructAction = CodecType<typeof SelfDestructAction>;
+
+export const RewardType: Codec<
+  "unknown" | "block" | "uncle",
+  proto.data.RewardType
+> = {
+  encode(x) {
+    const enumMap = {
+      unknown: proto.data.RewardType.UNSPECIFIED,
+      block: proto.data.RewardType.BLOCK,
+      uncle: proto.data.RewardType.UNCLE,
+    } as const;
+
+    return enumMap[x] ?? proto.data.RewardType.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.data.RewardType.BLOCK]: "block",
+      [proto.data.RewardType.UNCLE]: "uncle",
+      [proto.data.RewardType.UNSPECIFIED]: "unknown",
+      [proto.data.RewardType.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
   },
-);
+};
 
-export type RewardType = typeof RewardType.Type;
+export type RewardType = CodecType<typeof RewardType>;
 
-export const RewardAction = Schema.Struct({
-  _tag: tag("reward"),
-  reward: Schema.Struct({
-    author: Address,
-    type: RewardType,
-    value: U256,
-  }),
+export const RewardAction = MessageCodec({
+  author: RequiredCodec(Address),
+  type: RequiredCodec(RewardType),
+  value: RequiredCodec(U256),
 });
 
-export type RewardAction = typeof RewardAction.Type;
+export type RewardAction = CodecType<typeof RewardAction>;
 
-export const CallOutput = Schema.Struct({
-  _tag: tag("callOutput"),
-  callOutput: Schema.Struct({
-    gasUsed: Schema.BigIntFromSelf,
-    output: BytesFromUint8Array,
-  }),
+export const CallOutput = MessageCodec({
+  gasUsed: RequiredCodec(BigIntCodec),
+  output: RequiredCodec(BytesFromUint8Array),
 });
 
-export type CallOutput = typeof CallOutput.Type;
+export type CallOutput = CodecType<typeof CallOutput>;
 
-export const CreateOutput = Schema.Struct({
-  _tag: tag("createOutput"),
-  createOutput: Schema.Struct({
-    address: Address,
-    code: BytesFromUint8Array,
-    gasUsed: Schema.BigIntFromSelf,
-  }),
+export const CreateOutput = MessageCodec({
+  address: RequiredCodec(Address),
+  code: RequiredCodec(BytesFromUint8Array),
+  gasUsed: RequiredCodec(BigIntCodec),
 });
 
-export type CreateOutput = typeof CreateOutput.Type;
+export type CreateOutput = CodecType<typeof CreateOutput>;
 
-export const Trace = Schema.Struct({
-  action: Schema.Union(
-    CallAction,
-    CreateAction,
-    SelfDestructAction,
-    RewardAction,
+export const Trace = MessageCodec({
+  action: RequiredCodec(
+    OneOfCodec({
+      call: CallAction,
+      create: CreateAction,
+      selfDestruct: SelfDestructAction,
+      reward: RewardAction,
+    }),
   ),
-  error: Schema.optional(Schema.String),
-  output: Schema.optional(Schema.Union(CallOutput, CreateOutput)),
-  subtraces: Schema.Number,
-  traceAddress: Schema.Array(Schema.Number),
+  error: OptionalCodec(StringCodec),
+  output: OptionalCodec(
+    OneOfCodec({
+      callOutput: CallOutput,
+      createOutput: CreateOutput,
+    }),
+  ),
+  subtraces: RequiredCodec(NumberCodec),
+  traceAddress: ArrayCodec(NumberCodec),
 });
 
-export type Trace = typeof Trace.Type;
+export type Trace = CodecType<typeof Trace>;
 
-export const TransactionTrace = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256,
-  traces: Schema.Array(Trace),
+export const TransactionTrace = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256),
+  traces: ArrayCodec(Trace),
 });
 
-export type TransactionTrace = typeof TransactionTrace.Type;
+export type TransactionTrace = CodecType<typeof TransactionTrace>;
 
-export const Block = Schema.Struct({
-  header: BlockHeader,
-  withdrawals: Schema.Array(Withdrawal),
-  transactions: Schema.Array(Transaction),
-  receipts: Schema.Array(TransactionReceipt),
-  logs: Schema.Array(Log),
-  traces: Schema.Array(TransactionTrace),
+export const Block = MessageCodec({
+  header: RequiredCodec(BlockHeader),
+  withdrawals: ArrayCodec(Withdrawal),
+  transactions: ArrayCodec(Transaction),
+  receipts: ArrayCodec(TransactionReceipt),
+  logs: ArrayCodec(Log),
+  traces: ArrayCodec(TransactionTrace),
 });
 
-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);
   },
-);
+};