envio 3.6.1-subgraph → 3.7.0-subgraph

package/src/sources/SvmHyperSyncSource.res

@@ -10,17 +10,6 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-// Synthesize a stable logIndex for an SVM instruction so the FetchState
-// ordering machinery (which compares by `(blockNumber, logIndex)`) sorts
-// instructions deterministically within a slot. The bit packing fits inside
-// JS's 53-bit safe-integer range: transactionIndex ≤ ~10k per slot,
-// instruction position ≤ 1000 per tx, depth ≤ ~10. Outer-only instructions
-// land at `tx * 65536`; inner ones append depth-weighted offsets.
-let synthLogIndex = (~transactionIndex, ~instructionAddress) => {
-  let addrSum = instructionAddress->Array.reduce(0, (acc, n) => acc * 1024 + n + 1)
-  transactionIndex * 65536 + addrSum
-}
-
 // Parse the Rust-decoded instruction (args/accounts arrive as JSON strings to
 // side-step napi-rs's lack of native JSON passthrough) into the public shape.
 let parseDecoded = (
@@ -68,7 +57,14 @@ let toSvmInstruction = (
 }
 
 let make = (
-  {chainId, endpointUrl, apiToken, onEventRegistrations, clientTimeoutMillis, addressStore}: options,
+  {
+    chainId,
+    endpointUrl,
+    apiToken,
+    onEventRegistrations,
+    clientTimeoutMillis,
+    addressStore,
+  }: options,
 ): t => {
   let name = "SvmHyperSync"
 
@@ -112,6 +108,9 @@ let make = (
       ~addressSet,
     ) catch {
     | exn =>
+      // A rate limit or a replica behind the head is recoverable and has its own
+      // backoff and failover, so it must not be buried in a generic retry.
+      HyperSync.reraiseIfRecoverable(exn)
       throw(
         Source.GetItemsError(
           Source.FailedGettingItems({
@@ -133,17 +132,6 @@ let make = (
 
     let parsingRef = Performance.now()
 
-    // Per-slot blockTime lookup from the response's `blocks` table, for the
-    // batch's `latestFetchedBlockTimestamp`. Slots without a block row (rare;
-    // usually skipped slots) fall back to `None`.
-    let blockTimeBySlot = Dict.make()
-    resp.blocks->Array.forEach(b => {
-      switch b.blockTime {
-      | Some(t) => blockTimeBySlot->Dict.set(b.slot->Int.toString, t)
-      | None => ()
-      }
-    })
-
     let parsedQueueItems = resp.items->Array.map(item => {
       // Routing happened in Rust; the item references its registration by
       // chain-scoped index.
@@ -161,10 +149,13 @@ let make = (
         onEventRegistration,
         chainId,
         blockNumber: item.slot,
-        logIndex: synthLogIndex(
-          ~transactionIndex=item.transactionIndex,
-          ~instructionAddress=item.instructionAddress,
-        ),
+        // A slot orders by `(transactionIndex, instructionAddress)` — the
+        // transaction, then the instruction's position in its CPI tree. Both
+        // ride the item so the buffer comparator can order on the pair
+        // directly; no single integer can hold it (Solana allows a CPI depth
+        // of 5, which needs more bits than a JS integer is exact to).
+        logIndex: item.transactionIndex,
+        orderPath: item.instructionAddress,
         // The parent transaction is materialised from the store at batch prep.
         transactionIndex: item.transactionIndex,
         payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),
@@ -173,112 +164,29 @@ let make = (
 
     let parsingTimeElapsed = parsingRef->Performance.secondsSince
     let highestSlot = resp.nextSlot - 1
-    let latestBlockTime =
-      blockTimeBySlot
-      ->Utils.Dict.dangerouslyGetNonOption(highestSlot->Int.toString)
-      ->Option.getOr(0)
-
-    // Best-effort (slot, blockhash) pairs from the blocks the server returned
-    // for this range. Gaps (skipped slots, or slots without matched data) are
-    // fine — reorg detection only compares hashes for slots it has observed.
-    let blockHashes = resp.blocks->Array.map((b): ReorgDetection.blockData => {
-      blockNumber: b.slot,
-      blockHash: b.blockhash,
-    })
 
     let totalTimeElapsed = totalTimeRef->Performance.secondsSince
 
     {
-      latestFetchedBlockTimestamp: latestBlockTime,
       parsedQueueItems,
       // Raw transactions kept in Rust; materialised (selected fields) at batch prep.
       transactionStore: Some(transactionStore),
       // Raw blocks kept in Rust; materialised onto the payload at batch prep.
-      blockStore: Some(blockStore),
+      // Their (slot, blockhash) pairs also drive reorg detection on merge.
+      blockStore,
       latestFetchedBlockNumber: highestSlot,
       stats: {totalTimeElapsed, parsingTimeElapsed, pageFetchTime},
       knownHeight,
-      blockHashes,
       fromBlockQueried: fromBlock,
       requestStats,
     }
   }
 
-  // Fetch (slot, blockhash, blockTime) for blocks in an inclusive slot range,
-  // paginating on the server's `nextSlot` cursor. `toSlot` is exclusive on the
-  // wire, so we request `maxSlot + 1`; the caller filters to the exact slots.
-  let queryBlockDataRange = async (~fromSlot, ~toSlot) => {
-    let blockDatas = []
-    let requestStats = []
-    let fromRef = ref(fromSlot)
-    let keepGoing = ref(true)
-    while keepGoing.contents {
-      let query: SvmHyperSyncClient.query = {
-        fromSlot: fromRef.contents,
-        toSlot: toSlot + 1,
-        includeAllBlocks: true,
-        fields: {block: [Slot, Blockhash, BlockTime]},
-        maxNumBlocks: 1000,
-      }
-      let timerRef = Performance.now()
-      // Block-only query; the store pages are empty.
-      let (resp, _, _) = await client.get(~query)
-      requestStats
-      ->Array.push({Source.method: "getBlockHashes", seconds: timerRef->Performance.secondsSince})
-      ->ignore
-      resp.data.blocks->Array.forEach(b =>
-        blockDatas
-        ->Array.push({
-          ReorgDetection.blockNumber: b.slot,
-          blockHash: b.blockhash,
-          blockTimestamp: b.blockTime->Option.getOr(0),
-        })
-        ->ignore
-      )
-
-      // `nextSlot` is the (exclusive) resume cursor. Stop once it passes the
-      // range, or fails to advance — the latter guards against an infinite loop.
-      if resp.nextSlot > toSlot || resp.nextSlot <= fromRef.contents {
-        keepGoing := false
-      } else {
-        fromRef := resp.nextSlot
-      }
-    }
-    (blockDatas, requestStats)
-  }
-
-  let getBlockHashes = async (~blockNumbers, ~logger as _) =>
-    switch blockNumbers->Array.get(0) {
-    | None => {Source.result: Ok([]), requestStats: []}
-    | Some(firstSlot) =>
-      try {
-        let minSlot = ref(firstSlot)
-        let maxSlot = ref(firstSlot)
-        let requested = Utils.Set.make()
-        blockNumbers->Array.forEach(slot => {
-          if slot < minSlot.contents {
-            minSlot := slot
-          }
-          if slot > maxSlot.contents {
-            maxSlot := slot
-          }
-          requested->Utils.Set.add(slot)->ignore
-        })
-        let (blockDatas, requestStats) = await queryBlockDataRange(
-          ~fromSlot=minSlot.contents,
-          ~toSlot=maxSlot.contents,
-        )
-        // Keep one entry per requested slot; drop duplicates and unrelated slots.
-        {
-          Source.result: Ok(
-            blockDatas->Array.filter(data => requested->Utils.Set.delete(data.blockNumber)),
-          ),
-          requestStats,
-        }
-      } catch {
-      | exn => {Source.result: Error(exn), requestStats: []}
-      }
-    }
+  // Called through the client rather than passed as a value: the client is a
+  // napi class, so a detached method reference loses the instance it belongs to.
+  let getBlockHashes = HyperSync.makeGetBlockHashes(
+    ~query=(~blockNumbers) => client.getBlockHashes(~blockNumbers),
+  )
 
   {
     name,

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -1,18 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Source from "./Source.res.mjs";
+import * as HyperSync from "./HyperSync.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as SvmHyperSyncClient from "./SvmHyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function synthLogIndex(transactionIndex, instructionAddress) {
-  let addrSum = Stdlib_Array.reduce(instructionAddress, 0, (acc, n) => ((acc << 10) + n | 0) + 1 | 0);
-  return (transactionIndex << 16) + addrSum | 0;
-}
-
 function parseDecoded(d) {
   let args;
   try {
@@ -58,7 +53,7 @@ function toSvmInstruction(item, programName, instructionName) {
 function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
   let chainId = param.chainId;
-  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
+  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
   let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let pageFetchRef = Performance.now();
@@ -76,6 +71,7 @@ function make(param) {
       match = await client.getEventItems(query, addressSet);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
+      HyperSync.reraiseIfRecoverable(exn);
       throw {
         RE_EXN_ID: Source.GetItemsError,
         _1: {
@@ -98,14 +94,6 @@ function make(param) {
         seconds: pageFetchTime
       }];
     let parsingRef = Performance.now();
-    let blockTimeBySlot = {};
-    resp.blocks.forEach(b => {
-      let t = b.blockTime;
-      if (t !== undefined) {
-        blockTimeBySlot[b.slot.toString()] = t;
-        return;
-      }
-    });
     let parsedQueueItems = resp.items.map(item => {
       let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
       let eventConfig = onEventRegistration.eventConfig;
@@ -115,28 +103,22 @@ function make(param) {
         onEventRegistration: onEventRegistration,
         chainId: chainId,
         blockNumber: item.slot,
-        logIndex: synthLogIndex(item.transactionIndex, item.instructionAddress),
+        logIndex: item.transactionIndex,
+        orderPath: item.instructionAddress,
         transactionIndex: item.transactionIndex,
         payload: payload
       };
     });
     let parsingTimeElapsed = Performance.secondsSince(parsingRef);
     let highestSlot = resp.nextSlot - 1 | 0;
-    let latestBlockTime = Stdlib_Option.getOr(blockTimeBySlot[highestSlot.toString()], 0);
-    let blockHashes = resp.blocks.map(b => ({
-      blockHash: b.blockhash,
-      blockNumber: b.slot
-    }));
     let totalTimeElapsed = Performance.secondsSince(totalTimeRef);
     return {
       knownHeight: knownHeight,
-      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       transactionStore: Primitive_option.some(match[1]),
-      blockStore: Primitive_option.some(match[2]),
+      blockStore: match[2],
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: highestSlot,
-      latestFetchedBlockTimestamp: latestBlockTime,
       stats: {
         "total time elapsed (s)": totalTimeElapsed,
         "parsing time (s)": parsingTimeElapsed,
@@ -145,101 +127,7 @@ function make(param) {
       requestStats: requestStats
     };
   };
-  let queryBlockDataRange = async (fromSlot, toSlot) => {
-    let blockDatas = [];
-    let requestStats = [];
-    let fromRef = fromSlot;
-    let keepGoing = true;
-    while (keepGoing) {
-      let query_toSlot = toSlot + 1 | 0;
-      let query_includeAllBlocks = true;
-      let query_fields = {
-        block: [
-          "slot",
-          "blockhash",
-          "block_time"
-        ]
-      };
-      let query_maxNumBlocks = 1000;
-      let query = {
-        fromSlot: fromRef,
-        toSlot: query_toSlot,
-        includeAllBlocks: query_includeAllBlocks,
-        fields: query_fields,
-        maxNumBlocks: query_maxNumBlocks
-      };
-      let timerRef = Performance.now();
-      let match = await client.get(query);
-      let resp = match[0];
-      requestStats.push({
-        method: "getBlockHashes",
-        seconds: Performance.secondsSince(timerRef)
-      });
-      resp.data.blocks.forEach(b => {
-        blockDatas.push({
-          blockHash: b.blockhash,
-          blockNumber: b.slot,
-          blockTimestamp: Stdlib_Option.getOr(b.blockTime, 0)
-        });
-      });
-      if (resp.nextSlot > toSlot || resp.nextSlot <= fromRef) {
-        keepGoing = false;
-      } else {
-        fromRef = resp.nextSlot;
-      }
-    };
-    return [
-      blockDatas,
-      requestStats
-    ];
-  };
-  let getBlockHashes = async (blockNumbers, param) => {
-    let firstSlot = blockNumbers[0];
-    if (firstSlot === undefined) {
-      return {
-        result: {
-          TAG: "Ok",
-          _0: []
-        },
-        requestStats: []
-      };
-    }
-    try {
-      let minSlot = {
-        contents: firstSlot
-      };
-      let maxSlot = {
-        contents: firstSlot
-      };
-      let requested = new Set();
-      blockNumbers.forEach(slot => {
-        if (slot < minSlot.contents) {
-          minSlot.contents = slot;
-        }
-        if (slot > maxSlot.contents) {
-          maxSlot.contents = slot;
-        }
-        requested.add(slot);
-      });
-      let match = await queryBlockDataRange(minSlot.contents, maxSlot.contents);
-      return {
-        result: {
-          TAG: "Ok",
-          _0: match[0].filter(data => requested.delete(data.blockNumber))
-        },
-        requestStats: match[1]
-      };
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      return {
-        result: {
-          TAG: "Error",
-          _0: exn
-        },
-        requestStats: []
-      };
-    }
-  };
+  let getBlockHashes = HyperSync.makeGetBlockHashes(blockNumbers => client.getBlockHashes(blockNumbers));
   return {
     name: "SvmHyperSync",
     sourceFor: "Sync",
@@ -264,9 +152,8 @@ function make(param) {
 }
 
 export {
-  synthLogIndex,
   parseDecoded,
   toSvmInstruction,
   make,
 }
-/* SvmHyperSyncClient Not a pure module */
+/* Source Not a pure module */

package/src/subgraph/calls.ts

@@ -177,7 +177,11 @@ export function makeCallEffect(rpcUrls: string[]) {
           functionName: name,
           data: (result.data ?? "0x") as `0x${string}`,
         });
-        const values = Array.isArray(decoded) ? decoded : [decoded];
+        // graph-ts returns one `ethereum.Value` per ABI output. A single
+        // tuple/struct is therefore `[tuple]`, not the flattened fields —
+        // generated bindings call `result[0].toTuple()`.
+        const outputs = (abi[0] as { outputs?: unknown[] }).outputs ?? [];
+        const values = outputs.length === 1 ? [decoded] : Array.isArray(decoded) ? decoded : [decoded];
         return JSON.stringify({ reverted: false, values: values.map(encodeArg) });
       } catch {
         // Output the declared signature can't decode counts as a failed call,

package/src/subgraph/division.ts

@@ -54,6 +54,16 @@ export function integerDivision(a: unknown, b: unknown): unknown {
 }
 
 export const DIVIDE_HELPER = "__envio_idiv";
+export const RETAG_HELPER = "__envio_retag";
+
+/** `changetype<Foo>(x)` → `__envio_retag(Foo, x)` when Foo is a class name. */
+export function rewriteChangetype(source: string): string {
+  if (!source.includes("changetype<")) return source;
+  return source.replace(
+    /changetype\s*<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>\s*\(/g,
+    `${RETAG_HELPER}($1, `,
+  );
+}
 
 /** Returns the source unchanged when it divides nothing, or can't be parsed. */
 export function rewriteDivision(source: string): string {

package/src/subgraph/graph-ts.ts

@@ -653,6 +653,14 @@ export class Value {
   toArray(): Value[] {
     return this.data as Value[];
   }
+  // Official `ethereum.Value` exposes these; generated bindings call
+  // `result[0].toTuple()` on every struct/tuple return.
+  toTuple(): Value[] {
+    return this.toArray();
+  }
+  toTupleArray(): Value[][] {
+    return this.toArray().map(value => value.toArray());
+  }
   toMatrix(): Value[][] {
     return this.toArray().map((row) => row.toArray());
   }
@@ -769,8 +777,9 @@ export class Entity extends TypedMap<string, Value> {
     this.set(key, Value.fromNull());
   }
   merge(sources: Entity[]): this {
-    for (const entity of sources) {
-      for (const entry of entity.entries) {
+    // graph-ts assigns right to left, so the leftmost source wins a key.
+    for (let index = sources.length - 1; index >= 0; index--) {
+      for (const entry of sources[index].entries) {
         this.set(entry.key, entry.value);
       }
     }
@@ -1020,7 +1029,59 @@ export const store = strictNamespace("store", storeImpl);
 // ethereum
 // ---------------------------------------------------------------------------
 
-export class EthereumValue extends Value {}
+/**
+ * `ethereum.Value` names its factories after Solidity types rather than store
+ * ones, and `graph codegen` emits those names for every contract-call argument.
+ * They tag the same store kinds underneath — an ABI value's Solidity type is
+ * already carried by the call signature.
+ */
+export class EthereumValue extends Value {
+  static fromSignedBigInt(value: BigInt_): Value {
+    return Value.fromBigInt(value);
+  }
+  static fromUnsignedBigInt(value: BigInt_): Value {
+    return Value.fromBigInt(value);
+  }
+  static fromFixedBytes(value: Bytes): Value {
+    return Value.fromBytes(value);
+  }
+  static fromTuple(values: Value[]): Value {
+    return Value.fromArray(values);
+  }
+  static fromFixedSizedArray(values: Value[]): Value {
+    return Value.fromArray(values);
+  }
+  static fromTupleArray(values: Value[][]): Value {
+    return Value.fromArray(values.map(EthereumValue.fromTuple));
+  }
+  static fromAddressArray(values: Address[]): Value {
+    return Value.fromArray(values.map(Value.fromAddress));
+  }
+  static fromFixedBytesArray(values: Bytes[]): Value {
+    return Value.fromArray(values.map(Value.fromBytes));
+  }
+  static fromSignedBigIntArray(values: BigInt_[]): Value {
+    return Value.fromArray(values.map(Value.fromBigInt));
+  }
+  static fromUnsignedBigIntArray(values: BigInt_[]): Value {
+    return Value.fromArray(values.map(Value.fromBigInt));
+  }
+  toTuple(): Value[] {
+    return this.toArray();
+  }
+  toTupleArray(): Value[][] {
+    return this.toArray().map(value => value.toArray());
+  }
+  toFixedBytes(): Bytes {
+    return this.toBytes();
+  }
+  toAddressArray(): Address[] {
+    return this.toArray().map(value => value.toAddress());
+  }
+  toFixedBytesArray(): Bytes[] {
+    return this.toArray().map(value => value.toBytes());
+  }
+}
 
 class SmartContractCall {
   constructor(
@@ -1119,7 +1180,9 @@ function callContract(
 }
 
 function toEthereumValue(value: unknown): EthereumValue {
-  return toValue(value) as EthereumValue;
+  if (value instanceof EthereumValue) return value;
+  const wrapped = toValue(value);
+  return new EthereumValue(wrapped.kind, wrapped.data);
 }
 
 /** A graph-ts value as the plain JS an ABI encoder takes. */
@@ -1629,6 +1692,17 @@ export function changetype<T>(value: unknown): T {
   return value as T;
 }
 
+// `changetype<GeneratedTuple>(result[0].toTuple())` is a pointer reinterpret
+// in AssemblyScript; in JS the named getters live on the generated class.
+// The load hook rewrites that call to this helper so `.value` etc. resolve.
+export function retagChangetype(ctor: unknown, value: unknown): unknown {
+  if (value !== null && typeof value === "object" && typeof ctor === "function") {
+    const proto = (ctor as Function).prototype;
+    if (proto) Object.setPrototypeOf(value, proto);
+  }
+  return changetype(value);
+}
+
 /**
  * AssemblyScript's primitives are namespaces as well as types: `i32.MAX_VALUE`
  * reads a bound, `i32(x)` truncates to one. Both are ordinary source in a
@@ -1693,3 +1767,105 @@ export const assemblyScriptPrimitives: Record<string, unknown> = {
   f32: floatNamespace("f32", true),
   f64: floatNamespace("f64", false),
 };
+
+// ---------------------------------------------------------------------------
+// Host namespaces the generated declarations re-export
+//
+// A mapping importing one of these fails at ESM link time if it isn't exported,
+// which is a missing-export error naming nothing useful. Exporting them means an
+// unsupported one refuses by name like everything else.
+// ---------------------------------------------------------------------------
+
+const typeConversionImpl = {
+  bytesToString: (bytes: Uint8Array) => new TextDecoder().decode(bytes),
+  bytesToHex: (bytes: Uint8Array) => new ByteArray(bytes).toHexString(),
+  bigIntToString: (value: Uint8Array) => new BigInt_(fromLittleEndian(value, true)).toString(),
+  bigIntToHex: (value: Uint8Array) => new BigInt_(fromLittleEndian(value, true)).toHexString(),
+  stringToH160: (value: string) => Address.fromString(value) as Bytes,
+  bytesToBase58: (_: Uint8Array): string => {
+    throw unsupported("typeConversion.bytesToBase58", "a mapping handler");
+  },
+};
+
+export const typeConversion = strictNamespace("typeConversion", typeConversionImpl);
+
+const bigIntImpl = {
+  plus: (x: BigInt_, y: BigInt_) => x.plus(y),
+  minus: (x: BigInt_, y: BigInt_) => x.minus(y),
+  times: (x: BigInt_, y: BigInt_) => x.times(y),
+  dividedBy: (x: BigInt_, y: BigInt_) => x.div(y),
+  dividedByDecimal: (x: BigInt_, y: BigDecimal) => x.toBigDecimal().div(y),
+  mod: (x: BigInt_, y: BigInt_) => x.mod(y),
+  pow: (x: BigInt_, exp: number) => x.pow(exp),
+  fromString: (value: string) => BigInt_.fromString(value),
+  bitOr: (x: BigInt_, y: BigInt_) => x.bitOr(y),
+  bitAnd: (x: BigInt_, y: BigInt_) => x.bitAnd(y),
+  leftShift: (x: BigInt_, bits: number) => x.leftShift(bits),
+  rightShift: (x: BigInt_, bits: number) => x.rightShift(bits),
+};
+
+export const bigInt = strictNamespace("bigInt", bigIntImpl);
+
+const bigDecimalImpl = {
+  plus: (x: BigDecimal, y: BigDecimal) => x.plus(y),
+  minus: (x: BigDecimal, y: BigDecimal) => x.minus(y),
+  times: (x: BigDecimal, y: BigDecimal) => x.times(y),
+  dividedBy: (x: BigDecimal, y: BigDecimal) => x.div(y),
+  equals: (x: BigDecimal, y: BigDecimal) => x.equals(y),
+  toString: (value: BigDecimal) => value.toString(),
+  fromString: (value: string) => BigDecimal.fromString(value),
+};
+
+export const bigDecimal = strictNamespace("bigDecimal", bigDecimalImpl);
+
+export function concat(a: ByteArray, b: ByteArray): ByteArray {
+  return a.concat(b);
+}
+
+export function parseCSV(csv: string): string[] {
+  return csv.split(",").map(field => field.trim());
+}
+
+/** Restores the multihash prefix an IPFS hash loses when stored in a bytes32. */
+export function addQm(a: ByteArray): ByteArray {
+  return ByteArray.fromHexString("0x1220").concat(a);
+}
+
+export enum YAMLValueKind {
+  NULL = 0,
+  BOOL = 1,
+  NUMBER = 2,
+  STRING = 3,
+  ARRAY = 4,
+  OBJECT = 5,
+  TAGGED = 6,
+}
+
+export class YAMLValue {
+  constructor(_kind: YAMLValueKind, _data: unknown) {
+    throw unsupported("the yaml API", "a mapping handler");
+  }
+}
+
+export class YAMLTaggedValue {
+  constructor(_tag: string, _value: YAMLValue) {
+    throw unsupported("the yaml API", "a mapping handler");
+  }
+}
+
+const yamlImpl = {
+  fromBytes: (_: Bytes): YAMLValue => {
+    throw unsupported("yaml.fromBytes", "a mapping handler");
+  },
+  try_fromBytes: (_: Bytes): unknown => {
+    throw unsupported("yaml.try_fromBytes", "a mapping handler");
+  },
+  fromString: (_: string): YAMLValue => {
+    throw unsupported("yaml.fromString", "a mapping handler");
+  },
+  try_fromString: (_: string): unknown => {
+    throw unsupported("yaml.try_fromString", "a mapping handler");
+  },
+};
+
+export const yaml = strictNamespace("yaml", yamlImpl);