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

package/src/parser.ts

@@ -77,7 +77,7 @@ export function parseU256(data: readonly FieldElement[], offset: number) {
 export function parseAsHex(data: readonly FieldElement[], offset: number) {
   assertInBounds(data, offset);
   return {
-    out: String(data[offset]),
+    out: data[offset],
     offset: offset + 1,
   };
 }
@@ -96,7 +96,7 @@ export function parseFelt252(data: readonly FieldElement[], offset: number) {
   };
 }
 
-export function parseEmpty(data: readonly FieldElement[], offset: number) {
+export function parseEmpty(_data: readonly FieldElement[], offset: number) {
   return { out: null, offset };
 }
 
@@ -132,13 +132,15 @@ export function parseOption<T>(type: Parser<T>) {
   };
 }
 
-export function parseStruct<T extends { [key: string]: unknown }>(
-  parsers: { [K in keyof T]: { index: number; parser: Parser<T[K]> } },
-) {
+export function parseStruct<T extends Record<string, unknown>>(
+  parsers: {
+    [K in keyof T]: { index: number; parser: Parser<T[K]> };
+  },
+): Parser<{ [K in keyof T]: T[K] }> {
   const sortedParsers = Object.entries(parsers).sort(
     (a, b) => a[1].index - b[1].index,
   );
-  return (data: readonly FieldElement[], startingOffset: number) => {
+  const parser = (data: readonly FieldElement[], startingOffset: number) => {
     let offset = startingOffset;
     const out: Record<string, unknown> = {};
     for (const [key, { parser }] of sortedParsers) {
@@ -148,6 +150,35 @@ export function parseStruct<T extends { [key: string]: unknown }>(
     }
     return { out, offset };
   };
+  return parser as Parser<{ [K in keyof T]: T[K] }>;
+}
+
+export function parseEnum<T extends Record<string, unknown>>(
+  parsers: {
+    [K in keyof T]: { index: number; parser: Parser<T[K]> };
+  },
+): Parser<T[keyof T]> {
+  return (data: readonly FieldElement[], startingOffset: number) => {
+    const selectorFelt = data[startingOffset];
+    const selector = Number(BigInt(selectorFelt));
+
+    // Find the parser by index
+    const parserEntry = Object.entries(parsers).find(
+      ([, { index }]) => index === selector,
+    );
+
+    if (!parserEntry) {
+      throw new ParseError(`Unknown enum variant selector: ${selector}`);
+    }
+
+    const [variantName, { parser }] = parserEntry;
+    const { out, offset: newOffset } = parser(data, startingOffset + 1);
+
+    return {
+      out: { _tag: variantName, [variantName]: out } as T[keyof T],
+      offset: newOffset,
+    };
+  };
 }
 
 export function parseTuple<T extends Parser<unknown>[]>(
@@ -168,3 +199,68 @@ export function parseTuple<T extends Parser<unknown>[]>(
 type UnwrapParsers<TP> = {
   [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;
 };
+
+const parseByteArrayStruct = parseStruct({
+  data: {
+    index: 0,
+    parser: parseArray(parseBytes31),
+  },
+  pendingWord: { index: 1, parser: parseFelt252 },
+  pendingWordLen: { index: 2, parser: parseU32 },
+});
+
+export function parseByteArray(data: readonly FieldElement[], offset: number) {
+  // A ByteArray is a struct with the following abi:
+  //
+  // {
+  //   name: "core::byte_array::ByteArray",
+  //   type: "struct",
+  //   members: [
+  //     {
+  //       name: "data",
+  //       type: "core::array::Array::<core::bytes_31::bytes31>",
+  //     },
+  //     {
+  //       name: "pending_word",
+  //       type: "core::felt252",
+  //     },
+  //     {
+  //       name: "pending_word_len",
+  //       type: "core::integer::u32",
+  //     },
+  //   ],
+  // },
+  //
+  // We first parse it using a parser for that struct, then convert it to the output `0x${string}` type.
+  const { out, offset: offsetOut } = parseByteArrayStruct(data, offset);
+
+  // Remove 0x prefix from data elements and pad them to 31 bytes.
+  const dataBytes = out.data
+    .map((bytes) => bytes.slice(2).padStart(62, "0"))
+    .join("");
+
+  let pending = out.pendingWord.toString(16);
+  const pendingWordLength = Number(out.pendingWordLen);
+  if (pending.length < pendingWordLength * 2) {
+    pending = pending.padStart(pendingWordLength * 2, "0");
+  }
+
+  const pendingBytes = pending.slice(pending.length - 2 * pendingWordLength);
+  const bytes = removeLeadingZeros(dataBytes + pendingBytes);
+
+  return { out: `0x${bytes}`, offset: offsetOut };
+}
+
+function removeLeadingZeros(bytes: string): string {
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] !== "0") {
+      let j = i;
+      if (i % 2 !== 0) {
+        j -= 1;
+      }
+      return bytes.slice(j);
+    }
+  }
+  // The bytes are all 0, so return something reasonable.
+  return "00";
+}