@ickb/sdk 1000.0.52 → 1000.0.81

package/src/codec.ts

@@ -0,0 +1,138 @@
+import { ccc, mol } from "@ckb-ccc/core";
+import { max } from "@ickb/utils";
+
+const N = 1024;
+
+/**
+ * Codec for encoding and decoding a pool snapshot.
+ *
+ * The PoolSnapshotCodec encodes an array of 1024 numbers representing event counts for bins,
+ * where the number of bits used per bin is dynamically computed as the ceiling of log2(max + 1)
+ * across all bins. The codec provides methods to encode the array into a Uint8Array and decode
+ * a Uint8Array back to the original array of numbers.
+ *
+ * @remarks The total number of bits for encoding all the bins is computed as bitsPerBin * 1024. The codec
+ * does not have a fixed byteLength since it depends on the data.
+ */
+export const PoolSnapshot = mol.Codec.from<number[]>({
+  /**
+   * Encodes an array of 1024 bin counts into a Uint8Array.
+   *
+   * @param bins - An array of 1024 numbers. Each number represents the event count for a bin.
+   * @returns A Uint8Array containing the packed bit representation of the bin counts.
+   * @throws Error if the input array does not contain exactly 1024 elements.
+   */
+  encode: (bins) => {
+    if (bins.length !== N) {
+      throw new Error("Expected 1024 bins");
+    }
+
+    const bitsPerBin = computeBits(bins);
+    const buffer = new Uint8Array((bitsPerBin * N) >> 3);
+
+    let bitOffset = 0;
+    for (const count of bins) {
+      packBits(buffer, bitOffset, bitsPerBin, count);
+      bitOffset += bitsPerBin;
+    }
+    return buffer;
+  },
+
+  /**
+   * Decodes a buffer into an array of 1024 bin counts.
+   *
+   * The function automatically computes the number of bits per bin from the buffer length,
+   * expecting that the total number of bits in the buffer is a multiple of 1024.
+   *
+   * @param bufferLike - The input that can be converted into a Uint8Array.
+   * @returns An array of 1024 numbers representing the decoded bin counts.
+   * @throws Error if the buffer length is invalid (i.e., its total bit count is not divisible by 1024).
+   */
+  decode: (bufferLike) => {
+    const buffer = ccc.bytesFrom(bufferLike);
+    // Determine bitsPerBin from the fixed structure (totalBits divided by N).
+    const bitsPerBin = (buffer.byteLength * 8) / N;
+    if (!Number.isInteger(bitsPerBin)) {
+      throw new Error("Invalid buffer length for 1024 bins");
+    }
+    const bins = new Array<number>(N);
+    let bitOffset = 0;
+    for (let i = 0; i < N; i++) {
+      bins[i] = unpackBits(buffer, bitOffset, bitsPerBin);
+      bitOffset += bitsPerBin;
+    }
+    return bins;
+  },
+  // Note: The byteLength is not fixed as it depends on the data (i.e., the maximum bin count).
+});
+
+/**
+ * Computes the minimal number of bits required to represent the maximum number in the bins.
+ *
+ * Given an array of numbers that represent counts for each bin, this function calculates
+ * the number of bits required to represent the maximum bin count. A minimum of 1 bit is
+ * always returned.
+ *
+ * @param bins - An array of numbers, each representing a bin's value.
+ * @returns The minimal number of bits required to represent the highest value among the bins.
+ */
+function computeBits(bins: number[]): number {
+  return Math.ceil(Math.log2(1 + max(1, ...bins)));
+}
+
+/**
+ * Packs a given numeric value into a Uint8Array (bit array) at the specified bit offset and width.
+ *
+ * The function encodes the given number into the provided buffer, using the specified number of bits (width)
+ * starting from the specified bit offset. Each bit of the value is written into the buffer.
+ *
+ * @param buffer - The Uint8Array into which the value will be packed.
+ * @param bitOffset - The starting bit index in the array where the value should be packed.
+ * @param width - The number of bits to use for packing the value.
+ * @param value - The numeric value to pack.
+ */
+function packBits(
+  buffer: Uint8Array,
+  bitOffset: number,
+  width: number,
+  value: number,
+): void {
+  let offset = bitOffset;
+  for (let i = 0; i < width; i++) {
+    const byteIndex = offset >> 3;
+    const bitInByte = offset % 8;
+    const bit = (value >> i) & 1;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    buffer[byteIndex]! |= bit << bitInByte;
+    offset++;
+  }
+}
+
+/**
+ * Unpacks a numeric value from a Uint8Array (bit array) starting at a given bit offset with a specified width.
+ *
+ * The function reads bits from the buffer starting at the bit offset and reconstructs a numeric value
+ * using the specified number of bits (width).
+ *
+ * @param buffer - The Uint8Array from which the value will be unpacked.
+ * @param bitOffset - The starting bit index in the buffer.
+ * @param width - The number of bits to read for unpacking the value.
+ * @returns The numeric value resulting from decoding the specified bits.
+ */
+function unpackBits(
+  buffer: Uint8Array,
+  bitOffset: number,
+  width: number,
+): number {
+  let value = 0;
+  let offset = bitOffset;
+  for (let i = 0; i < width; i++) {
+    const byteIndex = offset >> 3;
+    const bitInByte = offset % 8;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const bit = (buffer[byteIndex]! >> bitInByte) & 1;
+    value |= bit << i;
+    offset++;
+  }
+  return value;
+}

