@apibara/starknet 2.1.0-beta.4 → 2.1.0-beta.41

package/src/filter.ts

@@ -1,7 +1,14 @@
-import { Schema } from "@effect/schema";
-
-import { FieldElement, FieldElementProto } from "./common";
-import { tag } from "./helpers";
+import {
+  ArrayCodec,
+  BooleanCodec,
+  type Codec,
+  type CodecType,
+  MessageCodec,
+  NumberCodec,
+  OneOfCodec,
+  OptionalCodec,
+} from "@apibara/protocol/codec";
+import { FieldElement } from "./common";
 import * as proto from "./proto";
 
 /** Header options.
@@ -10,90 +17,87 @@ import * as proto from "./proto";
  * - `on_data`: receive headers only if any other filter matches.
  * - `on_data_or_on_new_block`: receive headers only if any other filter matches and for "live" blocks.
  */
-export const HeaderFilter = Schema.transform(
-  Schema.Enums(proto.filter.HeaderFilter),
-  Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.filter.HeaderFilter.ALWAYS]: "always",
-        [proto.filter.HeaderFilter.ON_DATA]: "on_data",
-        [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
-          "on_data_or_on_new_block",
-        [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
-        [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
-      } as const;
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return proto.filter.HeaderFilter.ALWAYS;
-        case "on_data":
-          return proto.filter.HeaderFilter.ON_DATA;
-        case "on_data_or_on_new_block":
-          return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return proto.filter.HeaderFilter.UNSPECIFIED;
-      }
-    },
+export const HeaderFilter: Codec<
+  "always" | "on_data" | "on_data_or_on_new_block" | "unknown",
+  proto.filter.HeaderFilter
+> = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return proto.filter.HeaderFilter.ALWAYS;
+      case "on_data":
+        return proto.filter.HeaderFilter.ON_DATA;
+      case "on_data_or_on_new_block":
+        return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return proto.filter.HeaderFilter.UNSPECIFIED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.filter.HeaderFilter.ALWAYS]: "always",
+      [proto.filter.HeaderFilter.ON_DATA]: "on_data",
+      [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
+        "on_data_or_on_new_block",
+      [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
+      [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
+    } as const;
+    return enumMap[p] ?? "unknown";
   },
-);
+};
 
-export type HeaderFilter = typeof HeaderFilter.Type;
+export type HeaderFilter = CodecType<typeof HeaderFilter>;
 
 /** An event key filter. Use `null` to match any event key. */
-export const Key = Schema.transform(
-  Schema.Struct({ value: Schema.UndefinedOr(FieldElementProto) }),
-  Schema.NullOr(FieldElement),
-  {
-    decode({ value }) {
-      if (value === undefined) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: undefined };
-      }
-      return { value };
-    },
+export const Key: Codec<
+  FieldElement | null,
+  { value?: proto.common.FieldElement | undefined }
+> = {
+  encode(x) {
+    if (x === null) {
+      return { value: undefined };
+    }
+    return { value: FieldElement.encode(x) };
+  },
+  decode(p) {
+    if (p.value === undefined) {
+      return null;
+    }
+    return FieldElement.decode(p.value);
   },
-);
-
-export type Key = typeof Key.Type;
-
-export const TransactionStatusFilter = Schema.transform(
-  Schema.Enums(proto.filter.TransactionStatusFilter),
-  Schema.Literal("succeeded", "reverted", "all", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.filter.TransactionStatusFilter.SUCCEEDED]: "succeeded",
-        [proto.filter.TransactionStatusFilter.REVERTED]: "reverted",
-        [proto.filter.TransactionStatusFilter.ALL]: "all",
-        [proto.filter.TransactionStatusFilter.UNSPECIFIED]: "unknown",
-        [proto.filter.TransactionStatusFilter.UNRECOGNIZED]: "unknown",
-      } as const;
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "succeeded":
-          return proto.filter.TransactionStatusFilter.SUCCEEDED;
-        case "reverted":
-          return proto.filter.TransactionStatusFilter.REVERTED;
-        case "all":
-          return proto.filter.TransactionStatusFilter.ALL;
-        default:
-          return proto.filter.TransactionStatusFilter.UNSPECIFIED;
-      }
-    },
+};
+
+export type Key = CodecType<typeof Key>;
+
+export const TransactionStatusFilter: Codec<
+  "succeeded" | "reverted" | "all" | "unknown",
+  proto.filter.TransactionStatusFilter
+> = {
+  encode(x) {
+    switch (x) {
+      case "succeeded":
+        return proto.filter.TransactionStatusFilter.SUCCEEDED;
+      case "reverted":
+        return proto.filter.TransactionStatusFilter.REVERTED;
+      case "all":
+        return proto.filter.TransactionStatusFilter.ALL;
+      default:
+        return proto.filter.TransactionStatusFilter.UNSPECIFIED;
+    }
   },
-);
+  decode(p) {
+    const enumMap = {
+      [proto.filter.TransactionStatusFilter.SUCCEEDED]: "succeeded",
+      [proto.filter.TransactionStatusFilter.REVERTED]: "reverted",
+      [proto.filter.TransactionStatusFilter.ALL]: "all",
+      [proto.filter.TransactionStatusFilter.UNSPECIFIED]: "unknown",
+      [proto.filter.TransactionStatusFilter.UNRECOGNIZED]: "unknown",
+    } as const;
+    return enumMap[p] ?? "unknown";
+  },
+};
 
