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

package/dist/index.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
 const protocol = require('@apibara/protocol');
-const schema = require('@effect/schema');
-const viem = require('viem');
+const codec = require('@apibara/protocol/codec');
 const Long = require('long');
 const _m0 = require('protobufjs/minimal.js');
 
@@ -12,98 +11,70 @@ const Long__default = /*#__PURE__*/_interopDefaultCompat(Long);
 const _m0__default = /*#__PURE__*/_interopDefaultCompat(_m0);
 
 const MAX_U64 = 0xffffffffffffffffn;
-const _Address = schema.Schema.TemplateLiteral(schema.Schema.Literal("0x"), schema.Schema.String);
-const AddressProto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.Number
-});
-const Address$1 = schema.Schema.transform(AddressProto, _Address, {
-  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(8, "0");
-    return `0x${x0}${x1}${x2}`;
-  },
-  encode(value) {
-    const bytes = viem.hexToBytes(viem.pad(value, { size: 20, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getUint32(16);
-    return { x0, x1, x2 };
+const MAX_U32 = 0xffffffffn;
+const Address$1 = {
+  encode(x) {
+    const bn = BigInt(x);
+    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")}`;
   }
-});
-const _B256 = schema.Schema.TemplateLiteral(schema.Schema.Literal("0x"), schema.Schema.String);
-const B256Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.BigIntFromSelf,
-  x3: schema.Schema.BigIntFromSelf
-});
-const B256$1 = schema.Schema.transform(B256Proto, _B256, {
-  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");
-    return `0x${x0}${x1}${x2}${x3}`;
-  },
-  encode(value) {
-    const bytes = viem.hexToBytes(viem.pad(value, { size: 32, 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 B256$1 = {
+  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 };
-  }
-});
-const b256ToProto = schema.Schema.encodeSync(B256$1);
-const b256FromProto = schema.Schema.decodeSync(B256$1);
-const U256Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.BigIntFromSelf,
-  x3: schema.Schema.BigIntFromSelf
-});
-const U256$1 = schema.Schema.transform(U256Proto, schema.Schema.BigIntFromSelf, {
-  decode(value) {
-    return (value.x0 << 8n * 24n) + (value.x1 << 8n * 16n) + (value.x2 << 8n * 8n) + value.x3;
   },
-  encode(value) {
-    const x0 = value >> 8n * 24n & MAX_U64;
-    const x1 = value >> 8n * 16n & MAX_U64;
-    const x2 = value >> 8n * 8n & MAX_U64;
-    const x3 = value & 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")}`;
   }
-});
-const u256ToProto = schema.Schema.encodeSync(U256$1);
-const u256FromProto = schema.Schema.decodeSync(U256$1);
-const U128Proto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf
-});
-const U128$1 = schema.Schema.transform(U128Proto, schema.Schema.BigIntFromSelf, {
-  decode(value) {
-    return (value.x0 << 8n * 8n) + value.x1;
+};
+const U256$1 = {
+  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 };
   },
-  encode(value) {
-    const x0 = value >> 8n * 8n & MAX_U64;
-    const x1 = value & MAX_U64;
+  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);
+  }
+};
+const U128$1 = {
+  encode(x) {
+    const x1 = x & MAX_U64;
+    const x0 = x >> 64n & MAX_U64;
     return { x0, x1 };
+  },
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    return x1 + (x0 << 64n);
   }
