@apibara/starknet 2.0.0-beta.30 → 2.0.0-beta.31

package/dist/index.cjs

@@ -1,9 +1,12 @@
 'use strict';
 
 const protocol = require('@apibara/protocol');
+const abiWanKanabi = require('abi-wan-kanabi');
 const schema = require('@effect/schema');
 const Long = require('long');
 const _m0 = require('protobufjs/minimal.js');
+const starknet = require('@scure/starknet');
+const parser = require('./parser.cjs');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -7403,14 +7406,16 @@ function mergeHeaderFilter(a, b) {
   return "on_data";
 }
 
-function getReceipt(transactionIndex, receipts) {
+function getReceipt(transactionIndex, params) {
+  const receipts = "receipts" in params ? params.receipts : params;
   return binarySearch(
     transactionIndex,
     receipts,
     (receipt) => receipt.meta?.transactionIndex ?? 0
   );
 }
-function getTransaction(transactionIndex, transactions) {
+function getTransaction(transactionIndex, params) {
+  const transactions = "transactions" in params ? params.transactions : params;
   return binarySearch(
     transactionIndex,
     transactions,
@@ -7435,12 +7440,164 @@ function binarySearch(index, arr, getIndex) {
   }
 }
 
+function getBigIntSelector(name) {
+  const asBytes = new TextEncoder().encode(name);
+  return starknet.keccak(asBytes);
+}
+function getSelector(name) {
+  const bn = getBigIntSelector(name);
+  return `0x${bn.toString(16).padStart(64, "0")}`;
+}
+function getEventSelector(name) {
+  const parts = name.split("::");
+  return getSelector(parts[parts.length - 1]);
+}
+const PrimitiveTypeParsers = {
+  "core::bool": parser.parseBool,
+  "core::felt252": parser.parseFelt252,
+  "core::integer::u8": parser.parseU8,
+  "core::integer::u16": parser.parseU16,
+  "core::integer::u32": parser.parseU32,
+  "core::integer::u64": parser.parseU64,
+  "core::integer::u128": parser.parseU128,
+  "core::integer::u256": parser.parseU256,
+  "core::starknet::contract_address::ContractAddress": parser.parseContractAddress
+};
+function isPrimitiveType(type) {
+  return type in PrimitiveTypeParsers;
+}
+function isArrayType(type) {
+  return type.startsWith("core::array::Array::<") && type.endsWith(">");
+}
+function getArrayElementType(type) {
+  return type.slice("core::array::Array::<".length, -1);
+}
+function isSpanType(type) {
+  return type.startsWith("core::array::Span::<") && type.endsWith(">");
+}
+function getSpanType(type) {
+  return type.slice("core::array::Span::<".length, -1);
+}
+function isOptionType(type) {
+  return type.startsWith("core::option::Option::<") && type.endsWith(">");
+}
+function getOptionType(type) {
+  return type.slice("core::option::Option::<".length, -1);
+}
+function isEmptyType(type) {
+  return type === "()";
+}
+
+class DecodeEventError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DecodeEventError";
+  }
+}
+function decodeEvent(args) {
+  const { abi, event, eventName, strict = true } = args;
+  const eventAbi = abi.find(
+    (item) => item.name === eventName && item.type === "event"
+  );
+  if (!eventAbi || eventAbi.type !== "event") {
+    if (strict) {
+      throw new DecodeEventError(`Event ${eventName} not found in ABI`);
+    }
+    return null;
+  }
+  if (eventAbi.kind === "enum") {
+    throw new DecodeEventError("enum: not implemented");
+  }
+  const selector = BigInt(getEventSelector(eventName));
+  if (event.keys && selector !== BigInt(event.keys[0]) || !event.keys) {
+    if (strict) {
+      throw new DecodeEventError(
+        `Selector mismatch. Expected ${selector}, got ${event.keys?.[0]}`
+      );
+    }
+    return null;
+  }
+  const keysAbi = eventAbi.members.filter((m) => m.kind === "key");
+  const dataAbi = eventAbi.members.filter((m) => m.kind === "data");
+  try {
+    const keysParser = compileEventMembers(abi, keysAbi);
+    const dataParser = compileEventMembers(abi, dataAbi);
+    const keysWithoutSelector = event.keys?.slice(1) ?? [];
+    const { out: decodedKeys } = keysParser(keysWithoutSelector, 0);
+    const { out: decodedData } = dataParser(event.data ?? [], 0);
+    const decoded = {
+      ...decodedKeys,
+      ...decodedData
+    };
+    return {
+      ...event,
+      eventName,
+      args: decoded
+    };
+  } catch (error) {
+    if (error instanceof DecodeEventError && !strict) {
+      return null;
+    }
+    if (error instanceof parser.ParseError && !strict) {
+      return null;
+    }
+    throw error;
+  }
+}
+function compileEventMembers(abi, members) {
+  return compileStructParser(abi, members);
+}
+function compileTypeParser(abi, type) {
+  if (isPrimitiveType(type)) {
+    return PrimitiveTypeParsers[type];
+  }
+  if (isArrayType(type)) {
+    const elementType = getArrayElementType(type);
+    return parser.parseArray(compileTypeParser(abi, elementType));
+  }
+  if (isSpanType(type)) {
+    const elementType = getSpanType(type);
+    return parser.parseSpan(compileTypeParser(abi, elementType));
+  }
+  if (isOptionType(type)) {
+    const elementType = getOptionType(type);
+    return parser.parseOption(compileTypeParser(abi, elementType));
+  }
+  if (isEmptyType(type)) {
+    return parser.parseEmpty;
+  }
+  const typeAbi = abi.find((item) => item.name === type);
+  if (!typeAbi) {
+    throw new DecodeEventError(`Type ${type} not found in ABI`);
+  }
+  switch (typeAbi.type) {
+    case "struct": {
+      return compileStructParser(abi, typeAbi.members);
+    }
+    case "enum":
+      throw new DecodeEventError("enum: not implemented");
+    default:
+      throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
+  }
+}
+function compileStructParser(abi, members) {
+  const parsers = {};
+  for (const [index, member] of members.entries()) {
+    parsers[member.name] = {
+      index,
+      parser: compileTypeParser(abi, member.type)
+    };
+  }
+  return parser.parseStruct(parsers);
+}
+
 const StarknetStream = new protocol.StreamConfig(
   FilterFromBytes,
   BlockFromBytes,
   mergeFilter
 );
 
+exports.Abi = abiWanKanabi.Abi;
 exports.Block = Block;
 exports.BlockFromBytes = BlockFromBytes;
 exports.BlockHeader = BlockHeader;
@@ -7460,6 +7617,7 @@ exports.DeclareV2TransactionFilter = DeclareV2TransactionFilter;
 exports.DeclareV3TransactionFilter = DeclareV3TransactionFilter;
 exports.DeclaredClass = DeclaredClass;
 exports.DeclaredClassFilter = DeclaredClassFilter;
+exports.DecodeEventError = DecodeEventError;
 exports.DeployAccountTransactionReceipt = DeployAccountTransactionReceipt;
 exports.DeployAccountTransactionV1 = DeployAccountTransactionV1;
 exports.DeployAccountTransactionV3 = DeployAccountTransactionV3;
@@ -7515,13 +7673,17 @@ exports.TransactionReceiptMeta = TransactionReceiptMeta;
 exports.TransactionStatus = TransactionStatus;
 exports.TransactionStatusFilter = TransactionStatusFilter;
 exports.U128 = U128;
+exports.decodeEvent = decodeEvent;
 exports.feltFromProto = feltFromProto;
 exports.feltToProto = feltToProto;
 exports.filterFromBytes = filterFromBytes;
 exports.filterFromProto = filterFromProto;
 exports.filterToBytes = filterToBytes;
 exports.filterToProto = filterToProto;
+exports.getBigIntSelector = getBigIntSelector;
+exports.getEventSelector = getEventSelector;
 exports.getReceipt = getReceipt;
+exports.getSelector = getSelector;
 exports.getTransaction = getTransaction;
 exports.mergeFilter = mergeFilter;
 exports.proto = index;