package/src/constants.ts

@@ -0,0 +1,205 @@
+import { ccc } from "@ckb-ccc/core";
+import { IckbUdtManager, LogicManager, OwnedOwnerManager } from "@ickb/core";
+import { DaoManager } from "@ickb/dao";
+import { OrderManager } from "@ickb/order";
+import { CapacityManager, unique, type ScriptDeps } from "@ickb/utils";
+
+/**
+ * Retrieves the configuration for the given deployment environment.
+ *
+ * Accepts either a string identifier ("mainnet" or "testnet") or a custom configuration
+ * object containing script dependencies for a devnet.
+ *
+ * It sets up various managers (UDT, Logic, OwnedOwner, Order, Dao, Capacity) and also
+ * aggregates a unique list of known bot scripts.
+ *
+ * @param d - Either a network identifier ("mainnet"/"testnet") or an object containing
+ *   explicit script dependencies for devnet.
+ * @param bots - An optional array of bot script-like objects to augment the list of known bots.
+ * @returns An object containing the instantiated managers and bots.
+ */
+export function getConfig(
+  d:
+    | "mainnet"
+    | "testnet"
+    | {
+        // For devnet configuration provide explicit script dependencies.
+        udt: ScriptDeps;
+        logic: ScriptDeps;
+        ownedOwner: ScriptDeps;
+        order: ScriptDeps;
+        dao: ScriptDeps;
+      },
+  bots: ccc.ScriptLike[] = [],
+): {
+  managers: {
+    capacity: CapacityManager;
+    dao: DaoManager;
+    ickbUdt: IckbUdtManager;
+    logic: LogicManager;
+    ownedOwner: OwnedOwnerManager;
+    order: OrderManager;
+  };
+  bots: ccc.Script[];
+} {
+  // If deps is provided as a network string, use the pre-defined constants.
+  if (d === "mainnet" || d === "testnet") {
+    bots = bots.concat(
+      d === "mainnet" ? MAINNET_KNOWN_BOTS : TESTNET_KNOWN_BOTS,
+    );
+    const depGroup = d === "mainnet" ? MAINNET_DEP_GROUP : TESTNET_DEP_GROUP;
+    d = {
+      udt: from(UDT, depGroup),
+      logic: from(ICKB_LOGIC, depGroup),
+      ownedOwner: from(OWNED_OWNER, depGroup),
+      order: from(ORDER, depGroup),
+      dao: from(DAO, depGroup),
+    };
+  }
+
+  const capacity = CapacityManager.withAnyData();
+  const dao = new DaoManager(d.dao.script, d.dao.cellDeps);
+  const ickbUdt = new IckbUdtManager(
+    d.udt.script,
+    d.udt.cellDeps,
+    d.logic.script,
+    dao,
+  );
+  const logic = new LogicManager(
+    d.logic.script,
+    d.logic.cellDeps,
+    dao,
+    ickbUdt,
+  );
+  const ownedOwner = new OwnedOwnerManager(
+    d.ownedOwner.script,
+    d.ownedOwner.cellDeps,
+    dao,
+    ickbUdt,
+  );
+  const order = new OrderManager(d.order.script, d.order.cellDeps, ickbUdt);
+
+  return {
+    managers: {
+      capacity,
+      dao,
+      ickbUdt,
+      logic,
+      ownedOwner,
+      order,
+    },
+    bots: [...unique(bots.map((b) => ccc.Script.from(b)))],
+  };
+}
+
+/**
+ * Wraps a script-like object into a ScriptDeps structure.
+ *
+ * @param script - The script or script-like object.
+ * @param cellDeps - Additional cell dependencies that the script may require.
+ * @returns An object containing the script and its associated cell dependencies.
+ */
+function from(script: ccc.ScriptLike, ...cellDeps: ccc.CellDep[]): ScriptDeps {
+  return {
+    script: ccc.Script.from(script),
+    cellDeps,
+  };
+}
+
+/**
+ * DAO (Decentralized Autonomous Organization) lock script information.
+ */
+const DAO = {
+  codeHash:
+    "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
+  hashType: "type",
+  args: "0x",
+};
+
+/**
+ * UDT (User Defined Token) lock script information used for onchain validation.
+ */
+const UDT = {
+  codeHash:
+    "0x50bd8d6680b8b9cf98b73f3c08faf8b2a21914311954118ad6609be6e78a1b95",
+  hashType: "data1",
+  args: "0xb73b6ab39d79390c6de90a09c96b290c331baf1798ed6f97aed02590929734e800000080",
+};
+
+/**
+ * Logic script information for the iCKB logic contract.
+ */
+const ICKB_LOGIC = {
+  codeHash:
+    "0x2a8100ab5990fa055ab1b50891702e1e895c7bd1df6322cd725c1a6115873bd3",
+  hashType: "data1",
+  args: "0x",
+};
+
+/**
+ * OwnedOwner lock script information.
+ */
+const OWNED_OWNER = {
+  codeHash:
+    "0xacc79e07d107831feef4c70c9e683dac5644d5993b9cb106dca6e74baa381bd0",
+  hashType: "data1",
+  args: "0x",
+};
+
+/**
+ * Order lock script information.
+ */
+const ORDER = {
+  codeHash:
+    "0x49dfb6afee5cc8ac4225aeea8cb8928b150caf3cd92fea33750683c74b13254a",
+  hashType: "data1",
+  args: "0x",
+};
+
+/**
+ * Mainnet dependency group cell dep.
+ */
+const MAINNET_DEP_GROUP = ccc.CellDep.from({
+  outPoint: {
+    txHash:
+      "0x621a6f38de3b9f453016780edac3b26bfcbfa3e2ecb47c2da275471a5d3ed165",
+    index: "0x0",
+  },
+  depType: "depGroup",
+});
+
+/**
+ * Testnet dependency group cell dep.
+ */
+const TESTNET_DEP_GROUP = ccc.CellDep.from({
+  outPoint: {
+    txHash:
+      "0xf7ece4fb33d8378344cab11fcd6a4c6f382fd4207ac921cf5821f30712dcd311",
+    index: "0x0",
+  },
+  depType: "depGroup",
+});
+
+/**
+ * Array of known bot scripts on the mainnet.
+ */
+const MAINNET_KNOWN_BOTS = [
+  {
+    codeHash:
+      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
+    hashType: "type",
+    args: "0xd096cb29e2f68a85a46bd6bf6cbee6327959ba64",
+  },
+];
+
+/**
+ * Array of known bot scripts on the testnet.
+ */
+const TESTNET_KNOWN_BOTS = [
+  {
+    codeHash:
+      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
+    hashType: "type",
+    args: "0xb4380110f7679ac31cefe4925485645d82bf619f",
+  },
+];