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

package/dist/index.mjs

@@ -1,102 +1,73 @@
-import { BytesFromUint8Array, Bytes, StreamConfig } from '@apibara/protocol';
-import { Schema } from '@effect/schema';
-import { hexToBytes, pad } from 'viem';
+import { BytesFromUint8Array, StreamConfig } from '@apibara/protocol';
+import { MessageCodec, RequiredCodec, BigIntCodec, DateCodec, OptionalCodec, ArrayCodec, NumberCodec, BooleanCodec, OneOfCodec, StringCodec } from '@apibara/protocol/codec';
 import Long from 'long';
 import _m0 from 'protobufjs/minimal.js';
 
 const MAX_U64 = 0xffffffffffffffffn;
-const _Address = Schema.TemplateLiteral(Schema.Literal("0x"), Schema.String);
-const AddressProto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.Number
-});
-const Address$1 = 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 = hexToBytes(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.TemplateLiteral(Schema.Literal("0x"), Schema.String);
-const B256Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf
-});
-const B256$1 = 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 = hexToBytes(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.encodeSync(B256$1);
-const b256FromProto = Schema.decodeSync(B256$1);
-const U256Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf
-});
-const U256$1 = Schema.transform(U256Proto, 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.encodeSync(U256$1);
-const u256FromProto = Schema.decodeSync(U256$1);
-const U128Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf
-});
-const U128$1 = Schema.transform(U128Proto, 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.encodeSync(U128$1);
-const u128FromProto = Schema.decodeSync(U128$1);
-
-function tag(tag2) {
-  return Schema.Literal(tag2).pipe(
-    Schema.propertySignature,
-    Schema.fromKey("$case")
-  );
-}
+};
 
 const protobufPackage$2 = "evm.v2";
 function createBaseAddress() {
@@ -971,7 +942,8 @@ function createBaseBlockHeader() {
     totalDifficulty: void 0,
     blobGasUsed: void 0,
     excessBlobGas: void 0,
-    parentBeaconBlockRoot: void 0
+    parentBeaconBlockRoot: void 0,
+    requestsHash: void 0
   };
 }
 const BlockHeader$1 = {
@@ -1048,6 +1020,9 @@ const BlockHeader$1 = {
     if (message.parentBeaconBlockRoot !== void 0) {
       B256.encode(message.parentBeaconBlockRoot, writer.uint32(178).fork()).ldelim();
     }
+    if (message.requestsHash !== void 0) {
+      B256.encode(message.requestsHash, writer.uint32(186).fork()).ldelim();
+    }
     return writer;
   },
   decode(input, length) {
@@ -1189,6 +1164,12 @@ const BlockHeader$1 = {
           }
           message.parentBeaconBlockRoot = B256.decode(reader, reader.uint32());
           continue;
+        case 23:
+          if (tag !== 186) {
+            break;
+          }
+          message.requestsHash = B256.decode(reader, reader.uint32());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1220,7 +1201,8 @@ const BlockHeader$1 = {
       totalDifficulty: isSet$1(object.totalDifficulty) ? U256.fromJSON(object.totalDifficulty) : void 0,
       blobGasUsed: isSet$1(object.blobGasUsed) ? U128.fromJSON(object.blobGasUsed) : void 0,
       excessBlobGas: isSet$1(object.excessBlobGas) ? U128.fromJSON(object.excessBlobGas) : void 0,
-      parentBeaconBlockRoot: isSet$1(object.parentBeaconBlockRoot) ? B256.fromJSON(object.parentBeaconBlockRoot) : void 0
+      parentBeaconBlockRoot: isSet$1(object.parentBeaconBlockRoot) ? B256.fromJSON(object.parentBeaconBlockRoot) : void 0,
+      requestsHash: isSet$1(object.requestsHash) ? B256.fromJSON(object.requestsHash) : void 0
     };
   },
   toJSON(message) {
@@ -1291,6 +1273,9 @@ const BlockHeader$1 = {
     if (message.parentBeaconBlockRoot !== void 0) {
       obj.parentBeaconBlockRoot = B256.toJSON(message.parentBeaconBlockRoot);
     }
+    if (message.requestsHash !== void 0) {
+      obj.requestsHash = B256.toJSON(message.requestsHash);
+    }
     return obj;
   },
   create(base) {
@@ -1320,6 +1305,7 @@ const BlockHeader$1 = {
     message.blobGasUsed = object.blobGasUsed !== void 0 && object.blobGasUsed !== null ? U128.fromPartial(object.blobGasUsed) : void 0;
     message.excessBlobGas = object.excessBlobGas !== void 0 && object.excessBlobGas !== null ? U128.fromPartial(object.excessBlobGas) : void 0;
     message.parentBeaconBlockRoot = object.parentBeaconBlockRoot !== void 0 && object.parentBeaconBlockRoot !== null ? B256.fromPartial(object.parentBeaconBlockRoot) : void 0;
+    message.requestsHash = object.requestsHash !== void 0 && object.requestsHash !== null ? B256.fromPartial(object.requestsHash) : void 0;
     return message;
   }
 };
@@ -4046,416 +4032,368 @@ const index = {
   filter: filter
 };
 
-const Bloom = Schema.transform(
-  Schema.Struct({
-    value: BytesFromUint8Array
-  }),
-  Bytes,
-  {
-    strict: false,
-    encode(value) {
-      throw new Error("Not implemented");
-    },
-    decode({ value }) {
-      return value;
-    }
+const Bloom = {
+  encode(x) {
+    return { value: BytesFromUint8Array.encode(x) };
+  },
+  decode({ value }) {
+    return BytesFromUint8Array.decode(value);
   }
-);
-const TransactionStatus = Schema.transform(
-  Schema.Enums(TransactionStatus$1),
-  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.Struct({
-  blockNumber: 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.DateFromSelf,
-  extraData: BytesFromUint8Array,
-  mixHash: Schema.optional(B256$1),
-  nonce: Schema.optional(Schema.BigIntFromSelf),
-  baseFeePerGas: Schema.optional(U128$1),
-  withdrawalsRoot: Schema.optional(B256$1),
-  totalDifficulty: Schema.optional(U256$1),
-  blobGasUsed: Schema.optional(U128$1),
-  excessBlobGas: Schema.optional(U128$1),
-  parentBeaconBlockRoot: Schema.optional(B256$1)
+};
+const BlockHeader = MessageCodec({
+  blockNumber: RequiredCodec(BigIntCodec),
+  blockHash: RequiredCodec(B256$1),
+  parentBlockHash: RequiredCodec(B256$1),
+  unclesHash: RequiredCodec(B256$1),
+  miner: RequiredCodec(Address$1),
+  stateRoot: RequiredCodec(B256$1),
+  transactionsRoot: RequiredCodec(B256$1),
+  receiptsRoot: RequiredCodec(B256$1),
+  logsBloom: RequiredCodec(Bloom),
+  difficulty: RequiredCodec(U256$1),
+  gasLimit: RequiredCodec(U128$1),
+  gasUsed: RequiredCodec(U128$1),
+  timestamp: RequiredCodec(DateCodec),
+  extraData: RequiredCodec(BytesFromUint8Array),
+  mixHash: OptionalCodec(B256$1),
+  nonce: OptionalCodec(BigIntCodec),
+  baseFeePerGas: OptionalCodec(U128$1),
+  withdrawalsRoot: OptionalCodec(B256$1),
+  totalDifficulty: OptionalCodec(U256$1),
+  blobGasUsed: OptionalCodec(U128$1),
+  excessBlobGas: OptionalCodec(U128$1),
+  parentBeaconBlockRoot: OptionalCodec(B256$1),
+  requestsHash: OptionalCodec(B256$1)
 });
-const Withdrawal = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  withdrawalIndex: Schema.Number,
-  index: Schema.BigIntFromSelf,
-  validatorIndex: Schema.Number,
-  address: Address$1,
-  amount: Schema.BigIntFromSelf
+const Withdrawal = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  withdrawalIndex: RequiredCodec(NumberCodec),
+  index: RequiredCodec(BigIntCodec),
+  validatorIndex: RequiredCodec(NumberCodec),
+  address: RequiredCodec(Address$1),
+  amount: RequiredCodec(BigIntCodec)
 });
-const AccessListItem = Schema.Struct({
-  address: Address$1,
-  storageKeys: Schema.Array(B256$1)
+const AccessListItem = MessageCodec({
+  address: RequiredCodec(Address$1),
+  storageKeys: ArrayCodec(B256$1)
 });
-const Signature = Schema.Struct({
-  r: U256$1,
-  s: U256$1,
-  v: U256$1,
-  YParity: Schema.optional(Schema.Boolean)
+const Signature = MessageCodec({
+  r: RequiredCodec(U256$1),
+  s: RequiredCodec(U256$1),
+  v: OptionalCodec(U256$1),
+  YParity: OptionalCodec(BooleanCodec)
 });
-const Transaction = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256$1,
-  nonce: Schema.BigIntFromSelf,
-  from: Address$1,
-  to: Schema.optional(Address$1),
-  value: U256$1,
-  gasPrice: Schema.optional(U128$1),
-  gas: U128$1,
-  maxFeePerGas: Schema.optional(U128$1),
-  maxPriorityFeePerGas: Schema.optional(U128$1),
-  input: BytesFromUint8Array,
-  signature: Schema.optional(Signature),
-  chainId: Schema.optional(Schema.BigIntFromSelf),
-  accessList: Schema.Array(AccessListItem),
-  transactionType: Schema.BigIntFromSelf,
-  maxFeePerBlobGas: Schema.optional(U128$1),
-  blobVersionedHashes: Schema.Array(B256$1),
-  transactionStatus: TransactionStatus
+const Transaction = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256$1),
+  nonce: RequiredCodec(BigIntCodec),
+  from: RequiredCodec(Address$1),
+  to: OptionalCodec(Address$1),
+  value: RequiredCodec(U256$1),
+  gasPrice: OptionalCodec(U128$1),
+  gas: RequiredCodec(U128$1),
+  maxFeePerGas: OptionalCodec(U128$1),
+  maxPriorityFeePerGas: OptionalCodec(U128$1),
+  input: RequiredCodec(BytesFromUint8Array),
+  signature: OptionalCodec(Signature),
+  chainId: OptionalCodec(BigIntCodec),
+  accessList: ArrayCodec(AccessListItem),
+  transactionType: RequiredCodec(BigIntCodec),
+  maxFeePerBlobGas: OptionalCodec(U128$1),
+  blobVersionedHashes: ArrayCodec(B256$1),
+  transactionStatus: RequiredCodec(TransactionStatus)
 });
-const TransactionReceipt = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256$1,
-  cumulativeGasUsed: U128$1,
-  gasUsed: U128$1,
-  effectiveGasPrice: U128$1,
-  from: Address$1,
-  to: Schema.optional(Address$1),
-  contractAddress: Schema.optional(Address$1),
-  logsBloom: Bloom,
-  transactionType: Schema.BigIntFromSelf,
-  blobGasUsed: Schema.optional(U128$1),
-  blobGasPrice: Schema.optional(U128$1),
-  transactionStatus: TransactionStatus
+const TransactionReceipt = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256$1),
+  cumulativeGasUsed: RequiredCodec(U128$1),
+  gasUsed: RequiredCodec(U128$1),
+  effectiveGasPrice: RequiredCodec(U128$1),
+  from: RequiredCodec(Address$1),
+  to: OptionalCodec(Address$1),
+  contractAddress: OptionalCodec(Address$1),
+  logsBloom: RequiredCodec(Bloom),
+  transactionType: RequiredCodec(BigIntCodec),
+  blobGasUsed: OptionalCodec(U128$1),
+  blobGasPrice: OptionalCodec(U128$1),
+  transactionStatus: RequiredCodec(TransactionStatus)
 });
-const Log = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  address: Address$1,
-  topics: Schema.Array(B256$1),
-  data: BytesFromUint8Array,
-  logIndex: Schema.Number,
-  logIndexInTransaction: Schema.Number,
-  transactionIndex: Schema.Number,
-  transactionHash: B256$1,
-  transactionStatus: TransactionStatus
+const Log = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  address: RequiredCodec(Address$1),
+  topics: ArrayCodec(B256$1),
+  data: RequiredCodec(BytesFromUint8Array),
+  logIndex: RequiredCodec(NumberCodec),
+  logIndexInTransaction: RequiredCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256$1),
+  transactionStatus: RequiredCodec(TransactionStatus)
 });
