@apibara/starknet 2.0.0-beta.9 → 2.1.0-beta.2

package/dist/parser.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+class ParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+  }
+}
+function assertInBounds(data, offset) {
+  if (offset >= data.length) {
+    throw new ParseError(
+      `Offset out of bounds. Data length ${data.length}, offset ${offset}`
+    );
+  }
+}
+function parseBool(data, offset) {
+  assertInBounds(data, offset);
+  return { out: BigInt(data[offset]) > 0n, offset: offset + 1 };
+}
+function parseAsBigInt(data, offset) {
+  assertInBounds(data, offset);
+  return { out: BigInt(data[offset]), offset: offset + 1 };
+}
+const parseU8 = parseAsBigInt;
+const parseU16 = parseAsBigInt;
+const parseU32 = parseAsBigInt;
+const parseU64 = parseAsBigInt;
+const parseU128 = parseAsBigInt;
+const parseUsize = parseAsBigInt;
+function parseU256(data, offset) {
+  assertInBounds(data, offset + 1);
+  return {
+    out: BigInt(data[offset]) + (BigInt(data[offset + 1]) << 128n),
+    offset: offset + 2
+  };
+}
+function parseAsHex(data, offset) {
+  assertInBounds(data, offset);
+  return {
+    out: String(data[offset]),
+    offset: offset + 1
+  };
+}
+const parseContractAddress = parseAsHex;
+const parseEthAddress = parseAsHex;
+const parseStorageAddress = parseAsHex;
+const parseClassHash = parseAsHex;
+const parseBytes31 = parseAsHex;
+function parseFelt252(data, offset) {
+  assertInBounds(data, offset);
+  return {
+    out: BigInt(data[offset]),
+    offset: offset + 1
+  };
+}
+function parseEmpty(data, offset) {
+  return { out: null, offset };
+}
+function parseArray(type) {
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const length = BigInt(data[offset]);
+    offset++;
+    const out = [];
+    for (let i = 0; i < length; i++) {
+      const { out: item, offset: newOffset } = type(data, offset);
+      out.push(item);
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+const parseSpan = parseArray;
+function parseOption(type) {
+  return (data, offset) => {
+    const hasValue = BigInt(data[offset]) === 1n;
+    if (hasValue) {
+      return type(data, offset + 1);
+    }
+    return { out: null, offset: offset + 1 };
+  };
+}
+function parseStruct(parsers) {
+  const sortedParsers = Object.entries(parsers).sort(
+    (a, b) => a[1].index - b[1].index
+  );
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const out = {};
+    for (const [key, { parser }] of sortedParsers) {
+      const { out: value, offset: newOffset } = parser(data, offset);
+      out[key] = value;
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+function parseTuple(...parsers) {
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const out = [];
+    for (const parser of parsers) {
+      const { out: value, offset: newOffset } = parser(data, offset);
+      out.push(value);
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+
+exports.ParseError = ParseError;
+exports.parseArray = parseArray;
+exports.parseAsBigInt = parseAsBigInt;
+exports.parseAsHex = parseAsHex;
+exports.parseBool = parseBool;
+exports.parseBytes31 = parseBytes31;
+exports.parseClassHash = parseClassHash;
+exports.parseContractAddress = parseContractAddress;
+exports.parseEmpty = parseEmpty;
+exports.parseEthAddress = parseEthAddress;
+exports.parseFelt252 = parseFelt252;
+exports.parseOption = parseOption;
+exports.parseSpan = parseSpan;
+exports.parseStorageAddress = parseStorageAddress;
+exports.parseStruct = parseStruct;
+exports.parseTuple = parseTuple;
+exports.parseU128 = parseU128;
+exports.parseU16 = parseU16;
+exports.parseU256 = parseU256;
+exports.parseU32 = parseU32;
+exports.parseU64 = parseU64;
+exports.parseU8 = parseU8;
+exports.parseUsize = parseUsize;

package/dist/parser.d.cts

@@ -0,0 +1,72 @@
+import { F as FieldElement } from './shared/starknet.2b19268a.cjs';
+import '@effect/schema/AST';
+import '@effect/schema';
+
+type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
+    out: TOut;
+    offset: number;
+};
+declare class ParseError extends Error {
+    constructor(message: string);
+}
+declare function parseBool(data: readonly FieldElement[], offset: number): {
+    out: boolean;
+    offset: number;
+};
+declare function parseAsBigInt(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare const parseU8: typeof parseAsBigInt;
+declare const parseU16: typeof parseAsBigInt;
+declare const parseU32: typeof parseAsBigInt;
+declare const parseU64: typeof parseAsBigInt;
+declare const parseU128: typeof parseAsBigInt;
+declare const parseUsize: typeof parseAsBigInt;
+declare function parseU256(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseAsHex(data: readonly FieldElement[], offset: number): {
+    out: string;
+    offset: number;
+};
+declare const parseContractAddress: typeof parseAsHex;
+declare const parseEthAddress: typeof parseAsHex;
+declare const parseStorageAddress: typeof parseAsHex;
+declare const parseClassHash: typeof parseAsHex;
+declare const parseBytes31: typeof parseAsHex;
+declare function parseFelt252(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+    out: null;
+    offset: number;
+};
+declare function parseArray<T>(type: Parser<T>): Parser<T[]>;
+declare const parseSpan: typeof parseArray;
+declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[], offset: number) => {
+    out: T;
+    offset: number;
+} | {
+    out: null;
+    offset: number;
+};
+declare function parseStruct<T extends {
+    [key: string]: unknown;
+}>(parsers: {
+    [K in keyof T]: {
+        index: number;
+        parser: Parser<T[K]>;
+    };
+}): (data: readonly FieldElement[], startingOffset: number) => {
+    out: Record<string, unknown>;
+    offset: number;
+};
+declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
+type UnwrapParsers<TP> = {
+    [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;
+};
+
+export { ParseError, type Parser, parseArray, parseAsBigInt, parseAsHex, parseBool, parseBytes31, parseClassHash, parseContractAddress, parseEmpty, parseEthAddress, parseFelt252, parseOption, parseSpan, parseStorageAddress, parseStruct, parseTuple, parseU128, parseU16, parseU256, parseU32, parseU64, parseU8, parseUsize };

package/dist/parser.d.mts

@@ -0,0 +1,72 @@
+import { F as FieldElement } from './shared/starknet.2b19268a.mjs';
+import '@effect/schema/AST';
+import '@effect/schema';
+
+type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
+    out: TOut;
+    offset: number;
+};
+declare class ParseError extends Error {
+    constructor(message: string);
+}
+declare function parseBool(data: readonly FieldElement[], offset: number): {
+    out: boolean;
+    offset: number;
+};
+declare function parseAsBigInt(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare const parseU8: typeof parseAsBigInt;
+declare const parseU16: typeof parseAsBigInt;
+declare const parseU32: typeof parseAsBigInt;
+declare const parseU64: typeof parseAsBigInt;
+declare const parseU128: typeof parseAsBigInt;
+declare const parseUsize: typeof parseAsBigInt;
+declare function parseU256(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseAsHex(data: readonly FieldElement[], offset: number): {
+    out: string;
+    offset: number;
+};
+declare const parseContractAddress: typeof parseAsHex;
+declare const parseEthAddress: typeof parseAsHex;
+declare const parseStorageAddress: typeof parseAsHex;
+declare const parseClassHash: typeof parseAsHex;
+declare const parseBytes31: typeof parseAsHex;
+declare function parseFelt252(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+    out: null;
+    offset: number;
+};
+declare function parseArray<T>(type: Parser<T>): Parser<T[]>;
+declare const parseSpan: typeof parseArray;
+declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[], offset: number) => {
+    out: T;
+    offset: number;
+} | {
+    out: null;
+    offset: number;
+};
+declare function parseStruct<T extends {
+    [key: string]: unknown;
+}>(parsers: {
+    [K in keyof T]: {
+        index: number;
+        parser: Parser<T[K]>;
+    };
+}): (data: readonly FieldElement[], startingOffset: number) => {
+    out: Record<string, unknown>;
+    offset: number;
+};
+declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
+type UnwrapParsers<TP> = {
+    [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;
+};
+
+export { ParseError, type Parser, parseArray, parseAsBigInt, parseAsHex, parseBool, parseBytes31, parseClassHash, parseContractAddress, parseEmpty, parseEthAddress, parseFelt252, parseOption, parseSpan, parseStorageAddress, parseStruct, parseTuple, parseU128, parseU16, parseU256, parseU32, parseU64, parseU8, parseUsize };

package/dist/parser.d.ts

@@ -0,0 +1,72 @@
+import { F as FieldElement } from './shared/starknet.2b19268a.js';
+import '@effect/schema/AST';
+import '@effect/schema';
+
+type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
+    out: TOut;
+    offset: number;
+};
+declare class ParseError extends Error {
+    constructor(message: string);
+}
+declare function parseBool(data: readonly FieldElement[], offset: number): {
+    out: boolean;
+    offset: number;
+};
+declare function parseAsBigInt(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare const parseU8: typeof parseAsBigInt;
+declare const parseU16: typeof parseAsBigInt;
+declare const parseU32: typeof parseAsBigInt;
+declare const parseU64: typeof parseAsBigInt;
+declare const parseU128: typeof parseAsBigInt;
+declare const parseUsize: typeof parseAsBigInt;
+declare function parseU256(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseAsHex(data: readonly FieldElement[], offset: number): {
+    out: string;
+    offset: number;
+};
+declare const parseContractAddress: typeof parseAsHex;
+declare const parseEthAddress: typeof parseAsHex;
+declare const parseStorageAddress: typeof parseAsHex;
+declare const parseClassHash: typeof parseAsHex;
+declare const parseBytes31: typeof parseAsHex;
+declare function parseFelt252(data: readonly FieldElement[], offset: number): {
+    out: bigint;
+    offset: number;
+};
+declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+    out: null;
+    offset: number;
+};
+declare function parseArray<T>(type: Parser<T>): Parser<T[]>;
+declare const parseSpan: typeof parseArray;
+declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[], offset: number) => {
+    out: T;
+    offset: number;
+} | {
+    out: null;
+    offset: number;
+};
+declare function parseStruct<T extends {
+    [key: string]: unknown;
+}>(parsers: {
+    [K in keyof T]: {
+        index: number;
+        parser: Parser<T[K]>;
+    };
+}): (data: readonly FieldElement[], startingOffset: number) => {
+    out: Record<string, unknown>;
+    offset: number;
+};
+declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
+type UnwrapParsers<TP> = {
+    [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;
+};
+
+export { ParseError, type Parser, parseArray, parseAsBigInt, parseAsHex, parseBool, parseBytes31, parseClassHash, parseContractAddress, parseEmpty, parseEthAddress, parseFelt252, parseOption, parseSpan, parseStorageAddress, parseStruct, parseTuple, parseU128, parseU16, parseU256, parseU32, parseU64, parseU8, parseUsize };

package/dist/parser.mjs

@@ -0,0 +1,109 @@
+class ParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+  }
+}
+function assertInBounds(data, offset) {
+  if (offset >= data.length) {
+    throw new ParseError(
+      `Offset out of bounds. Data length ${data.length}, offset ${offset}`
+    );
+  }
+}
+function parseBool(data, offset) {
+  assertInBounds(data, offset);
+  return { out: BigInt(data[offset]) > 0n, offset: offset + 1 };
+}
+function parseAsBigInt(data, offset) {
+  assertInBounds(data, offset);
+  return { out: BigInt(data[offset]), offset: offset + 1 };
+}
+const parseU8 = parseAsBigInt;
+const parseU16 = parseAsBigInt;
+const parseU32 = parseAsBigInt;
+const parseU64 = parseAsBigInt;
+const parseU128 = parseAsBigInt;
+const parseUsize = parseAsBigInt;
+function parseU256(data, offset) {
+  assertInBounds(data, offset + 1);
+  return {
+    out: BigInt(data[offset]) + (BigInt(data[offset + 1]) << 128n),
+    offset: offset + 2
+  };
+}
+function parseAsHex(data, offset) {
+  assertInBounds(data, offset);
+  return {
+    out: String(data[offset]),
+    offset: offset + 1
+  };
+}
+const parseContractAddress = parseAsHex;
+const parseEthAddress = parseAsHex;
+const parseStorageAddress = parseAsHex;
+const parseClassHash = parseAsHex;
+const parseBytes31 = parseAsHex;
+function parseFelt252(data, offset) {
+  assertInBounds(data, offset);
+  return {
+    out: BigInt(data[offset]),
+    offset: offset + 1
+  };
+}
+function parseEmpty(data, offset) {
+  return { out: null, offset };
+}
+function parseArray(type) {
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const length = BigInt(data[offset]);
+    offset++;
+    const out = [];
+    for (let i = 0; i < length; i++) {
+      const { out: item, offset: newOffset } = type(data, offset);
+      out.push(item);
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+const parseSpan = parseArray;
+function parseOption(type) {
+  return (data, offset) => {
+    const hasValue = BigInt(data[offset]) === 1n;
+    if (hasValue) {
+      return type(data, offset + 1);
+    }
+    return { out: null, offset: offset + 1 };
+  };
+}
+function parseStruct(parsers) {
+  const sortedParsers = Object.entries(parsers).sort(
+    (a, b) => a[1].index - b[1].index
+  );
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const out = {};
+    for (const [key, { parser }] of sortedParsers) {
+      const { out: value, offset: newOffset } = parser(data, offset);
+      out[key] = value;
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+function parseTuple(...parsers) {
+  return (data, startingOffset) => {
+    let offset = startingOffset;
+    const out = [];
+    for (const parser of parsers) {
+      const { out: value, offset: newOffset } = parser(data, offset);
+      out.push(value);
+      offset = newOffset;
+    }
+    return { out, offset };
+  };
+}
+
+export { ParseError, parseArray, parseAsBigInt, parseAsHex, parseBool, parseBytes31, parseClassHash, parseContractAddress, parseEmpty, parseEthAddress, parseFelt252, parseOption, parseSpan, parseStorageAddress, parseStruct, parseTuple, parseU128, parseU16, parseU256, parseU32, parseU64, parseU8, parseUsize };

package/dist/shared/starknet.2b19268a.d.cts

@@ -0,0 +1,32 @@
+import * as _effect_schema_AST from '@effect/schema/AST';
+import { Schema } from '@effect/schema';
+
+/** Wire representation of `FieldElement`. */
+declare const FieldElementProto: Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>;
+/** Field element. */
+declare const FieldElement: Schema.transform<Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
+type FieldElement = Schema.Schema.Type<typeof FieldElement>;
+declare const feltToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+};
+declare const feltFromProto: (i: {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+}, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
+
+export { FieldElement as F, FieldElementProto as a, feltFromProto as b, feltToProto as f };

package/dist/shared/starknet.2b19268a.d.mts

@@ -0,0 +1,32 @@
+import * as _effect_schema_AST from '@effect/schema/AST';
+import { Schema } from '@effect/schema';
+
+/** Wire representation of `FieldElement`. */
+declare const FieldElementProto: Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>;
+/** Field element. */
+declare const FieldElement: Schema.transform<Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
+type FieldElement = Schema.Schema.Type<typeof FieldElement>;
+declare const feltToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+};
+declare const feltFromProto: (i: {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+}, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
+
+export { FieldElement as F, FieldElementProto as a, feltFromProto as b, feltToProto as f };

package/dist/shared/starknet.2b19268a.d.ts

@@ -0,0 +1,32 @@
+import * as _effect_schema_AST from '@effect/schema/AST';
+import { Schema } from '@effect/schema';
+
+/** Wire representation of `FieldElement`. */
+declare const FieldElementProto: Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>;
+/** Field element. */
+declare const FieldElement: Schema.transform<Schema.Struct<{
+    x0: typeof Schema.BigIntFromSelf;
+    x1: typeof Schema.BigIntFromSelf;
+    x2: typeof Schema.BigIntFromSelf;
+    x3: typeof Schema.BigIntFromSelf;
+}>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
+type FieldElement = Schema.Schema.Type<typeof FieldElement>;
+declare const feltToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+};
+declare const feltFromProto: (i: {
+    readonly x0: bigint;
+    readonly x1: bigint;
+    readonly x2: bigint;
+    readonly x3: bigint;
+}, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
+
+export { FieldElement as F, FieldElementProto as a, feltFromProto as b, feltToProto as f };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/starknet",
-  "version": "2.0.0-beta.9",
+  "version": "2.1.0-beta.2",
   "type": "module",
   "files": [
     "dist",
@@ -15,6 +15,12 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "default": "./dist/index.mjs"
+    },
+    "./parser": {
+      "types": "./dist/parser.d.ts",
+      "import": "./dist/parser.mjs",
+      "require": "./dist/parser.cjs",
+      "default": "./dist/parser.mjs"
     }
   },
   "scripts": {
@@ -36,8 +42,10 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.0.0-beta.9",
+    "@apibara/protocol": "2.1.0-beta.2",
     "@effect/schema": "^0.67.15",
+    "@scure/starknet": "^1.1.0",
+    "abi-wan-kanabi": "^2.2.4",
     "effect": "^3.2.6",
     "long": "^5.2.1",
     "nice-grpc-common": "^2.0.2",

package/src/abi.ts

@@ -0,0 +1,79 @@
+import { keccak } from "@scure/starknet";
+
+import type { FieldElement } from "./common";
+import {
+  parseBool,
+  parseContractAddress,
+  parseFelt252,
+  parseU8,
+  parseU16,
+  parseU32,
+  parseU64,
+  parseU128,
+  parseU256,
+} from "./parser";
+
+/** Returns the selector of the provided `name` as a bigint. */
+export function getBigIntSelector(name: string): bigint {
+  const asBytes = new TextEncoder().encode(name);
+  return keccak(asBytes);
+}
+
+/** Returns the selector of the provided `name` as a FieldElement. */
+export function getSelector(name: string): FieldElement {
+  const bn = getBigIntSelector(name);
+  return `0x${bn.toString(16).padStart(64, "0")}`;
+}
+
+/** Returns the selector of the provided event with `name` as a FieldElement.
+ *
+ * If the name is fully qualified, only the last part is used to compute the selector.
+ */
+export function getEventSelector(name: string): FieldElement {
+  const parts = name.split("::");
+  return getSelector(parts[parts.length - 1]);
+}
+
+export const PrimitiveTypeParsers = {
+  "core::bool": parseBool,
+  "core::felt252": parseFelt252,
+  "core::integer::u8": parseU8,
+  "core::integer::u16": parseU16,
+  "core::integer::u32": parseU32,
+  "core::integer::u64": parseU64,
+  "core::integer::u128": parseU128,
+  "core::integer::u256": parseU256,
+  "core::starknet::contract_address::ContractAddress": parseContractAddress,
+};
+
+export function isPrimitiveType(type: string) {
+  return type in PrimitiveTypeParsers;
+}
+
+export function isArrayType(type: string) {
+  return type.startsWith("core::array::Array::<") && type.endsWith(">");
+}
+
+export function getArrayElementType(type: string) {
+  return type.slice("core::array::Array::<".length, -1);
+}
+
+export function isSpanType(type: string) {
+  return type.startsWith("core::array::Span::<") && type.endsWith(">");
+}
+
+export function getSpanType(type: string) {
+  return type.slice("core::array::Span::<".length, -1);
+}
+
+export function isOptionType(type: string) {
+  return type.startsWith("core::option::Option::<") && type.endsWith(">");
+}
+
+export function getOptionType(type: string) {
+  return type.slice("core::option::Option::<".length, -1);
+}
+
+export function isEmptyType(type: string) {
+  return type === "()";
+}

package/src/access.ts

@@ -3,8 +3,11 @@ import type { Transaction, TransactionReceipt } from "./block";
 /** Returns the transaction receipt for the given transaction index. */
 export function getReceipt(
   transactionIndex: number,
-  receipts: readonly TransactionReceipt[],
+  params:
+    | { receipts: readonly TransactionReceipt[] }
+    | readonly TransactionReceipt[],
 ): TransactionReceipt | undefined {
+  const receipts = "receipts" in params ? params.receipts : params;
   return binarySearch(
     transactionIndex,
     receipts,
@@ -15,8 +18,9 @@ export function getReceipt(
 /** Returns the transaction for the given transaction index. */
 export function getTransaction(
   transactionIndex: number,
-  transactions: readonly Transaction[],
+  params: { transactions: readonly Transaction[] } | readonly Transaction[],
 ): Transaction | undefined {
+  const transactions = "transactions" in params ? params.transactions : params;
   return binarySearch(
     transactionIndex,
     transactions,