@trufnetwork/sdk-js 0.6.0 → 0.6.2

package/dist/esm/util/orderbookHelpers.test.mjs

@@ -1,51 +1,284 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/util/orderbookHelpers.ts
+var orderbookHelpers_exports = {};
+__export(orderbookHelpers_exports, {
+  bytesToHex: () => bytesToHex,
+  dbBytesToUint8Array: () => dbBytesToUint8Array,
+  decodeMarketData: () => decodeMarketData,
+  encodeActionArgs: () => encodeActionArgs,
+  encodeEqualsActionArgs: () => encodeEqualsActionArgs,
+  encodeQueryComponents: () => encodeQueryComponents,
+  encodeRangeActionArgs: () => encodeRangeActionArgs,
+  hexToBytes: () => hexToBytes,
+  settledFilterToBoolean: () => settledFilterToBoolean,
+  stringToBytes32: () => stringToBytes32,
+  validateAmount: () => validateAmount,
+  validateBridge: () => validateBridge,
+  validateMaxSpread: () => validateMaxSpread,
+  validatePrice: () => validatePrice,
+  validateSettleTime: () => validateSettleTime
+});
+import { ethers } from "ethers";
+import { Utils } from "@trufnetwork/kwil-js";
+import {
+  encodeActionArgs as encodeActionArgsKwil,
+  decodeActionArgs,
+  decodeQueryComponents
+} from "./AttestationEncoding.mjs";
+function decodeMarketData(encoded) {
+  const bytes = dbBytesToUint8Array(encoded);
+  const { dataProvider, streamId, actionId, args: argsBytes } = decodeQueryComponents(bytes);
+  const args = decodeActionArgs(argsBytes);
+  const market = {
+    dataProvider,
+    streamId,
+    actionId,
+    type: "unknown",
+    thresholds: []
+  };
+  switch (actionId) {
+    case "price_above_threshold":
+      market.type = "above";
+      if (args.length >= 4) {
+        market.thresholds.push(args[3].toString());
+      }
+      break;
+    case "price_below_threshold":
+      market.type = "below";
+      if (args.length >= 4) {
+        market.thresholds.push(args[3].toString());
+      }
+      break;
+    case "value_in_range":
+      market.type = "between";
+      if (args.length >= 5) {
+        market.thresholds.push(args[3].toString(), args[4].toString());
+      }
+      break;
+    case "value_equals":
+      market.type = "equals";
+      if (args.length >= 5) {
+        market.thresholds.push(args[3].toString(), args[4].toString());
+      }
+      break;
+  }
+  return market;
+}
+function encodeActionArgs(dataProvider, streamId, timestamp, threshold, frozenAt) {
+  return encodeActionArgsKwil(
+    [
+      dataProvider.toLowerCase(),
+      // TEXT: data provider address
+      streamId,
+      // TEXT: stream ID
+      timestamp,
+      // INT8: timestamp
+      threshold,
+      // NUMERIC: threshold - must specify type explicitly
+      frozenAt === 0 ? null : frozenAt
+      // INT8: frozen_at (null for latest)
+    ],
+    {
+      // Argument 3 (threshold) must be NUMERIC(36, 18) to match price_above_threshold action signature
+      3: Utils.DataType.Numeric(36, 18)
+    }
+  );
+}
+function encodeRangeActionArgs(dataProvider, streamId, timestamp, minValue, maxValue, frozenAt) {
+  return encodeActionArgsKwil(
+    [
+      dataProvider.toLowerCase(),
+      streamId,
+      timestamp,
+      minValue,
+      maxValue,
+      frozenAt === 0 ? null : frozenAt
+    ],
+    {
+      // Arguments 3, 4 (minValue, maxValue) must be NUMERIC(36, 18)
+      3: Utils.DataType.Numeric(36, 18),
+      4: Utils.DataType.Numeric(36, 18)
+    }
+  );
+}
+function encodeEqualsActionArgs(dataProvider, streamId, timestamp, targetValue, tolerance, frozenAt) {
+  return encodeActionArgsKwil(
+    [
+      dataProvider.toLowerCase(),
+      streamId,
+      timestamp,
+      targetValue,
+      tolerance,
+      frozenAt === 0 ? null : frozenAt
+    ],
+    {
+      // Arguments 3, 4 (targetValue, tolerance) must be NUMERIC(36, 18)
+      3: Utils.DataType.Numeric(36, 18),
+      4: Utils.DataType.Numeric(36, 18)
+    }
+  );
+}
+function encodeQueryComponents(dataProvider, streamId, actionId, args) {
+  const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+  const streamIdBytes = stringToBytes32(streamId);
+  const encoded = abiCoder.encode(
+    ["address", "bytes32", "string", "bytes"],
+    [dataProvider, streamIdBytes, actionId, args]
+  );
+  return ethers.getBytes(encoded);
+}
+function stringToBytes32(str) {
+  const bytes = ethers.toUtf8Bytes(str);
+  if (bytes.length > 32) {
+    throw new Error(`String too long for bytes32: ${str.length} characters`);
+  }
+  return ethers.zeroPadValue(bytes, 32);
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex : "0x" + hex;
+  return ethers.getBytes(cleanHex);
+}
+function isBase64(str) {
+  const s = str.startsWith("0x") ? str.slice(2) : str;
+  return /[+/=]/.test(s) || !/^[0-9a-fA-F]*$/.test(s);
+}
+function base64ToBytes(b64) {
+  const cleanB64 = b64.startsWith("0x") ? b64.slice(2) : b64;
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(cleanB64, "base64"));
+  }
+  const binary = atob(cleanB64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function dbBytesToUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (isBase64(value)) {
+      return base64ToBytes(value);
+    }
+    return hexToBytes(value);
+  }
+  throw new Error(`Unexpected bytes value type: ${typeof value}`);
+}
+function bytesToHex(bytes) {
+  return ethers.hexlify(bytes);
+}
+function validatePrice(price, operation) {
+  if (!Number.isInteger(price)) {
+    throw new Error(`${operation}: Price must be an integer`);
+  }
+  if (price < 1 || price > 99) {
+    throw new Error(`${operation}: Price must be between 1 and 99 cents`);
+  }
+}
+function validateAmount(amount, operation) {
+  if (!Number.isInteger(amount)) {
+    throw new Error(`${operation}: Amount must be an integer`);
+  }
+  if (amount <= 0) {
+    throw new Error(`${operation}: Amount must be positive`);
+  }
+  if (amount > 1e9) {
+    throw new Error(`${operation}: Amount exceeds maximum (1,000,000,000)`);
+  }
+}
+function validateBridge(bridge) {
+  const validBridges = ["hoodi_tt2", "sepolia_bridge", "ethereum_bridge"];
+  if (!validBridges.includes(bridge)) {
+    throw new Error(
+      `Invalid bridge: ${bridge}. Must be one of: ${validBridges.join(", ")}`
+    );
+  }
+}
+function validateMaxSpread(maxSpread) {
+  if (!Number.isInteger(maxSpread)) {
+    throw new Error("Max spread must be an integer");
+  }
+  if (maxSpread < 1 || maxSpread > 50) {
+    throw new Error("Max spread must be between 1 and 50 cents");
+  }
+}
+function validateSettleTime(settleTime) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (settleTime <= now) {
+    throw new Error("Settle time must be in the future");
+  }
+}
+function settledFilterToBoolean(filter) {
+  if (filter === null || filter === void 0) {
+    return null;
+  }
+  return filter;
+}
+var init_orderbookHelpers = __esm({
+  "src/util/orderbookHelpers.ts"() {
+    "use strict";
+  }
+});
+
 // src/util/orderbookHelpers.test.ts
 import { describe, it, expect } from "vitest";
 import {
-  encodeActionArgs,
-  encodeQueryComponents,
-  encodeRangeActionArgs,
-  encodeEqualsActionArgs,
-  stringToBytes32,
-  hexToBytes,
-  bytesToHex,
-  validatePrice,
-  validateAmount,
-  validateBridge,
-  validateMaxSpread,
-  validateSettleTime,
-  settledFilterToBoolean
+  encodeActionArgs as encodeActionArgs2,
+  encodeQueryComponents as encodeQueryComponents2,
+  encodeRangeActionArgs as encodeRangeActionArgs2,
+  encodeEqualsActionArgs as encodeEqualsActionArgs2,
+  stringToBytes32 as stringToBytes322,
+  hexToBytes as hexToBytes2,
+  bytesToHex as bytesToHex2,
+  validatePrice as validatePrice2,
+  validateAmount as validateAmount2,
+  validateBridge as validateBridge2,
+  validateMaxSpread as validateMaxSpread2,
+  validateSettleTime as validateSettleTime2,
+  settledFilterToBoolean as settledFilterToBoolean2
 } from "./orderbookHelpers.mjs";
 var TEST_STREAM_ID = "stbtc000000000000000000000000000";
 var TEST_DATA_PROVIDER = "0x4710a8d8f0d845da110086812a32de6d90d7ff5c";
 describe("orderbookHelpers", () => {
   describe("stringToBytes32", () => {
     it("should convert a short string to bytes32", () => {
-      const result = stringToBytes32("test");
+      const result = stringToBytes322("test");
       expect(result).toMatch(/^0x/);
       expect(result.length).toBe(66);
     });
     it("should convert a 32-char string to bytes32", () => {
       const str = "abcdefghijklmnopqrstuvwxyz123456";
       expect(str.length).toBe(32);
-      const result = stringToBytes32(str);
+      const result = stringToBytes322(str);
       expect(result).toMatch(/^0x/);
       expect(result.length).toBe(66);
     });
     it("should throw for strings longer than 32 bytes", () => {
       const longStr = "a".repeat(33);
-      expect(() => stringToBytes32(longStr)).toThrow("String too long");
+      expect(() => stringToBytes322(longStr)).toThrow("String too long");
     });
   });
   describe("hexToBytes", () => {
     it("should convert hex string with 0x prefix", () => {
-      const result = hexToBytes("0x1234");
+      const result = hexToBytes2("0x1234");
       expect(result).toBeInstanceOf(Uint8Array);
       expect(result.length).toBe(2);
       expect(result[0]).toBe(18);
       expect(result[1]).toBe(52);
     });
     it("should convert hex string without 0x prefix", () => {
-      const result = hexToBytes("abcd");
+      const result = hexToBytes2("abcd");
       expect(result).toBeInstanceOf(Uint8Array);
       expect(result.length).toBe(2);
       expect(result[0]).toBe(171);
@@ -55,107 +288,107 @@ describe("orderbookHelpers", () => {
   describe("bytesToHex", () => {
     it("should convert Uint8Array to hex string with 0x prefix", () => {
       const bytes = new Uint8Array([18, 52, 171, 205]);
-      const result = bytesToHex(bytes);
+      const result = bytesToHex2(bytes);
       expect(result).toBe("0x1234abcd");
     });
     it("should handle empty array", () => {
       const bytes = new Uint8Array([]);
-      const result = bytesToHex(bytes);
+      const result = bytesToHex2(bytes);
       expect(result).toBe("0x");
     });
   });
   describe("validatePrice", () => {
     it("should accept valid prices (1-99)", () => {
-      expect(() => validatePrice(1, "test")).not.toThrow();
-      expect(() => validatePrice(50, "test")).not.toThrow();
-      expect(() => validatePrice(99, "test")).not.toThrow();
+      expect(() => validatePrice2(1, "test")).not.toThrow();
+      expect(() => validatePrice2(50, "test")).not.toThrow();
+      expect(() => validatePrice2(99, "test")).not.toThrow();
     });
     it("should reject price 0", () => {
-      expect(() => validatePrice(0, "test")).toThrow("between 1 and 99");
+      expect(() => validatePrice2(0, "test")).toThrow("between 1 and 99");
     });
     it("should reject price 100", () => {
-      expect(() => validatePrice(100, "test")).toThrow("between 1 and 99");
+      expect(() => validatePrice2(100, "test")).toThrow("between 1 and 99");
     });
     it("should reject negative prices", () => {
-      expect(() => validatePrice(-1, "test")).toThrow("between 1 and 99");
+      expect(() => validatePrice2(-1, "test")).toThrow("between 1 and 99");
     });
     it("should reject non-integer prices", () => {
-      expect(() => validatePrice(50.5, "test")).toThrow("must be an integer");
+      expect(() => validatePrice2(50.5, "test")).toThrow("must be an integer");
     });
   });
   describe("validateAmount", () => {
     it("should accept valid amounts", () => {
-      expect(() => validateAmount(1, "test")).not.toThrow();
-      expect(() => validateAmount(1e6, "test")).not.toThrow();
+      expect(() => validateAmount2(1, "test")).not.toThrow();
+      expect(() => validateAmount2(1e6, "test")).not.toThrow();
     });
     it("should reject zero amount", () => {
-      expect(() => validateAmount(0, "test")).toThrow("must be positive");
+      expect(() => validateAmount2(0, "test")).toThrow("must be positive");
     });
     it("should reject negative amounts", () => {
-      expect(() => validateAmount(-1, "test")).toThrow("must be positive");
+      expect(() => validateAmount2(-1, "test")).toThrow("must be positive");
     });
     it("should reject amounts over 1 billion", () => {
-      expect(() => validateAmount(1000000001, "test")).toThrow("exceeds maximum");
+      expect(() => validateAmount2(1000000001, "test")).toThrow("exceeds maximum");
     });
     it("should reject non-integer amounts", () => {
-      expect(() => validateAmount(10.5, "test")).toThrow("must be an integer");
+      expect(() => validateAmount2(10.5, "test")).toThrow("must be an integer");
     });
   });
   describe("validateBridge", () => {
     it("should accept valid bridges", () => {
-      expect(() => validateBridge("hoodi_tt2")).not.toThrow();
-      expect(() => validateBridge("sepolia_bridge")).not.toThrow();
-      expect(() => validateBridge("ethereum_bridge")).not.toThrow();
+      expect(() => validateBridge2("hoodi_tt2")).not.toThrow();
+      expect(() => validateBridge2("sepolia_bridge")).not.toThrow();
+      expect(() => validateBridge2("ethereum_bridge")).not.toThrow();
     });
     it("should reject invalid bridges", () => {
-      expect(() => validateBridge("invalid")).toThrow("Invalid bridge");
-      expect(() => validateBridge("")).toThrow("Invalid bridge");
+      expect(() => validateBridge2("invalid")).toThrow("Invalid bridge");
+      expect(() => validateBridge2("")).toThrow("Invalid bridge");
     });
   });
   describe("validateMaxSpread", () => {
     it("should accept valid spreads (1-50)", () => {
-      expect(() => validateMaxSpread(1)).not.toThrow();
-      expect(() => validateMaxSpread(25)).not.toThrow();
-      expect(() => validateMaxSpread(50)).not.toThrow();
+      expect(() => validateMaxSpread2(1)).not.toThrow();
+      expect(() => validateMaxSpread2(25)).not.toThrow();
+      expect(() => validateMaxSpread2(50)).not.toThrow();
     });
     it("should reject spread 0", () => {
-      expect(() => validateMaxSpread(0)).toThrow("between 1 and 50");
+      expect(() => validateMaxSpread2(0)).toThrow("between 1 and 50");
     });
     it("should reject spread over 50", () => {
-      expect(() => validateMaxSpread(51)).toThrow("between 1 and 50");
+      expect(() => validateMaxSpread2(51)).toThrow("between 1 and 50");
     });
   });
   describe("validateSettleTime", () => {
     it("should accept future timestamps", () => {
       const futureTime = Math.floor(Date.now() / 1e3) + 3600;
-      expect(() => validateSettleTime(futureTime)).not.toThrow();
+      expect(() => validateSettleTime2(futureTime)).not.toThrow();
     });
     it("should reject past timestamps", () => {
       const pastTime = Math.floor(Date.now() / 1e3) - 3600;
-      expect(() => validateSettleTime(pastTime)).toThrow("must be in the future");
+      expect(() => validateSettleTime2(pastTime)).toThrow("must be in the future");
     });
     it("should reject current timestamp", () => {
       const now = Math.floor(Date.now() / 1e3);
-      expect(() => validateSettleTime(now)).toThrow("must be in the future");
+      expect(() => validateSettleTime2(now)).toThrow("must be in the future");
     });
   });
   describe("settledFilterToBoolean", () => {
     it("should return null for null (all markets)", () => {
-      expect(settledFilterToBoolean(null)).toBe(null);
+      expect(settledFilterToBoolean2(null)).toBe(null);
     });
     it("should return null for undefined (all markets)", () => {
-      expect(settledFilterToBoolean(void 0)).toBe(null);
+      expect(settledFilterToBoolean2(void 0)).toBe(null);
     });
     it("should return true for true (unsettled)", () => {
-      expect(settledFilterToBoolean(true)).toBe(true);
+      expect(settledFilterToBoolean2(true)).toBe(true);
     });
     it("should return false for false (settled)", () => {
-      expect(settledFilterToBoolean(false)).toBe(false);
+      expect(settledFilterToBoolean2(false)).toBe(false);
     });
   });
   describe("encodeActionArgs", () => {
     it("should encode action arguments", () => {
-      const result = encodeActionArgs(
+      const result = encodeActionArgs2(
         TEST_DATA_PROVIDER,
         TEST_STREAM_ID,
         17e8,
@@ -173,21 +406,21 @@ describe("orderbookHelpers", () => {
         "50000.00",
         1e3
       ];
-      const result1 = encodeActionArgs(...args);
-      const result2 = encodeActionArgs(...args);
-      expect(bytesToHex(result1)).toBe(bytesToHex(result2));
+      const result1 = encodeActionArgs2(...args);
+      const result2 = encodeActionArgs2(...args);
+      expect(bytesToHex2(result1)).toBe(bytesToHex2(result2));
     });
   });
   describe("encodeQueryComponents", () => {
     it("should encode query components", () => {
-      const args = encodeActionArgs(
+      const args = encodeActionArgs2(
         TEST_DATA_PROVIDER,
         TEST_STREAM_ID,
         17e8,
         "50000.00",
         1e3
       );
-      const result = encodeQueryComponents(
+      const result = encodeQueryComponents2(
         TEST_DATA_PROVIDER,
         TEST_STREAM_ID,
         "price_above_threshold",
@@ -199,7 +432,7 @@ describe("orderbookHelpers", () => {
   });
   describe("encodeRangeActionArgs", () => {
     it("should encode range action arguments", () => {
-      const result = encodeRangeActionArgs(
+      const result = encodeRangeActionArgs2(
         TEST_DATA_PROVIDER,
         TEST_STREAM_ID,
         17e8,
@@ -213,7 +446,7 @@ describe("orderbookHelpers", () => {
   });
   describe("encodeEqualsActionArgs", () => {
     it("should encode equals action arguments", () => {
-      const result = encodeEqualsActionArgs(
+      const result = encodeEqualsActionArgs2(
         TEST_DATA_PROVIDER,
         TEST_STREAM_ID,
         17e8,
@@ -225,5 +458,97 @@ describe("orderbookHelpers", () => {
       expect(result.length).toBeGreaterThan(0);
     });
   });
+  describe("decodeMarketData", () => {
+    const importHelper = async () => {
+      const { decodeMarketData: decodeMarketData2 } = await Promise.resolve().then(() => (init_orderbookHelpers(), orderbookHelpers_exports));
+      return { decodeMarketData: decodeMarketData2 };
+    };
+    it("should round-trip price_above_threshold", async () => {
+      const { decodeMarketData: decodeMarketData2 } = await importHelper();
+      const threshold = "100000.0";
+      const args = encodeActionArgs2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        17e8,
+        threshold,
+        0
+      );
+      const encoded = encodeQueryComponents2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        "price_above_threshold",
+        args
+      );
+      const decoded = decodeMarketData2(encoded);
+      expect(decoded.type).toBe("above");
+      expect(decoded.thresholds[0]).toBe(threshold);
+      expect(decoded.dataProvider).toBe(TEST_DATA_PROVIDER.toLowerCase());
+      expect(decoded.streamId).toBe(TEST_STREAM_ID);
+    });
+    it("should round-trip price_below_threshold", async () => {
+      const { decodeMarketData: decodeMarketData2 } = await importHelper();
+      const threshold = "4.5";
+      const args = encodeActionArgs2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        17e8,
+        threshold,
+        0
+      );
+      const encoded = encodeQueryComponents2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        "price_below_threshold",
+        args
+      );
+      const decoded = decodeMarketData2(encoded);
+      expect(decoded.type).toBe("below");
+      expect(decoded.thresholds[0]).toBe(threshold);
+    });
+    it("should round-trip value_in_range", async () => {
+      const { decodeMarketData: decodeMarketData2 } = await importHelper();
+      const min = "90000.0";
+      const max = "110000.0";
+      const args = encodeRangeActionArgs2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        17e8,
+        min,
+        max,
+        0
+      );
+      const encoded = encodeQueryComponents2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        "value_in_range",
+        args
+      );
+      const decoded = decodeMarketData2(encoded);
+      expect(decoded.type).toBe("between");
+      expect(decoded.thresholds).toEqual([min, max]);
+    });
+    it("should round-trip value_equals", async () => {
+      const { decodeMarketData: decodeMarketData2 } = await importHelper();
+      const target = "5.25";
+      const tolerance = "0.01";
+      const args = encodeEqualsActionArgs2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        17e8,
+        target,
+        tolerance,
+        0
+      );
+      const encoded = encodeQueryComponents2(
+        TEST_DATA_PROVIDER,
+        TEST_STREAM_ID,
+        "value_equals",
+        args
+      );
+      const decoded = decodeMarketData2(encoded);
+      expect(decoded.type).toBe("equals");
+      expect(decoded.thresholds).toEqual([target, tolerance]);
+    });
+  });
 });
 //# sourceMappingURL=orderbookHelpers.test.mjs.map