-const CallType = Schema.transform(
-  Schema.Enums(CallType$1),
-  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.transform(
-  Schema.Enums(CreationMethod$1),
-  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.Struct({
-  _tag: tag("call"),
-  call: Schema.Struct({
-    fromAddress: Address$1,
-    type: CallType,
-    gas: Schema.BigIntFromSelf,
-    input: BytesFromUint8Array,
-    toAddress: Address$1,
-    value: U256$1
-  })
+};
+const CallAction = MessageCodec({
+  fromAddress: RequiredCodec(Address$1),
+  type: RequiredCodec(CallType),
+  gas: RequiredCodec(BigIntCodec),
+  input: RequiredCodec(BytesFromUint8Array),
+  toAddress: RequiredCodec(Address$1),
+  value: RequiredCodec(U256$1)
 });
-const CreateAction = Schema.Struct({
-  _tag: tag("create"),
-  create: Schema.Struct({
-    fromAddress: Address$1,
-    gas: Schema.BigIntFromSelf,
-    init: BytesFromUint8Array,
-    value: U256$1,
-    creationMethod: CreationMethod
-  })
+const CreateAction = MessageCodec({
+  fromAddress: RequiredCodec(Address$1),
+  gas: RequiredCodec(BigIntCodec),
+  init: RequiredCodec(BytesFromUint8Array),
+  value: RequiredCodec(U256$1),
+  creationMethod: RequiredCodec(CreationMethod)
 });
-const SelfDestructAction = Schema.Struct({
-  _tag: tag("selfDestruct"),
-  selfDestruct: Schema.Struct({
-    address: Address$1,
-    balance: U256$1,
-    refundAddress: Address$1
-  })
+const SelfDestructAction = MessageCodec({
+  address: RequiredCodec(Address$1),
+  balance: RequiredCodec(U256$1),
+  refundAddress: RequiredCodec(Address$1)
 });
-const RewardType = Schema.transform(
-  Schema.Enums(RewardType$1),
-  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.Struct({
-  _tag: tag("reward"),
-  reward: Schema.Struct({
-    author: Address$1,
-    type: RewardType,
-    value: U256$1
-  })
+};
+const RewardAction = MessageCodec({
+  author: RequiredCodec(Address$1),
+  type: RequiredCodec(RewardType),
+  value: RequiredCodec(U256$1)
 });
-const CallOutput = Schema.Struct({
-  _tag: tag("callOutput"),
-  callOutput: Schema.Struct({
-    gasUsed: Schema.BigIntFromSelf,
-    output: BytesFromUint8Array
-  })
+const CallOutput = MessageCodec({
+  gasUsed: RequiredCodec(BigIntCodec),
+  output: RequiredCodec(BytesFromUint8Array)
 });
-const CreateOutput = Schema.Struct({
-  _tag: tag("createOutput"),
-  createOutput: Schema.Struct({
-    address: Address$1,
-    code: BytesFromUint8Array,
-    gasUsed: Schema.BigIntFromSelf
-  })
+const CreateOutput = MessageCodec({
+  address: RequiredCodec(Address$1),
+  code: RequiredCodec(BytesFromUint8Array),
+  gasUsed: RequiredCodec(BigIntCodec)
 });
-const Trace = Schema.Struct({
-  action: Schema.Union(
-    CallAction,
-    CreateAction,
-    SelfDestructAction,
-    RewardAction
+const Trace = MessageCodec({
+  action: RequiredCodec(
+    OneOfCodec({
+      call: CallAction,
+      create: CreateAction,
+      selfDestruct: SelfDestructAction,
+      reward: RewardAction
+    })
+  ),
+  error: OptionalCodec(StringCodec),
+  output: OptionalCodec(
+    OneOfCodec({
+      callOutput: CallOutput,
+      createOutput: CreateOutput
+    })
   ),
-  error: Schema.optional(Schema.String),
-  output: Schema.optional(Schema.Union(CallOutput, CreateOutput)),
-  subtraces: Schema.Number,
-  traceAddress: Schema.Array(Schema.Number)
+  subtraces: RequiredCodec(NumberCodec),
+  traceAddress: ArrayCodec(NumberCodec)
 });
-const TransactionTrace = Schema.Struct({
-  filterIds: Schema.Array(Schema.Number),
-  transactionIndex: Schema.Number,
-  transactionHash: B256$1,
-  traces: Schema.Array(Trace)
+const TransactionTrace = MessageCodec({
+  filterIds: ArrayCodec(NumberCodec),
+  transactionIndex: RequiredCodec(NumberCodec),
+  transactionHash: RequiredCodec(B256$1),
+  traces: ArrayCodec(Trace)
 });
-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)
+const Block = MessageCodec({
+  header: RequiredCodec(BlockHeader),
+  withdrawals: ArrayCodec(Withdrawal),
+  transactions: ArrayCodec(Transaction),
+  receipts: ArrayCodec(TransactionReceipt),
+  logs: ArrayCodec(Log),
+  traces: ArrayCodec(TransactionTrace)
 });
-const BlockFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  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) => Schema.optional(Schema.Array(schema));
-const HeaderFilter = Schema.transform(
-  Schema.Enums(HeaderFilter$1),
-  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.Struct({
-  id: Schema.optional(Schema.Number),
-  validatorIndex: Schema.optional(Schema.Number),
-  address: Schema.optional(Address$1)
+};
+const WithdrawalFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  validatorIndex: OptionalCodec(NumberCodec),
+  address: OptionalCodec(Address$1)
 });
-const TransactionStatusFilter = Schema.transform(
-  Schema.Enums(TransactionStatusFilter$1),
-  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.transform(
-  Schema.Struct({ value: Schema.UndefinedOr(B256Proto) }),
-  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.Struct({
-  id: Schema.optional(Schema.Number),
-  address: Schema.optional(Address$1),
-  topics: OptionalArray(Topic),
-  strict: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeTransactionTrace: Schema.optional(Schema.Boolean)
+};
+const LogFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  address: OptionalCodec(Address$1),
+  topics: OptionalCodec(ArrayCodec(Topic)),
+  strict: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec)
 });
-const TransactionFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  from: Schema.optional(Address$1),
-  to: Schema.optional(Address$1),
-  create: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeLogs: Schema.optional(Schema.Boolean),
-  includeTransactionTrace: Schema.optional(Schema.Boolean)
+const TransactionFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  from: OptionalCodec(Address$1),
+  to: OptionalCodec(Address$1),
+  create: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeLogs: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec)
 });
-const Filter = Schema.Struct({
-  header: Schema.optional(HeaderFilter),
-  withdrawals: OptionalArray(WithdrawalFilter),
-  transactions: OptionalArray(TransactionFilter),
-  logs: OptionalArray(LogFilter)
+const Filter = MessageCodec({
+  header: OptionalCodec(HeaderFilter),
+  withdrawals: OptionalCodec(ArrayCodec(WithdrawalFilter)),
+  transactions: OptionalCodec(ArrayCodec(TransactionFilter)),
+  logs: OptionalCodec(ArrayCodec(LogFilter))
 });
-const filterToProto = Schema.encodeSync(Filter);
-const filterFromProto = Schema.decodeSync(Filter);
-const FilterFromBytes = Schema.transform(
-  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.encodeSync(FilterFromBytes);
-const filterFromBytes = Schema.decodeSync(FilterFromBytes);
+};
 function mergeFilter(a, b) {
   const header = mergeHeaderFilter(a.header, b.header);
   return {
@@ -4487,4 +4425,4 @@ const EvmStream = new StreamConfig(
   mergeFilter
 );
 
-export { AccessListItem, Address$1 as Address, B256$1 as B256, B256Proto, Block, BlockFromBytes, BlockHeader, Bloom, CallAction, CallOutput, CallType, CreateAction, CreateOutput, CreationMethod, EvmStream, Filter, FilterFromBytes, HeaderFilter, Log, LogFilter, RewardAction, RewardType, SelfDestructAction, Signature, Topic, Trace, Transaction, TransactionFilter, TransactionReceipt, TransactionStatus, TransactionStatusFilter, TransactionTrace, U128$1 as U128, U256$1 as U256, Withdrawal, WithdrawalFilter, b256FromProto, b256ToProto, filterFromBytes, filterFromProto, filterToBytes, filterToProto, mergeFilter, index as proto, u128FromProto, u128ToProto, u256FromProto, u256ToProto };
+export { AccessListItem, Address$1 as Address, B256$1 as B256, Block, BlockFromBytes, BlockHeader, Bloom, CallAction, CallOutput, CallType, CreateAction, CreateOutput, CreationMethod, EvmStream, Filter, FilterFromBytes, HeaderFilter, Log, LogFilter, RewardAction, RewardType, SelfDestructAction, Signature, Topic, Trace, Transaction, TransactionFilter, TransactionReceipt, TransactionStatus, TransactionStatusFilter, TransactionTrace, U128$1 as U128, U256$1 as U256, Withdrawal, WithdrawalFilter, mergeFilter, index as proto };