-export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
+export type TransactionStatusFilter = CodecType<typeof TransactionStatusFilter>;
 
 /** Filter events.
  *
@@ -106,20 +110,22 @@ export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeMessages Include the messages that were sent to L1 in the same transaction.
  * @prop includeSiblings Include the sibling events of the matched events.
+ * @prop includeTransactionTrace Include the trace of the transaction that emitted the event.
  */
-export const EventFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  address: Schema.optional(FieldElement),
-  keys: Schema.optional(Schema.Array(Key)),
-  strict: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeMessages: Schema.optional(Schema.Boolean),
-  includeSiblings: Schema.optional(Schema.Boolean),
+export const EventFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  address: OptionalCodec(FieldElement),
+  keys: OptionalCodec(ArrayCodec(Key)),
+  strict: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeMessages: OptionalCodec(BooleanCodec),
+  includeSiblings: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export type EventFilter = typeof EventFilter.Type;
+export type EventFilter = Readonly<CodecType<typeof EventFilter>>;
 
 /** Filter messages to L1.
  *
@@ -129,73 +135,76 @@ export type EventFilter = typeof EventFilter.Type;
  * @prop includeTransaction Include the transaction that sent the message.
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeEvents Include events from the same transaction.
+ * @prop includeTransactionTrace Include the trace of the transaction that sent the message.
  */