-});
-const u128ToProto = schema.Schema.encodeSync(U128$1);
-const u128FromProto = schema.Schema.decodeSync(U128$1);
-
-function tag(tag2) {
-  return schema.Schema.Literal(tag2).pipe(
-    schema.Schema.propertySignature,
-    schema.Schema.fromKey("$case")
-  );
-}
+};
 
 const protobufPackage$2 = "evm.v2";
 function createBaseAddress() {
@@ -4068,417 +4039,368 @@ const index = {
   filter: filter
 };
 
-const Bloom = schema.Schema.transform(
-  schema.Schema.Struct({
-    value: protocol.BytesFromUint8Array
-  }),
-  protocol.Bytes,
-  {
-    strict: false,
-    encode(value) {
-      throw new Error("Not implemented");
-    },
-    decode({ value }) {
-      return value;
-    }
+const Bloom = {
+  encode(x) {
+    return { value: protocol.BytesFromUint8Array.encode(x) };
+  },
+  decode({ value }) {
+    return protocol.BytesFromUint8Array.decode(value);
   }
-);
-const TransactionStatus = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatus$1),
-  schema.Schema.Literal("unknown", "succeeded", "reverted"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatus$1.SUCCEEDED]: "succeeded",
-        [TransactionStatus$1.REVERTED]: "reverted",
-        [TransactionStatus$1.UNSPECIFIED]: "unknown",
-        [TransactionStatus$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+};
+const TransactionStatus = {
+  encode(x) {
+    const enumMap = {
+      unknown: TransactionStatus$1.UNSPECIFIED,
+      succeeded: TransactionStatus$1.SUCCEEDED,
+      reverted: TransactionStatus$1.REVERTED
+    };
+    return enumMap[x] ?? TransactionStatus$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [TransactionStatus$1.SUCCEEDED]: "succeeded",
+      [TransactionStatus$1.REVERTED]: "reverted",
+      [TransactionStatus$1.UNSPECIFIED]: "unknown",
+      [TransactionStatus$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const BlockHeader = schema.Schema.Struct({
-  blockNumber: schema.Schema.BigIntFromSelf,
-  blockHash: B256$1,
-  parentBlockHash: B256$1,
-  unclesHash: B256$1,
-  miner: Address$1,
-  stateRoot: B256$1,
-  transactionsRoot: B256$1,
-  receiptsRoot: B256$1,
-  logsBloom: Bloom,
-  difficulty: U256$1,
-  gasLimit: U128$1,
-  gasUsed: U128$1,
-  timestamp: schema.Schema.DateFromSelf,
-  extraData: protocol.BytesFromUint8Array,
-  mixHash: schema.Schema.optional(B256$1),
-  nonce: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  baseFeePerGas: schema.Schema.optional(U128$1),
-  withdrawalsRoot: schema.Schema.optional(B256$1),
-  totalDifficulty: schema.Schema.optional(U256$1),
-  blobGasUsed: schema.Schema.optional(U128$1),
-  excessBlobGas: schema.Schema.optional(U128$1),
-  parentBeaconBlockRoot: schema.Schema.optional(B256$1),
-  requestsHash: schema.Schema.optional(B256$1)
+};
+const BlockHeader = codec.MessageCodec({
+  blockNumber: codec.RequiredCodec(codec.BigIntCodec),
+  blockHash: codec.RequiredCodec(B256$1),
+  parentBlockHash: codec.RequiredCodec(B256$1),
+  unclesHash: codec.RequiredCodec(B256$1),
+  miner: codec.RequiredCodec(Address$1),
+  stateRoot: codec.RequiredCodec(B256$1),
+  transactionsRoot: codec.RequiredCodec(B256$1),
+  receiptsRoot: codec.RequiredCodec(B256$1),
+  logsBloom: codec.RequiredCodec(Bloom),
+  difficulty: codec.RequiredCodec(U256$1),
+  gasLimit: codec.RequiredCodec(U128$1),
+  gasUsed: codec.RequiredCodec(U128$1),
+  timestamp: codec.RequiredCodec(codec.DateCodec),
+  extraData: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  mixHash: codec.OptionalCodec(B256$1),
+  nonce: codec.OptionalCodec(codec.BigIntCodec),
+  baseFeePerGas: codec.OptionalCodec(U128$1),
+  withdrawalsRoot: codec.OptionalCodec(B256$1),
+  totalDifficulty: codec.OptionalCodec(U256$1),
+  blobGasUsed: codec.OptionalCodec(U128$1),
+  excessBlobGas: codec.OptionalCodec(U128$1),
+  parentBeaconBlockRoot: codec.OptionalCodec(B256$1),
+  requestsHash: codec.OptionalCodec(B256$1)
 });
-const Withdrawal = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  withdrawalIndex: schema.Schema.Number,
-  index: schema.Schema.BigIntFromSelf,
-  validatorIndex: schema.Schema.Number,
-  address: Address$1,
-  amount: schema.Schema.BigIntFromSelf
+const Withdrawal = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  withdrawalIndex: codec.RequiredCodec(codec.NumberCodec),
+  index: codec.RequiredCodec(codec.BigIntCodec),
+  validatorIndex: codec.RequiredCodec(codec.NumberCodec),
+  address: codec.RequiredCodec(Address$1),
+  amount: codec.RequiredCodec(codec.BigIntCodec)
 });
-const AccessListItem = schema.Schema.Struct({
-  address: Address$1,
-  storageKeys: schema.Schema.Array(B256$1)
+const AccessListItem = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  storageKeys: codec.ArrayCodec(B256$1)
 });
-const Signature = schema.Schema.Struct({
-  r: U256$1,
-  s: U256$1,
-  v: schema.Schema.optional(U256$1),
-  YParity: schema.Schema.optional(schema.Schema.Boolean)
+const Signature = codec.MessageCodec({
+  r: codec.RequiredCodec(U256$1),
+  s: codec.RequiredCodec(U256$1),
+  v: codec.OptionalCodec(U256$1),
+  YParity: codec.OptionalCodec(codec.BooleanCodec)
 });
-const Transaction = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  nonce: schema.Schema.BigIntFromSelf,
-  from: Address$1,
-  to: schema.Schema.optional(Address$1),
-  value: U256$1,
-  gasPrice: schema.Schema.optional(U128$1),
-  gas: U128$1,
-  maxFeePerGas: schema.Schema.optional(U128$1),
-  maxPriorityFeePerGas: schema.Schema.optional(U128$1),
-  input: protocol.BytesFromUint8Array,
-  signature: schema.Schema.optional(Signature),
-  chainId: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  accessList: schema.Schema.Array(AccessListItem),
-  transactionType: schema.Schema.BigIntFromSelf,
-  maxFeePerBlobGas: schema.Schema.optional(U128$1),
-  blobVersionedHashes: schema.Schema.Array(B256$1),
-  transactionStatus: TransactionStatus
+const Transaction = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  nonce: codec.RequiredCodec(codec.BigIntCodec),
+  from: codec.RequiredCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  value: codec.RequiredCodec(U256$1),
+  gasPrice: codec.OptionalCodec(U128$1),
+  gas: codec.RequiredCodec(U128$1),
+  maxFeePerGas: codec.OptionalCodec(U128$1),
+  maxPriorityFeePerGas: codec.OptionalCodec(U128$1),
+  input: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  signature: codec.OptionalCodec(Signature),
+  chainId: codec.OptionalCodec(codec.BigIntCodec),
+  accessList: codec.ArrayCodec(AccessListItem),
+  transactionType: codec.RequiredCodec(codec.BigIntCodec),
+  maxFeePerBlobGas: codec.OptionalCodec(U128$1),
+  blobVersionedHashes: codec.ArrayCodec(B256$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const TransactionReceipt = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  cumulativeGasUsed: U128$1,
-  gasUsed: U128$1,
-  effectiveGasPrice: U128$1,
-  from: Address$1,
-  to: schema.Schema.optional(Address$1),
-  contractAddress: schema.Schema.optional(Address$1),
-  logsBloom: Bloom,
-  transactionType: schema.Schema.BigIntFromSelf,
-  blobGasUsed: schema.Schema.optional(U128$1),
-  blobGasPrice: schema.Schema.optional(U128$1),
-  transactionStatus: TransactionStatus
+const TransactionReceipt = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  cumulativeGasUsed: codec.RequiredCodec(U128$1),
+  gasUsed: codec.RequiredCodec(U128$1),
+  effectiveGasPrice: codec.RequiredCodec(U128$1),
+  from: codec.RequiredCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  contractAddress: codec.OptionalCodec(Address$1),
+  logsBloom: codec.RequiredCodec(Bloom),
+  transactionType: codec.RequiredCodec(codec.BigIntCodec),
+  blobGasUsed: codec.OptionalCodec(U128$1),
+  blobGasPrice: codec.OptionalCodec(U128$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const Log = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  address: Address$1,
-  topics: schema.Schema.Array(B256$1),
-  data: protocol.BytesFromUint8Array,
-  logIndex: schema.Schema.Number,
-  logIndexInTransaction: schema.Schema.Number,
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  transactionStatus: TransactionStatus
+const Log = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  address: codec.RequiredCodec(Address$1),
+  topics: codec.ArrayCodec(B256$1),
+  data: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  logIndex: codec.RequiredCodec(codec.NumberCodec),
+  logIndexInTransaction: codec.RequiredCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const CallType = schema.Schema.transform(
-  schema.Schema.Enums(CallType$1),
-  schema.Schema.Literal(
-    "unknown",
-    "call",
-    "delegateCall",
-    "callCode",
-    "delegateCall",
-    "staticCall",
-    "authCall"
-  ),
-  {
-    decode(value) {
-      const enumMap = {
-        [CallType$1.CALL]: "call",
-        [CallType$1.CALL_CODE]: "callCode",
-        [CallType$1.DELEGATE_CALL]: "delegateCall",
-        [CallType$1.STATIC_CALL]: "staticCall",
-        [CallType$1.AUTH_CALL]: "authCall",
-        [CallType$1.UNSPECIFIED]: "unknown",
-        [CallType$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+const CallType = {
+  encode(x) {
+    const enumMap = {
+      unknown: CallType$1.UNSPECIFIED,
+      call: CallType$1.CALL,
+      callCode: CallType$1.CALL_CODE,
+      delegateCall: CallType$1.DELEGATE_CALL,
+      staticCall: CallType$1.STATIC_CALL,
+      authCall: CallType$1.AUTH_CALL
+    };
+    return enumMap[x] ?? CallType$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [CallType$1.CALL]: "call",
+      [CallType$1.CALL_CODE]: "callCode",
+      [CallType$1.DELEGATE_CALL]: "delegateCall",
+      [CallType$1.STATIC_CALL]: "staticCall",
+      [CallType$1.AUTH_CALL]: "authCall",
+      [CallType$1.UNSPECIFIED]: "unknown",
+      [CallType$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const CreationMethod = schema.Schema.transform(
-  schema.Schema.Enums(CreationMethod$1),
-  schema.Schema.Literal("unknown", "create", "create2", "eofCreate"),
-  {
-    decode(value) {
-      const enumMap = {
-        [CreationMethod$1.CREATE]: "create",
-        [CreationMethod$1.CREATE2]: "create2",
-        [CreationMethod$1.EOF_CREATE]: "eofCreate",
-        [CallType$1.UNSPECIFIED]: "unknown",
-        [CallType$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+};
+const CreationMethod = {
+  encode(x) {
+    const enumMap = {
+      unknown: CreationMethod$1.UNSPECIFIED,
+      create: CreationMethod$1.CREATE,
+      create2: CreationMethod$1.CREATE2,
+      eofCreate: CreationMethod$1.EOF_CREATE
+    };
+    return enumMap[x] ?? CreationMethod$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [CreationMethod$1.CREATE]: "create",
+      [CreationMethod$1.CREATE2]: "create2",
+      [CreationMethod$1.EOF_CREATE]: "eofCreate",
+      [CreationMethod$1.UNSPECIFIED]: "unknown",
+      [CreationMethod$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const CallAction = schema.Schema.Struct({
-  _tag: tag("call"),
-  call: schema.Schema.Struct({
-    fromAddress: Address$1,
-    type: CallType,
-    gas: schema.Schema.BigIntFromSelf,
-    input: protocol.BytesFromUint8Array,
-    toAddress: Address$1,
-    value: U256$1
-  })
+};
+const CallAction = codec.MessageCodec({
+  fromAddress: codec.RequiredCodec(Address$1),
+  type: codec.RequiredCodec(CallType),
+  gas: codec.RequiredCodec(codec.BigIntCodec),
+  input: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  toAddress: codec.RequiredCodec(Address$1),
+  value: codec.RequiredCodec(U256$1)
 });
-const CreateAction = schema.Schema.Struct({
-  _tag: tag("create"),
-  create: schema.Schema.Struct({
-    fromAddress: Address$1,
-    gas: schema.Schema.BigIntFromSelf,
-    init: protocol.BytesFromUint8Array,
-    value: U256$1,
-    creationMethod: CreationMethod
-  })
+const CreateAction = codec.MessageCodec({
+  fromAddress: codec.RequiredCodec(Address$1),
+  gas: codec.RequiredCodec(codec.BigIntCodec),
+  init: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  value: codec.RequiredCodec(U256$1),
+  creationMethod: codec.RequiredCodec(CreationMethod)
 });
-const SelfDestructAction = schema.Schema.Struct({
-  _tag: tag("selfDestruct"),
-  selfDestruct: schema.Schema.Struct({
-    address: Address$1,
-    balance: U256$1,
-    refundAddress: Address$1
-  })
+const SelfDestructAction = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  balance: codec.RequiredCodec(U256$1),
+  refundAddress: codec.RequiredCodec(Address$1)
 });
-const RewardType = schema.Schema.transform(
-  schema.Schema.Enums(RewardType$1),
-  schema.Schema.Literal("unknown", "block", "uncle"),
-  {
-    decode(value) {
-      const enumMap = {
-        [RewardType$1.BLOCK]: "block",
-        [RewardType$1.UNCLE]: "uncle",
-        [RewardType$1.UNSPECIFIED]: "unknown",
-        [RewardType$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+const RewardType = {
+  encode(x) {
+    const enumMap = {
+      unknown: RewardType$1.UNSPECIFIED,
+      block: RewardType$1.BLOCK,
+      uncle: RewardType$1.UNCLE
+    };
+    return enumMap[x] ?? RewardType$1.UNSPECIFIED;
+  },
+  decode(p) {
+    const enumMap = {
+      [RewardType$1.BLOCK]: "block",
+      [RewardType$1.UNCLE]: "uncle",
+      [RewardType$1.UNSPECIFIED]: "unknown",
+      [RewardType$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const RewardAction = schema.Schema.Struct({
-  _tag: tag("reward"),
-  reward: schema.Schema.Struct({
-    author: Address$1,
-    type: RewardType,
-    value: U256$1
-  })
+};
+const RewardAction = codec.MessageCodec({
+  author: codec.RequiredCodec(Address$1),
+  type: codec.RequiredCodec(RewardType),
+  value: codec.RequiredCodec(U256$1)
 });
-const CallOutput = schema.Schema.Struct({
-  _tag: tag("callOutput"),
-  callOutput: schema.Schema.Struct({
-    gasUsed: schema.Schema.BigIntFromSelf,
-    output: protocol.BytesFromUint8Array
-  })
+const CallOutput = codec.MessageCodec({
+  gasUsed: codec.RequiredCodec(codec.BigIntCodec),
+  output: codec.RequiredCodec(protocol.BytesFromUint8Array)
 });
-const CreateOutput = schema.Schema.Struct({
-  _tag: tag("createOutput"),
-  createOutput: schema.Schema.Struct({
-    address: Address$1,
-    code: protocol.BytesFromUint8Array,
-    gasUsed: schema.Schema.BigIntFromSelf
-  })
+const CreateOutput = codec.MessageCodec({
+  address: codec.RequiredCodec(Address$1),
+  code: codec.RequiredCodec(protocol.BytesFromUint8Array),
+  gasUsed: codec.RequiredCodec(codec.BigIntCodec)
 });
-const Trace = schema.Schema.Struct({
-  action: schema.Schema.Union(
-    CallAction,
-    CreateAction,
-    SelfDestructAction,
-    RewardAction
+const Trace = codec.MessageCodec({
+  action: codec.RequiredCodec(
+    codec.OneOfCodec({
+      call: CallAction,
+      create: CreateAction,
+      selfDestruct: SelfDestructAction,
+      reward: RewardAction
+    })
   ),
-  error: schema.Schema.optional(schema.Schema.String),
-  output: schema.Schema.optional(schema.Schema.Union(CallOutput, CreateOutput)),
-  subtraces: schema.Schema.Number,
-  traceAddress: schema.Schema.Array(schema.Schema.Number)
+  error: codec.OptionalCodec(codec.StringCodec),
+  output: codec.OptionalCodec(
+    codec.OneOfCodec({
+      callOutput: CallOutput,
+      createOutput: CreateOutput
+    })
+  ),
+  subtraces: codec.RequiredCodec(codec.NumberCodec),
+  traceAddress: codec.ArrayCodec(codec.NumberCodec)
 });
-const TransactionTrace = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  transactionIndex: schema.Schema.Number,
-  transactionHash: B256$1,
-  traces: schema.Schema.Array(Trace)
+const TransactionTrace = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(B256$1),
+  traces: codec.ArrayCodec(Trace)
 });
-const Block = schema.Schema.Struct({
-  header: BlockHeader,
-  withdrawals: schema.Schema.Array(Withdrawal),
-  transactions: schema.Schema.Array(Transaction),
-  receipts: schema.Schema.Array(TransactionReceipt),
-  logs: schema.Schema.Array(Log),
-  traces: schema.Schema.Array(TransactionTrace)
+const Block = codec.MessageCodec({
+  header: codec.RequiredCodec(BlockHeader),
+  withdrawals: codec.ArrayCodec(Withdrawal),
+  transactions: codec.ArrayCodec(Transaction),
+  receipts: codec.ArrayCodec(TransactionReceipt),
+  logs: codec.ArrayCodec(Log),
+  traces: codec.ArrayCodec(TransactionTrace)
 });
-const BlockFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  schema.Schema.NullOr(Block),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return Block$1.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return Block$1.encode(value).finish();
-    }
+const BlockFromBytes = {
+  encode(x) {
+    const block = Block.encode(x);
+    return Block$1.encode(block).finish();
+  },
+  decode(p) {
+    const block = Block$1.decode(p);
+    return Block.decode(block);
   }
-);
+};
 
-const OptionalArray = (schema$1) => schema.Schema.optional(schema.Schema.Array(schema$1));
-const HeaderFilter = schema.Schema.transform(
-  schema.Schema.Enums(HeaderFilter$1),
-  schema.Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [HeaderFilter$1.ALWAYS]: "always",
-        [HeaderFilter$1.ON_DATA]: "on_data",
-        [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
-        [HeaderFilter$1.UNSPECIFIED]: "unknown",
-        [HeaderFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return HeaderFilter$1.ALWAYS;
-        case "on_data":
-          return HeaderFilter$1.ON_DATA;
-        case "on_data_or_on_new_block":
-          return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return HeaderFilter$1.UNSPECIFIED;
-      }
-    }
+const HeaderFilter = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return HeaderFilter$1.ALWAYS;
+      case "on_data":
+        return HeaderFilter$1.ON_DATA;
+      case "on_data_or_on_new_block":
+        return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return HeaderFilter$1.UNSPECIFIED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [HeaderFilter$1.ALWAYS]: "always",
+      [HeaderFilter$1.ON_DATA]: "on_data",
+      [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
+      [HeaderFilter$1.UNSPECIFIED]: "unknown",
+      [HeaderFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const WithdrawalFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  validatorIndex: schema.Schema.optional(schema.Schema.Number),
-  address: schema.Schema.optional(Address$1)
+};
+const WithdrawalFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  validatorIndex: codec.OptionalCodec(codec.NumberCodec),
+  address: codec.OptionalCodec(Address$1)
 });
-const TransactionStatusFilter = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatusFilter$1),
-  schema.Schema.Literal("succeeded", "reverted", "all", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
-        [TransactionStatusFilter$1.REVERTED]: "reverted",
-        [TransactionStatusFilter$1.ALL]: "all",
-        [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
-        [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "succeeded":
-          return TransactionStatusFilter$1.SUCCEEDED;
-        case "reverted":
-          return TransactionStatusFilter$1.REVERTED;
-        case "all":
-          return TransactionStatusFilter$1.ALL;
-        default:
-          return TransactionStatusFilter$1.UNSPECIFIED;
-      }
+const TransactionStatusFilter = {
+  decode(value) {
+    const enumMap = {
+      [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
+      [TransactionStatusFilter$1.REVERTED]: "reverted",
+      [TransactionStatusFilter$1.ALL]: "all",
+      [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
+      [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[value] ?? "unknown";
+  },
+  encode(value) {
+    switch (value) {
+      case "succeeded":
+        return TransactionStatusFilter$1.SUCCEEDED;
+      case "reverted":
+        return TransactionStatusFilter$1.REVERTED;
+      case "all":
+        return TransactionStatusFilter$1.ALL;
+      default:
+        return TransactionStatusFilter$1.UNSPECIFIED;
     }
   }
-);
-const Topic = schema.Schema.transform(
-  schema.Schema.Struct({ value: schema.Schema.UndefinedOr(B256Proto) }),
-  schema.Schema.NullOr(B256$1),
-  {
-    decode({ value }) {
-      if (value === void 0) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: void 0 };
-      }
-      return { value };
+};
+const Topic = {
+  encode(x) {
+    if (x === null) {
+      return { value: void 0 };
     }
+    return { value: B256$1.encode(x) };
+  },
+  decode({ value }) {
+    if (value === void 0) {
+      return null;
+    }
+    return B256$1.decode(value);
   }
-);
-const LogFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  address: schema.Schema.optional(Address$1),
-  topics: OptionalArray(Topic),
-  strict: schema.Schema.optional(schema.Schema.Boolean),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeTransaction: schema.Schema.optional(schema.Schema.Boolean),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeTransactionTrace: schema.Schema.optional(schema.Schema.Boolean)
+};
+const LogFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  address: codec.OptionalCodec(Address$1),
+  topics: codec.OptionalCodec(codec.ArrayCodec(Topic)),
+  strict: codec.OptionalCodec(codec.BooleanCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeTransaction: codec.OptionalCodec(codec.BooleanCodec),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const TransactionFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  from: schema.Schema.optional(Address$1),
-  to: schema.Schema.optional(Address$1),
-  create: schema.Schema.optional(schema.Schema.Boolean),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeLogs: schema.Schema.optional(schema.Schema.Boolean),
-  includeTransactionTrace: schema.Schema.optional(schema.Schema.Boolean)
+const TransactionFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  from: codec.OptionalCodec(Address$1),
+  to: codec.OptionalCodec(Address$1),
+  create: codec.OptionalCodec(codec.BooleanCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeLogs: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const Filter = schema.Schema.Struct({
-  header: schema.Schema.optional(HeaderFilter),
-  withdrawals: OptionalArray(WithdrawalFilter),
-  transactions: OptionalArray(TransactionFilter),
-  logs: OptionalArray(LogFilter)
+const Filter = codec.MessageCodec({
+  header: codec.OptionalCodec(HeaderFilter),
+  withdrawals: codec.OptionalCodec(codec.ArrayCodec(WithdrawalFilter)),
+  transactions: codec.OptionalCodec(codec.ArrayCodec(TransactionFilter)),
+  logs: codec.OptionalCodec(codec.ArrayCodec(LogFilter))
 });
-const filterToProto = schema.Schema.encodeSync(Filter);
-const filterFromProto = schema.Schema.decodeSync(Filter);
-const FilterFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  Filter,
-  {
-    strict: false,
-    decode(value) {
-      return Filter$1.decode(value);
-    },
-    encode(value) {
-      return Filter$1.encode(value).finish();
-    }
+const FilterFromBytes = {
+  encode(x) {
+    return Filter$1.encode(Filter.encode(x)).finish();
+  },
+  decode(p) {
+    return Filter.decode(Filter$1.decode(p));
   }
-);
-const filterToBytes = schema.Schema.encodeSync(FilterFromBytes);
-const filterFromBytes = schema.Schema.decodeSync(FilterFromBytes);
+};
 function mergeFilter(a, b) {
   const header = mergeHeaderFilter(a.header, b.header);
   return {
@@ -4513,7 +4435,6 @@ const EvmStream = new protocol.StreamConfig(
 exports.AccessListItem = AccessListItem;
 exports.Address = Address$1;
 exports.B256 = B256$1;
-exports.B256Proto = B256Proto;
 exports.Block = Block;
 exports.BlockFromBytes = BlockFromBytes;
 exports.BlockHeader = BlockHeader;
@@ -4546,15 +4467,5 @@ exports.U128 = U128$1;
 exports.U256 = U256$1;
 exports.Withdrawal = Withdrawal;
 exports.WithdrawalFilter = WithdrawalFilter;
-exports.b256FromProto = b256FromProto;
-exports.b256ToProto = b256ToProto;
-exports.filterFromBytes = filterFromBytes;
-exports.filterFromProto = filterFromProto;
-exports.filterToBytes = filterToBytes;
-exports.filterToProto = filterToProto;
 exports.mergeFilter = mergeFilter;
 exports.proto = index;
-exports.u128FromProto = u128FromProto;
-exports.u128ToProto = u128ToProto;
-exports.u256FromProto = u256FromProto;
-exports.u256ToProto = u256ToProto;