-export const MessageToL1Filter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  fromAddress: Schema.optional(FieldElement),
-  toAddress: Schema.optional(FieldElement),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeEvents: Schema.optional(Schema.Boolean),
-});
-
-export type MessageToL1Filter = typeof MessageToL1Filter.Type;
-
-export const InvokeTransactionV0Filter = Schema.Struct({
-  _tag: tag("invokeV0"),
-  invokeV0: Schema.Struct({}),
+export const MessageToL1Filter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  fromAddress: OptionalCodec(FieldElement),
+  toAddress: OptionalCodec(FieldElement),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeEvents: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export const InvokeTransactionV1Filter = Schema.Struct({
-  _tag: tag("invokeV1"),
-  invokeV1: Schema.Struct({}),
-});
-
-export const InvokeTransactionV3Filter = Schema.Struct({
-  _tag: tag("invokeV3"),
-  invokeV3: Schema.Struct({}),
-});
-
-export const DeployTransactionFilter = Schema.Struct({
-  _tag: tag("deploy"),
-  deploy: Schema.Struct({}),
-});
-
-export const DeclareV0TransactionFilter = Schema.Struct({
-  _tag: tag("declareV0"),
-  declareV0: Schema.Struct({}),
-});
-
-export const DeclareV1TransactionFilter = Schema.Struct({
-  _tag: tag("declareV1"),
-  declareV1: Schema.Struct({}),
-});
-
-export const DeclareV2TransactionFilter = Schema.Struct({
-  _tag: tag("declareV2"),
-  declareV2: Schema.Struct({}),
-});
-
-export const DeclareV3TransactionFilter = Schema.Struct({
-  _tag: tag("declareV3"),
-  declareV3: Schema.Struct({}),
-});
-
-export const L1HandlerTransactionFilter = Schema.Struct({
-  _tag: tag("l1Handler"),
-  l1Handler: Schema.Struct({}),
-});
-
-export const DeployAccountV1TransactionFilter = Schema.Struct({
-  _tag: tag("deployAccountV1"),
-  deployAccountV1: Schema.Struct({}),
-});
-
-export const DeployAccountV3TransactionFilter = Schema.Struct({
-  _tag: tag("deployAccountV3"),
-  deployAccountV3: Schema.Struct({}),
-});
+export type MessageToL1Filter = Readonly<CodecType<typeof MessageToL1Filter>>;
+
+// Transaction type filters
+export const InvokeTransactionV0Filter = MessageCodec({});
+export type InvokeTransactionV0Filter = Readonly<
+  CodecType<typeof InvokeTransactionV0Filter>
+>;
+
+export const InvokeTransactionV1Filter = MessageCodec({});
+export type InvokeTransactionV1Filter = Readonly<
+  CodecType<typeof InvokeTransactionV1Filter>
+>;
+
+export const InvokeTransactionV3Filter = MessageCodec({});
+export type InvokeTransactionV3Filter = Readonly<
+  CodecType<typeof InvokeTransactionV3Filter>
+>;
+
+export const DeployTransactionFilter = MessageCodec({});
+export type DeployTransactionFilter = Readonly<
+  CodecType<typeof DeployTransactionFilter>
+>;
+
+export const DeclareV0TransactionFilter = MessageCodec({});
+export type DeclareV0TransactionFilter = Readonly<
+  CodecType<typeof DeclareV0TransactionFilter>
+>;
+
+export const DeclareV1TransactionFilter = MessageCodec({});
+export type DeclareV1TransactionFilter = Readonly<
+  CodecType<typeof DeclareV1TransactionFilter>
+>;
+
+export const DeclareV2TransactionFilter = MessageCodec({});
+export type DeclareV2TransactionFilter = Readonly<
+  CodecType<typeof DeclareV2TransactionFilter>
+>;
+
+export const DeclareV3TransactionFilter = MessageCodec({});
+export type DeclareV3TransactionFilter = Readonly<
+  CodecType<typeof DeclareV3TransactionFilter>
+>;
+
+export const L1HandlerTransactionFilter = MessageCodec({});
+export type L1HandlerTransactionFilter = Readonly<
+  CodecType<typeof L1HandlerTransactionFilter>
+>;
+
+export const DeployAccountV1TransactionFilter = MessageCodec({});
+export type DeployAccountV1TransactionFilter = Readonly<
+  CodecType<typeof DeployAccountV1TransactionFilter>
+>;
+
+export const DeployAccountV3TransactionFilter = MessageCodec({});
+export type DeployAccountV3TransactionFilter = Readonly<
+  CodecType<typeof DeployAccountV3TransactionFilter>
+>;
 
 /** Filter transactions.
  *
@@ -203,118 +212,110 @@ export const DeployAccountV3TransactionFilter = Schema.Struct({
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeEvents Include events from the same transaction.
  * @prop includeMessages Include messages sent in the transaction.
+ * @prop includeTrace Include the transaction's trace.
  */
-export const TransactionFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeMessages: Schema.optional(Schema.Boolean),
-  includeEvents: Schema.optional(Schema.Boolean),
-  transactionType: Schema.optional(
-    Schema.Union(
-      InvokeTransactionV0Filter,
-      InvokeTransactionV1Filter,
-      InvokeTransactionV3Filter,
-      DeployTransactionFilter,
-      DeclareV0TransactionFilter,
-      DeclareV1TransactionFilter,
-      DeclareV2TransactionFilter,
-      DeclareV3TransactionFilter,
-      DeclareV3TransactionFilter,
-      L1HandlerTransactionFilter,
-      DeployAccountV1TransactionFilter,
-      DeployAccountV3TransactionFilter,
-    ),
+export const TransactionFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeMessages: OptionalCodec(BooleanCodec),
+  includeEvents: OptionalCodec(BooleanCodec),
+  includeTrace: OptionalCodec(BooleanCodec),
+  transactionType: OptionalCodec(
+    OneOfCodec({
+      invokeV0: InvokeTransactionV0Filter,
+      invokeV1: InvokeTransactionV1Filter,
+      invokeV3: InvokeTransactionV3Filter,
+      deploy: DeployTransactionFilter,
+      declareV0: DeclareV0TransactionFilter,
+      declareV1: DeclareV1TransactionFilter,
+      declareV2: DeclareV2TransactionFilter,
+      declareV3: DeclareV3TransactionFilter,
+      l1Handler: L1HandlerTransactionFilter,
+      deployAccountV1: DeployAccountV1TransactionFilter,
+      deployAccountV3: DeployAccountV3TransactionFilter,
+    }),
   ),
 });
 
-export type TransactionFilter = typeof TransactionFilter.Type;
+export type TransactionFilter = Readonly<CodecType<typeof TransactionFilter>>;
 
 /** Filter storage diffs.
  *
  *  @prop contractAddress Filter by contract address.
  */
-export const StorageDiffFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  contractAddress: Schema.optional(FieldElement),
+export const StorageDiffFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  contractAddress: OptionalCodec(FieldElement),
 });
 
-export type StorageDiffFilter = typeof StorageDiffFilter.Type;
+export type StorageDiffFilter = Readonly<CodecType<typeof StorageDiffFilter>>;
 
 /** Filter declared classes. */
-export const DeclaredClassFilter = Schema.Struct({
-  _tag: tag("declaredClass"),
-  declaredClass: Schema.Struct({}),
-});
-
-export type DeclaredClassFilter = typeof DeclaredClassFilter.Type;
+export const DeclaredClassFilter = MessageCodec({});
+export type DeclaredClassFilter = Readonly<
+  CodecType<typeof DeclaredClassFilter>
+>;
 
-export const ReplacedClassFilter = Schema.Struct({
-  _tag: tag("replacedClass"),
-  replacedClass: Schema.Struct({}),
-});
-
-export type ReplacedClassFilter = typeof ReplacedClassFilter.Type;
+export const ReplacedClassFilter = MessageCodec({});
+export type ReplacedClassFilter = Readonly<
+  CodecType<typeof ReplacedClassFilter>
+>;
 
-export const DeployedContractFilter = Schema.Struct({
-  _tag: tag("deployedContract"),
-  deployedContract: Schema.Struct({}),
-});
-
-export type DeployedContractFilter = typeof DeployedContractFilter.Type;
+export const DeployedContractFilter = MessageCodec({});
+export type DeployedContractFilter = Readonly<
+  CodecType<typeof DeployedContractFilter>
+>;
 
 /** Filter contract changes. */
-export const ContractChangeFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  change: Schema.optional(
-    Schema.Union(
-      DeclaredClassFilter,
-      ReplacedClassFilter,
-      DeployedContractFilter,
-    ),
+export const ContractChangeFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  change: OptionalCodec(
+    OneOfCodec({
+      declaredClass: DeclaredClassFilter,
+      replacedClass: ReplacedClassFilter,
+      deployedContract: DeployedContractFilter,
+    }),
   ),
 });
 
+export type ContractChangeFilter = Readonly<
+  CodecType<typeof ContractChangeFilter>
+>;
+
 /** Filter updates to nonces.
  *
  * @prop contractAddress Filter by contract address.
  */
-export const NonceUpdateFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  contractAddress: Schema.optional(FieldElement),
+export const NonceUpdateFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  contractAddress: OptionalCodec(FieldElement),
 });
 
-export const Filter = Schema.Struct({
-  header: Schema.optional(HeaderFilter),
-  transactions: Schema.optional(Schema.Array(TransactionFilter)),
-  events: Schema.optional(Schema.Array(EventFilter)),
-  messages: Schema.optional(Schema.Array(MessageToL1Filter)),
-  storageDiffs: Schema.optional(Schema.Array(StorageDiffFilter)),
-  contractChanges: Schema.optional(Schema.Array(ContractChangeFilter)),
-  nonceUpdates: Schema.optional(Schema.Array(NonceUpdateFilter)),
+export type NonceUpdateFilter = Readonly<CodecType<typeof NonceUpdateFilter>>;
+
+export const Filter = MessageCodec({
+  header: OptionalCodec(HeaderFilter),
+  transactions: OptionalCodec(ArrayCodec(TransactionFilter)),
+  events: OptionalCodec(ArrayCodec(EventFilter)),
+  messages: OptionalCodec(ArrayCodec(MessageToL1Filter)),
+  storageDiffs: OptionalCodec(ArrayCodec(StorageDiffFilter)),
+  contractChanges: OptionalCodec(ArrayCodec(ContractChangeFilter)),
+  nonceUpdates: OptionalCodec(ArrayCodec(NonceUpdateFilter)),
 });
 
-export type Filter = typeof Filter.Type;
-
-export const filterToProto = Schema.encodeSync(Filter);
-export const filterFromProto = Schema.decodeSync(Filter);
-
-export const FilterFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Filter,
-  {
-    strict: false,
-    decode(value) {
-      return proto.filter.Filter.decode(value);
-    },
-    encode(value) {
-      return proto.filter.Filter.encode(value).finish();
-    },
-  },
-);
+export type Filter = Readonly<CodecType<typeof Filter>>;
 
-export const filterToBytes = Schema.encodeSync(FilterFromBytes);
-export const filterFromBytes = Schema.decodeSync(FilterFromBytes);
+export const FilterFromBytes: Codec<Filter, Uint8Array> = {
+  encode(x) {
+    const filter = Filter.encode(x);
+    return proto.filter.Filter.encode(filter).finish();
+  },
+  decode(p) {
+    const filter = proto.filter.Filter.decode(p);
+    return Filter.decode(filter);
+  },
+};
 
 export function mergeFilter(a: Filter, b: Filter): Filter {
   const header = mergeHeaderFilter(a.header, b.header);

package/src/index.ts

@@ -15,6 +15,8 @@ export { getBigIntSelector, getEventSelector, getSelector } from "./abi";
 
 declare module "abi-wan-kanabi" {
   interface Config {
+    AddressType: `0x${string}`;
+    ClassHashType: `0x${string}`;
     FeltType: bigint;
     BigIntType: bigint;
     U256Type: bigint;
@@ -25,4 +27,5 @@ export const StarknetStream = new StreamConfig(
   FilterFromBytes,
   BlockFromBytes,
   mergeFilter,
+  "starknet",
 );