@palliora.org/chainsdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1687 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/account/account.ts
+var _wasmcrypto = require('@polkadot/wasm-crypto'); var wasmCrypto = _interopRequireWildcard(_wasmcrypto);
+
+// src/account/types.ts
+var CryptoType = /* @__PURE__ */ ((CryptoType2) => {
+  CryptoType2["SR25519"] = "sr25519";
+  CryptoType2["ED25519"] = "ed25519";
+  CryptoType2["ECDSA"] = "ecdsa";
+  return CryptoType2;
+})(CryptoType || {});
+var AccountSourceType = /* @__PURE__ */ ((AccountSourceType2) => {
+  AccountSourceType2["PRIVATE_KEY"] = "privateKey";
+  AccountSourceType2["SEED"] = "seed";
+  AccountSourceType2["MNEMONIC"] = "mnemonic";
+  AccountSourceType2["DERIVED"] = "derived";
+  AccountSourceType2["ADDRESS"] = "address";
+  return AccountSourceType2;
+})(AccountSourceType || {});
+
+// src/account/account.ts
+var _api2 = require('@polkadot/api');
+var _util = require('@polkadot/util'); _createStarExport(_util);
+var _utilcrypto = require('@polkadot/util-crypto'); var utilCrypto = _interopRequireWildcard(_utilcrypto);
+async function createAccount(input, type, name = "default", cryptoType = "sr25519" /* SR25519 */) {
+  await _wasmcrypto.waitReady.call(void 0, );
+  const keyring2 = new (0, _api2.Keyring)({ type: cryptoType });
+  switch (type) {
+    case "privateKey" /* PRIVATE_KEY */: {
+      const pair = pairFromPrivateKeyHex(input, cryptoType);
+      return keyring2.addFromPair(pair, { name }, cryptoType);
+    }
+    case "seed" /* SEED */: {
+      const seed = _util.hexToU8a.call(void 0, input);
+      if (seed.length !== 32) {
+        throw new Error(
+          `Invalid ${cryptoType} seed length. Expected 32 bytes, got ${seed.length}`
+        );
+      }
+      return keyring2.addFromSeed(seed, { name }, cryptoType);
+    }
+    case "mnemonic" /* MNEMONIC */:
+      return keyring2.createFromUri(input, { name }, cryptoType);
+    case "address" /* ADDRESS */:
+      const account = keyring2.addFromAddress(
+        input,
+        { name },
+        null,
+        cryptoType
+      );
+      return account;
+    default:
+      throw new Error("Invalid input type");
+  }
+}
+function pairFromPrivateKeyHex(privateKeyHex, cryptoType) {
+  const privateKey = _util.hexToU8a.call(void 0, privateKeyHex);
+  switch (cryptoType) {
+    case "ed25519" /* ED25519 */:
+      if (privateKey.length !== 64) {
+        throw new Error(
+          `Invalid ed25519 private key length. Expected 64 bytes, got ${privateKey.length}`
+        );
+      }
+      return _utilcrypto.ed25519PairFromSecret.call(void 0, privateKey);
+    case "ecdsa" /* ECDSA */:
+      if (privateKey.length !== 32) {
+        throw new Error(
+          `Invalid ecdsa private key length. Expected 32 bytes, got ${privateKey.length}`
+        );
+      }
+      return _utilcrypto.secp256k1PairFromSeed.call(void 0, privateKey);
+    case "sr25519" /* SR25519 */:
+      if (privateKey.length !== 96) {
+        throw new Error(
+          `Invalid sr25519 private key length. Expected 96 bytes (secret+public), got ${privateKey.length}`
+        );
+      }
+      return {
+        secretKey: privateKey.slice(0, 64),
+        publicKey: privateKey.slice(64, 96)
+      };
+    default:
+      throw new Error(`Unsupported crypto type: ${cryptoType}`);
+  }
+}
+
+// src/chain/spec.ts
+var API_RPC = {
+  kate: {
+    queryRows: {
+      description: "",
+      params: [
+        {
+          name: "rows",
+          type: "Vec<u32>"
+        },
+        {
+          name: "at",
+          type: "Hash",
+          isOptional: true
+        }
+      ],
+      type: "Vec<GRow>"
+    },
+    queryProof: {
+      description: "Generate the kate proof for the given `cells`",
+      params: [
+        {
+          name: "cells",
+          type: "Vec<Cell>"
+        },
+        {
+          name: "at",
+          type: "Hash",
+          isOptional: true
+        }
+      ],
+      type: "Vec<GDataProof>"
+    },
+    blockLength: {
+      description: "Get Block Length",
+      params: [
+        {
+          name: "at",
+          type: "Hash",
+          isOptional: true
+        }
+      ],
+      type: "BlockLength"
+    },
+    queryDataProof: {
+      description: "Generate the data proof for the given `transaction_index`",
+      params: [
+        {
+          name: "transaction_index",
+          type: "u32"
+        },
+        {
+          name: "at",
+          type: "Hash",
+          isOptional: true
+        }
+      ],
+      type: "ProofResponse"
+    }
+  },
+  guardian: {
+    runtimeInfo: {
+      description: "Fetch guardian runtime info",
+      params: [
+        {
+          name: "at",
+          type: "Hash",
+          isOptional: true
+        }
+      ],
+      type: "GuardianInfo"
+    },
+    guardianList: {
+      description: "Fetch guardian list",
+      params: [],
+      type: "Vec<String>"
+    },
+    guardianNwParams: {
+      description: "Fetch guardian network parameters",
+      params: [],
+      type: "GuardianNwParams"
+    }
+  }
+};
+var API_TYPES = {
+  GuardianInfo: {
+    active: "u32",
+    maximum: "u32"
+  },
+  GuardianNwParams: {
+    kzg: "Vec<u8>",
+    agg_key: "Vec<u8>"
+  },
+  AppId: "Compact<u32>",
+  DataLookupItem: {
+    appId: "AppId",
+    start: "Compact<u32>"
+  },
+  CompactDataLookup: {
+    size: "Compact<u32>",
+    index: "Vec<DataLookupItem>"
+  },
+  KateCommitment: {
+    rows: "Compact<u16>",
+    cols: "Compact<u16>",
+    commitment: "Vec<u8>",
+    dataRoot: "H256"
+  },
+  V3HeaderExtension: {
+    appLookup: "CompactDataLookup",
+    commitment: "KateCommitment"
+  },
+  HeaderExtension: {
+    _enum: {
+      V1: null,
+      V2: null,
+      V3: "V3HeaderExtension"
+    }
+  },
+  DaHeader: {
+    parentHash: "Hash",
+    number: "Compact<BlockNumber>",
+    stateRoot: "Hash",
+    extrinsicsRoot: "Hash",
+    digest: "Digest",
+    extension: "HeaderExtension"
+  },
+  Header: "DaHeader",
+  CheckAppIdExtra: {
+    appId: "AppId"
+  },
+  CheckAppIdTypes: {},
+  CheckAppId: {
+    extra: "CheckAppIdExtra",
+    types: "CheckAppIdTypes"
+  },
+  ComputePayload: {
+    da_type: "u8",
+    agreement: "Option<BoundedVec<[u8; 32], 10>>",
+    verification: "u8",
+    compute: "u8"
+  },
+  BlockLengthColumns: "Compact<u32>",
+  BlockLengthRows: "Compact<u32>",
+  BlockLength: {
+    max: "PerDispatchClass",
+    cols: "BlockLengthColumns",
+    rows: "BlockLengthRows",
+    chunkSize: "Compact<u32>"
+  },
+  PerDispatchClass: {
+    normal: "u32",
+    operational: "u32",
+    mandatory: "u32"
+  },
+  TxDataRoots: {
+    dataRoot: "H256",
+    blobRoot: "H256",
+    bridgeRoot: "H256"
+  },
+  DataProof: {
+    roots: "TxDataRoots",
+    proof: "Vec<H256>",
+    numberOfLeaves: "Compact<u32>",
+    leafIndex: "Compact<u32>",
+    leaf: "H256"
+  },
+  ProofResponse: {
+    dataProof: "DataProof",
+    message: "Option<AddressedMessage>"
+  },
+  AddressedMessage: {
+    message: "Message",
+    from: "H256",
+    to: "H256",
+    originDomain: "u32",
+    destinationDomain: "u32",
+    id: "u64"
+  },
+  Message: {
+    _enum: {
+      ArbitraryMessage: "ArbitraryMessage",
+      FungibleToken: "FungibleToken"
+    }
+  },
+  FungibleToken: {
+    assetId: "H256",
+    amount: "u128"
+  },
+  BoundedData: "Vec<u8>",
+  ArbitraryMessage: "BoundedData",
+  Cell: {
+    row: "u32",
+    col: "u32"
+  },
+  GRawScalar: "U256",
+  GProof: "[u8; 48]",
+  GRow: "Vec<GRawScalar>",
+  GDataProof: "(GRawScalar, GProof)"
+};
+var DEFAULT_COMPUTE_PAYLOAD = { compute: { da_type: 0, verification: 0, compute: 0 } };
+var DEFAULT_EMPTY_PAYLOAD = { compute: { da_type: 0, verification: 0, compute: 0, agreement: [] } };
+var API_EXTENSIONS = {
+  CheckAppId: {
+    extrinsic: {
+      appId: "AppId"
+    },
+    payload: {}
+  },
+  CheckCompute: {
+    extrinsic: {
+      compute: "ComputePayload"
+    },
+    payload: {}
+  }
+};
+
+// src/crypto/core.ts
+var _bls12381 = require('@noble/curves/bls12-381');
+var encrypt = (params, apk, t) => {
+  const gamma = _bls12381.bls12_381.fields.Fr.create(
+    BigInt(
+      "0x" + reverseEndianess(
+        "8660d3c2a2ab458dd6da04d3e7cb5cf6edb702dfa2fa0c952cd6f3bcdc0fdb1a"
+      )
+    )
+  );
+  const gamma_g2 = params.powers_of_h[0].multiply(gamma);
+  let g = params.powers_of_g[0];
+  let h = params.powers_of_h[0];
+  let sa1 = [_bls12381.bls12_381.G1.ProjectivePoint.BASE, _bls12381.bls12_381.G1.ProjectivePoint.BASE];
+  let sa2 = Array(6).fill(_bls12381.bls12_381.G2.ProjectivePoint.BASE);
+  const hexValues = [
+    reverseEndianess(
+      "08ca6f2a35f8f6f9cad58e9d764d450af154c246fc04266151e2a5493ff02943"
+    ),
+    reverseEndianess(
+      "8696a66087578b92e1b4b11c6b4c06d4694a9bed1f9468f0115e7f2648eb021d"
+    ),
+    reverseEndianess(
+      "91e201cc83dc03cc47d63cfb8a9016e73ffd1a78fffd14e4dfcdf2cbb9a7245d"
+    ),
+    reverseEndianess(
+      "a90598c6e0f25c3a104fc94632b1d58cf21bca3bbd7e41da07feb9c14e0fa60d"
+    ),
+    reverseEndianess(
+      "d3f5a9fc8abfef02fb6095c08ba4f3445b36f0fb963579bc5112d34a02044567"
+    )
+  ];
+  const s = Array.from({ length: 5 }, () => _bls12381.bls12_381.G1.normPrivateKeyToScalar(_bls12381.bls12_381.utils.randomPrivateKey()));
+  sa1[0] = apk.ask.multiply(s[0]).add(params.powers_of_g[t].multiply(s[3])).add(params.powers_of_g[0].multiply(s[4]));
+  sa1[1] = g.multiply(s[2]);
+  sa2[0] = h.multiply(s[0]).add(gamma_g2.multiply(s[2]));
+  sa2[1] = apk.z_g2.multiply(s[0]);
+  sa2[2] = params.powers_of_h[1].multiply(s[0]).add(params.powers_of_h[1].multiply(s[1]));
+  sa2[3] = h.multiply(s[1]);
+  sa2[4] = h.multiply(s[3]);
+  sa2[5] = params.powers_of_h[1].add(apk.h_minus1).multiply(s[4]);
+  const enc_key = _bls12381.bls12_381.fields.Fp12.pow(apk.e_gh, s[4]);
+  return { gamma_g2, sa1, sa2, enc_key, t };
+};
+var decodePowersOfTau = (input) => {
+  try {
+    if (!input || input.length % 2 !== 0) {
+      throw new Error("Invalid input hex string");
+    }
+    const hexArray = input.match(/.{1,2}/g) || [];
+    const buffer = new Uint8Array(hexArray.map((byte) => parseInt(byte, 16)));
+    const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    const view = new DataView(arrayBuffer);
+    const powers_of_g = [];
+    const powers_of_h = [];
+    const G1_POINT_SIZE = 48;
+    const G2_POINT_SIZE = 96;
+    let offset = 0;
+    if (offset + 8 > buffer.length) {
+      throw new Error("Buffer too small to read count");
+    }
+    const count = view.getBigUint64(offset, true);
+    offset += 8;
+    for (let i = 0; i < count; i++) {
+      if (offset + G1_POINT_SIZE > buffer.length) {
+        throw new Error("Buffer too small to read G1 point");
+      }
+      const pointBuffer = buffer.slice(offset, offset + G1_POINT_SIZE);
+      const point = _bls12381.bls12_381.G1.ProjectivePoint.fromHex(pointBuffer);
+      powers_of_g.push(point);
+      offset += G1_POINT_SIZE;
+    }
+    if (offset + 8 > buffer.length) {
+      throw new Error("Buffer too small to read second count");
+    }
+    offset += 8;
+    for (let i = 0; i < count; i++) {
+      if (offset + G2_POINT_SIZE > buffer.length) {
+        throw new Error("Buffer too small to read G2 point");
+      }
+      const pointBuffer = buffer.slice(offset, offset + G2_POINT_SIZE);
+      const point = _bls12381.bls12_381.G2.ProjectivePoint.fromHex(pointBuffer);
+      powers_of_h.push(point);
+      offset += G2_POINT_SIZE;
+    }
+    return { powers_of_g, powers_of_h };
+  } catch (error) {
+    console.error("Error in decodePowersOfTau:", error);
+    console.log("Input length:", input.length);
+    console.log("Input preview:", input.slice(0, 100));
+    throw error;
+  }
+};
+var isValidHex = (hex) => {
+  return /^[0-9A-Fa-f]*$/.test(hex) && hex.length % 2 === 0;
+};
+var decodeAggregateKey = (input) => {
+  const buffer = new Uint8Array(_optionalChain([input, 'access', _ => _.match, 'call', _2 => _2(/.{1,2}/g), 'optionalAccess', _3 => _3.map, 'call', _4 => _4((byte) => parseInt(byte, 16))]) || []);
+  let offset = 0;
+  const view = new DataView(buffer.buffer);
+  const readBigUInt64LE = () => {
+    const value = view.getBigUint64(offset, true);
+    offset += 8;
+    return value;
+  };
+  const readProjPointTypeFp = (count) => {
+    const points = [];
+    for (let i = 0; i < count; i++) {
+      const pointBuffer = buffer.slice(offset, offset + 48);
+      const point = _bls12381.bls12_381.G1.ProjectivePoint.fromHex(pointBuffer);
+      points.push(point);
+      offset += 48;
+    }
+    return points;
+  };
+  const readProjPointTypeFp2 = (count) => {
+    const points = [];
+    for (let i = 0; i < count; i++) {
+      const pointBuffer = buffer.slice(offset, offset + 96);
+      const point = _bls12381.bls12_381.G2.ProjectivePoint.fromHex(pointBuffer);
+      points.push(point);
+      offset += 96;
+    }
+    return points;
+  };
+  const readProjPointTypeFp12 = () => {
+    const points = [];
+    for (let i = 0; i < 12; i++) {
+      const pointBuffer = buffer.slice(offset, offset + 48);
+      const hexValue = Array.from(pointBuffer).reverse().map((b) => b.toString(16).padStart(2, "0")).join("");
+      const point = BigInt("0x" + hexValue);
+      points.push(point);
+      offset += 48;
+    }
+    if (points.length !== 12) {
+      throw new Error("Invalid number of points for Fp12");
+    }
+    return _bls12381.bls12_381.fields.Fp12.create({
+      c0: _bls12381.bls12_381.fields.Fp6.create({
+        c0: _bls12381.bls12_381.fields.Fp2.create({ c0: points[0], c1: points[1] }),
+        c1: _bls12381.bls12_381.fields.Fp2.create({ c0: points[2], c1: points[3] }),
+        c2: _bls12381.bls12_381.fields.Fp2.create({ c0: points[4], c1: points[5] })
+      }),
+      c1: _bls12381.bls12_381.fields.Fp6.create({
+        c0: _bls12381.bls12_381.fields.Fp2.create({ c0: points[6], c1: points[7] }),
+        c1: _bls12381.bls12_381.fields.Fp2.create({ c0: points[8], c1: points[9] }),
+        c2: _bls12381.bls12_381.fields.Fp2.create({ c0: points[10], c1: points[11] })
+      })
+    });
+  };
+  const pkCount = readBigUInt64LE();
+  const pk = [];
+  for (let i = 0; i < pkCount; i++) {
+    const id = Number(readBigUInt64LE());
+    const bls_pk = readProjPointTypeFp(BigInt(1))[0];
+    const sk_li = readProjPointTypeFp(BigInt(1))[0];
+    const sk_li_minus0 = readProjPointTypeFp(BigInt(1))[0];
+    const sk_li_lj_z = readProjPointTypeFp(readBigUInt64LE());
+    const sk_li_x = readProjPointTypeFp(BigInt(1))[0];
+    pk.push({ id, bls_pk, sk_li, sk_li_minus0, sk_li_x, sk_li_lj_z });
+  }
+  const agg_sk_li_lj_z = readProjPointTypeFp(readBigUInt64LE());
+  const ask = readProjPointTypeFp(BigInt(1))[0];
+  const z_g2 = readProjPointTypeFp2(BigInt(1))[0];
+  const h_minus1 = readProjPointTypeFp2(BigInt(1))[0];
+  const e_gh = readProjPointTypeFp12();
+  return { pk, agg_sk_li_lj_z, ask, z_g2, h_minus1, e_gh };
+};
+var encodeCiphertext = (input) => {
+  const writeProjPointTypeFp = (point) => {
+    const hex = point.toHex(true);
+    return new Uint8Array(_optionalChain([hex, 'access', _5 => _5.match, 'call', _6 => _6(/.{1,2}/g), 'optionalAccess', _7 => _7.map, 'call', _8 => _8((byte) => parseInt(byte, 16))]) || []);
+  };
+  const writeProjPointTypeFp2 = (point) => {
+    const hex = point.toHex(true);
+    return new Uint8Array(_optionalChain([hex, 'access', _9 => _9.match, 'call', _10 => _10(/.{1,2}/g), 'optionalAccess', _11 => _11.map, 'call', _12 => _12((byte) => parseInt(byte, 16))]) || []);
+  };
+  const gamma_g2Buffer = writeProjPointTypeFp2(input.gamma_g2);
+  const sa1Buffer = new Uint8Array(input.sa1.flatMap((p) => Array.from(writeProjPointTypeFp(p))));
+  const sa2Buffer = new Uint8Array(input.sa2.flatMap((p) => Array.from(writeProjPointTypeFp2(p))));
+  const enc_keyBuffer = new Uint8Array(_optionalChain([fp12ToHex, 'call', _13 => _13(input.enc_key), 'access', _14 => _14.match, 'call', _15 => _15(/.{1,2}/g), 'optionalAccess', _16 => _16.map, 'call', _17 => _17((byte) => parseInt(byte, 16))]) || []);
+  const tBuffer = new Uint8Array(8);
+  new DataView(tBuffer.buffer).setBigUint64(0, BigInt(input.t), true);
+  const totalLength = gamma_g2Buffer.length + sa1Buffer.length + sa2Buffer.length + enc_keyBuffer.length + tBuffer.length;
+  const resultBuffer = new Uint8Array(totalLength);
+  let offset = 0;
+  resultBuffer.set(gamma_g2Buffer, offset);
+  offset += gamma_g2Buffer.length;
+  resultBuffer.set(sa1Buffer, offset);
+  offset += sa1Buffer.length;
+  resultBuffer.set(sa2Buffer, offset);
+  offset += sa2Buffer.length;
+  resultBuffer.set(enc_keyBuffer, offset);
+  offset += enc_keyBuffer.length;
+  resultBuffer.set(tBuffer, offset);
+  return Array.from(resultBuffer).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+function fp12ToHex(fp12) {
+  const c0 = fp12.c0;
+  const c1 = fp12.c1;
+  return [
+    bigintToBigEndianHex(c0.c0.c0, 48),
+    bigintToBigEndianHex(c0.c0.c1, 48),
+    bigintToBigEndianHex(c0.c1.c0, 48),
+    bigintToBigEndianHex(c0.c1.c1, 48),
+    bigintToBigEndianHex(c0.c2.c0, 48),
+    bigintToBigEndianHex(c0.c2.c1, 48),
+    bigintToBigEndianHex(c1.c0.c0, 48),
+    bigintToBigEndianHex(c1.c0.c1, 48),
+    bigintToBigEndianHex(c1.c1.c0, 48),
+    bigintToBigEndianHex(c1.c1.c1, 48),
+    bigintToBigEndianHex(c1.c2.c0, 48),
+    bigintToBigEndianHex(c1.c2.c1, 48)
+  ].join("");
+}
+var testCrypt = (kzg, agg_key) => {
+  try {
+    if (!isValidHex(kzg) || !isValidHex(agg_key)) {
+      throw new Error("Invalid input hex strings");
+    }
+    const powersOfTau = decodePowersOfTau(kzg);
+    const aggregateKey = decodeAggregateKey(agg_key);
+    const ciph = encrypt(powersOfTau, aggregateKey, 2);
+    const encoded = encodeCiphertext(ciph);
+    const ikm = fp12ToHex(ciph.enc_key);
+    return { encoded, ikm, ciph };
+  } catch (error) {
+    console.error("Error in testCrypt:", error);
+    throw error;
+  }
+};
+function bigintToBigEndianHex(value, length) {
+  let hex = value.toString(16);
+  if (hex.length > length * 2) {
+    throw new Error("BigInt value is too large to fit in the specified length");
+  }
+  hex = hex.padStart(length * 2, "0");
+  const byteArray = _optionalChain([hex, 'access', _18 => _18.match, 'call', _19 => _19(/.{1,2}/g), 'optionalAccess', _20 => _20.map, 'call', _21 => _21((byte) => parseInt(byte, 16))]) || [];
+  const reversedByteArray = byteArray.reverse();
+  const bigEndianHex = reversedByteArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return bigEndianHex;
+}
+function reverseEndianess(hex) {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Hex string must have an even length");
+  }
+  return _optionalChain([hex, 'access', _22 => _22.match, 'call', _23 => _23(/.{1,2}/g), 'optionalAccess', _24 => _24.reverse, 'call', _25 => _25(), 'access', _26 => _26.join, 'call', _27 => _27("")]) || "";
+}
+
+// src/crypto/cipher.ts
+var _ed25519 = require('@noble/curves/ed25519');
+var _hkdf = require('@noble/hashes/hkdf');
+var _sha256 = require('@noble/hashes/sha256');
+var _chacha20poly1305 = require('@stablelib/chacha20poly1305');
+var gen_stretched_key = (input) => {
+  const salt = new Uint8Array(32);
+  const info = new TextEncoder().encode("aes_encryption");
+  return _hkdf.hkdf.call(void 0, _sha256.sha256, input, salt, info, 32);
+};
+var gen_shared_key = (key, pk) => {
+  const mg_key = _ed25519.edwardsToMontgomeryPriv.call(void 0, key);
+  const mg_pk = _ed25519.edwardsToMontgomeryPub.call(void 0, pk);
+  return _ed25519.x25519.getSharedSecret(mg_key, mg_pk);
+};
+var encrypt2 = (plaintext, key) => {
+  const cipher = new (0, _chacha20poly1305.ChaCha20Poly1305)(key);
+  const nonce = new Uint8Array(cipher.nonceLength);
+  globalThis.crypto.getRandomValues(nonce);
+  const ciphertext = cipher.seal(nonce, plaintext);
+  return { ciphertext, nonce };
+};
+var decrypt = (ciphertext, key, nonce) => {
+  const cipher = new (0, _chacha20poly1305.ChaCha20Poly1305)(key);
+  const res = cipher.open(nonce, ciphertext);
+  return res;
+};
+
+// src/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(_nullishCoalesce(message, () => ( "Assertion failed")));
+  }
+}
+
+// src/config.ts
+var env = typeof process !== "undefined" && process.env ? process.env : {};
+var PALLIORA_WS = env.PALLIORA_WS || "wss://manas-rpc.palliora.org";
+var PALLIORA_RPC_URL = env.PALLIORA_RPC_URL || "wss://manas-rpc.palliora.org";
+var DEBUG = env.DEBUG === "true" || false;
+var TX_WAIT_FINALIZATION = env.TX_WAIT_FINALIZATION === "true" || false;
+function configure(opts) {
+  if (opts.pallioraWs !== void 0) PALLIORA_WS = exports.PALLIORA_WS = opts.pallioraWs;
+  if (opts.pallioraRpcUrl !== void 0) PALLIORA_RPC_URL = exports.PALLIORA_RPC_URL = opts.pallioraRpcUrl;
+  if (opts.debug !== void 0) DEBUG = exports.DEBUG = opts.debug;
+  if (opts.txWaitFinalization !== void 0) TX_WAIT_FINALIZATION = exports.TX_WAIT_FINALIZATION = opts.txWaitFinalization;
+}
+
+// src/utils/helper.ts
+var tokenToBigint = (arg) => {
+  const val = typeof arg === "bigint" ? arg : BigInt(arg);
+  return val * 10n ** 15n;
+};
+function hexToUint8Array(hex) {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Invalid hex string");
+  }
+  const arr = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return arr;
+}
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    binary += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binary);
+}
+var base64ToUint8Array = (base64) => {
+  base64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4) {
+    base64 += "=";
+  }
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+};
+var decodeField = (field, expectedLength) => {
+  const bytes = base64ToUint8Array(field);
+  if (expectedLength && bytes.length !== expectedLength) {
+    if (bytes.length === expectedLength * 2) {
+      const intermediateStr = new TextDecoder().decode(bytes);
+      const secondBytes = base64ToUint8Array(intermediateStr);
+      if (secondBytes.length === expectedLength) {
+        return secondBytes;
+      }
+    }
+  }
+  return bytes;
+};
+var debugLog = (message, ...optionalParams) => {
+  if (DEBUG) {
+    console.log(message, ...optionalParams);
+  }
+};
+
+// src/utils/token.ts
+
+var tokenCache = null;
+async function fetchTokenProperties() {
+  if (tokenCache) {
+    return tokenCache;
+  }
+  try {
+    const systemProperties = await _asyncOptionalChain([(await await _asyncOptionalChain([(await getApi()), 'optionalAccess', async _28 => _28.rpc, 'access', async _29 => _29.system, 'access', async _30 => _30.properties, 'call', async _31 => _31()])), 'optionalAccess', async _32 => _32.toHuman, 'call', async _33 => _33()]);
+    assert(systemProperties, "Failed to fetch system properties from RPC");
+    const tokenProperties = {
+      symbol: (_optionalChain([systemProperties, 'optionalAccess', _34 => _34.tokenSymbol]) || ["UNIT"])[0],
+      decimals: Number((_optionalChain([systemProperties, 'optionalAccess', _35 => _35.tokenDecimals]) || ["18"])[0])
+    };
+    tokenCache = tokenProperties;
+    return tokenProperties;
+  } catch (error) {
+    console.error("Failed to fetch token properties:", error);
+    throw error;
+  }
+}
+function getCachedTokenProperties() {
+  return tokenCache;
+}
+function clearTokenCache() {
+  tokenCache = null;
+}
+async function formatBalanceWithTokenProperties(balance) {
+  const tokenProperties = await fetchTokenProperties();
+  if (!tokenProperties) {
+    throw new Error(
+      "Token properties not yet cached. Call fetchTokenProperties first."
+    );
+  }
+  return _util.formatBalance.call(void 0, balance, {
+    decimals: tokenProperties.decimals,
+    withSi: true,
+    withUnit: tokenProperties.symbol
+  });
+}
+
+// src/chain/singleton.ts
+
+
+// src/chain/wsProvider.ts
+
+var provider = new (0, _api2.WsProvider)(PALLIORA_WS, 1e4);
+
+// src/chain/singleton.ts
+
+var wsProvider = null;
+var api = null;
+var keyring = null;
+var encKeyring = null;
+var RpcApi = class {
+  constructor() {
+    this.isConnected = false;
+    this.isConnecting = false;
+    this.error = null;
+  }
+  /**
+   * Establishes a connection to a node at `endpoint` and returns the singleton
+   * API and Keyring instances.
+   *
+   * @param endpoint - WebSocket endpoint URL to connect to (e.g. "wss://...").
+   * @returns A promise resolving to an object containing the singleton {@link ApiPromise}
+   *          instance and the singleton {@link Keyring} instance.
+   *
+   * @remarks
+   * - If a connection already exists (`isConnected === true`) the method returns
+   *   the already-initialized instances without recreating them.
+   * - The method sets `isConnecting` to true while establishing the connection and
+   *   clears it in a `finally` block.
+   * - Provider and API event listeners update the instance `error` and `isConnected`
+   *   fields on runtime errors and disconnects.
+   * - The Keyring created here uses `sr25519` keys. If the standalone `getKeyring`
+   *   helper is used elsewhere, it will additionally add a default development
+   *   account derived from the well-known dev URI `//Bob` (named "Bob default").
+   *
+   * @throws Will re-throw underlying errors encountered while creating the provider
+   *         or API. In that case `error` will contain the textual error message.
+   */
+  async connect(endpoint) {
+    try {
+      if (this.isConnected) {
+        return { api, keyring };
+      }
+      this.isConnecting = true;
+      this.error = null;
+      if (!wsProvider) {
+        wsProvider = new (0, _api2.WsProvider)(endpoint);
+        wsProvider.on("error", (err) => {
+          console.error("WsProvider error:", err);
+          this.error = "WebSocket connection error";
+          this.isConnected = false;
+        });
+        wsProvider.on("disconnected", () => {
+          console.log("WsProvider disconnected");
+          this.isConnected = false;
+        });
+      }
+      if (!api) {
+        api = await _api2.ApiPromise.create({
+          provider: wsProvider,
+          rpc: API_RPC,
+          types: API_TYPES,
+          signedExtensions: API_EXTENSIONS
+        });
+        api.on("error", (err) => {
+          console.error("API error:", err);
+          this.error = "API error occurred";
+        });
+        api.on("disconnected", () => {
+          this.isConnected = false;
+        });
+      }
+      if (!keyring) {
+        keyring = new (0, _api2.Keyring)({ type: "sr25519" });
+      }
+      if (!encKeyring) {
+        encKeyring = new (0, _api2.Keyring)({ type: "ed25519" });
+      }
+      await api.isReady;
+      this.isConnected = true;
+      return { api, keyring };
+    } catch (err) {
+      console.error("Failed to connect to Polkadot:", err);
+      this.error = err instanceof Error ? err.message : "Failed to connect to Polkadot";
+      throw err;
+    } finally {
+      this.isConnecting = false;
+    }
+  }
+  /**
+   * Gracefully disconnects and nullifies the singleton API, provider and keyring
+   * instances managed by this RpcApi instance.
+   *
+   * @remarks
+   * - The method calls `api.disconnect()` and `wsProvider.disconnect()` if they
+   *   exist, then sets the internal singletons to `null` and `isConnected` to false.
+   * - Any error during disconnect is captured in `error`.
+   */
+  async disconnect() {
+    try {
+      if (api) {
+        await api.disconnect();
+        api = null;
+      }
+      if (wsProvider) {
+        await wsProvider.disconnect();
+        wsProvider = null;
+      }
+      keyring = null;
+      this.isConnected = false;
+    } catch (err) {
+      console.error("Error disconnecting:", err);
+      this.error = err instanceof Error ? err.message : "Failed to disconnect";
+    }
+  }
+  getApi() {
+    return api;
+  }
+  getKeyring() {
+    return keyring;
+  }
+  getEncKeyring() {
+    return encKeyring;
+  }
+};
+async function getApi() {
+  if (!provider) return;
+  console.debug(provider.endpoint);
+  if (!api) {
+    api = await _api2.ApiPromise.create({
+      provider,
+      rpc: API_RPC,
+      types: API_TYPES,
+      signedExtensions: API_EXTENSIONS
+    });
+  }
+  const isNode = typeof process !== "undefined" && typeof process.exit === "function";
+  const isTest = typeof process !== "undefined" && _optionalChain([process, 'access', _36 => _36.env, 'optionalAccess', _37 => _37.NODE_ENV]) === "test";
+  if (isNode && !isTest) {
+    api.on("error", (err) => {
+      console.error("api error, will restart:", err);
+      process.exit(0);
+    });
+    api.on("disconnected", () => {
+      console.error("api disconnected, will restart.");
+      process.exit(0);
+    });
+  }
+  return api;
+}
+async function getKeyring() {
+  if (!keyring) {
+    await _wasmcrypto.waitReady.call(void 0, );
+    keyring = new (0, _api2.Keyring)({ type: "sr25519" });
+    keyring.addFromUri("//Bob", { name: "Bob default" });
+  }
+  return keyring;
+}
+async function getEncKeyring() {
+  if (!encKeyring) {
+    await _wasmcrypto.waitReady.call(void 0, );
+    encKeyring = new (0, _api2.Keyring)({ type: "ed25519" });
+    encKeyring.addFromUri("//Bob", { name: "Bob default (enc)" });
+  }
+  return encKeyring;
+}
+var apiInstance = null;
+function getRpcApi() {
+  if (!apiInstance) {
+    apiInstance = new RpcApi();
+  }
+  return apiInstance;
+}
+
+// src/chain/utils.ts
+
+var _bs58 = require('bs58'); var _bs582 = _interopRequireDefault(_bs58);
+
+// src/guardian/active.ts
+
+var getGuardianList = async () => {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  const rpc = api2.rpc;
+  const section = "guardian";
+  const method = "guardianList";
+  assert(
+    _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _38 => _38[section], 'optionalAccess', _39 => _39[method]])),
+    `api.rpc.${section}.${method} does not exist`
+  );
+  const list = (await rpc[section]["guardianList"]()).map((item) => [item.toString()]).flat(1);
+  return list;
+};
+
+// src/guardian/group.ts
+var createGuardianGroup = async (account, selectedGuardians) => {
+  try {
+    const api2 = await getApi();
+    assert(selectedGuardians.length >= 3, "Not enough guardians available to create a group");
+    assert(account, "Failed to load account");
+    assert(api2, "Failed to initialize API");
+    const tau_params = await getGuardianNwParams();
+    assert(tau_params && tau_params !== "", "Failed to retrieve guardian network parameters");
+    debugLog(`Selected guardians: ${selectedGuardians.join(", ")} and tau_params: ${tau_params}`);
+    const tx = api2.tx.dataAvailability.daccGuardianGroup(
+      selectedGuardians,
+      Array.from(hexToUint8Array(tau_params))
+      // Use the new helper function
+    );
+    const result = await signAndSend(tx, account);
+    debugLog("Guardian group created:", result);
+  } catch (error) {
+    console.error("Error creating guardian group:", error);
+    throw new Error(`Failed to create guardian group: ${error instanceof Error ? error.message : error}`);
+  }
+};
+
+// src/guardian/join.ts
+async function joinGuardian(account, prefs) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  const computeOpts = _optionalChain([prefs, 'access', _40 => _40.compute, 'optionalAccess', _41 => _41.split, 'call', _42 => _42(","), 'access', _43 => _43.map, 'call', _44 => _44((s) => s.trim()), 'access', _45 => _45.filter, 'call', _46 => _46((s) => s.length > 0)]) || void 0;
+  const guardianPrefs = {
+    pubKey: account.publicKey,
+    guardian: prefs.standard,
+    verifier: prefs.verifier,
+    compute: prefs.compute ? true : false,
+    computePrefs: {
+      trusted: _optionalChain([computeOpts, 'optionalAccess', _47 => _47.includes, 'call', _48 => _48("trusted")]) || false,
+      tee: _optionalChain([computeOpts, 'optionalAccess', _49 => _49.includes, 'call', _50 => _50("tee")]) || false,
+      mpc: _optionalChain([computeOpts, 'optionalAccess', _51 => _51.includes, 'call', _52 => _52("mpc")]) || false,
+      fhe: _optionalChain([computeOpts, 'optionalAccess', _53 => _53.includes, 'call', _54 => _54("fhe")]) || false,
+      zkp: _optionalChain([computeOpts, 'optionalAccess', _55 => _55.includes, 'call', _56 => _56("zkp")]) || false
+    }
+  };
+  debugLog(
+    account.address,
+    "joining as guardian with preferences:",
+    guardianPrefs
+  );
+  const guardTx = api2.tx.staking.guard(guardianPrefs);
+  const hash = await signAndSend(guardTx, account);
+  debugLog("Guardian join tx sent with hash:", hash.hash);
+}
+
+// src/chain/utils.ts
+var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
+  const tx_result = await new Promise((res, err) => {
+    request.signAndSend(account, opts, (result) => {
+      if (result.isFinalized) {
+        res(result);
+      }
+      if (!TX_WAIT_FINALIZATION && result.isInBlock) {
+        res(result);
+      }
+      if (result.isError) err(result);
+    });
+  });
+  if (tx_result.isError) {
+    throw new Error(`Transaction failed with error: ${tx_result.error}`);
+  }
+  if (tx_result.dispatchError) {
+    throw new Error(
+      `Transaction dispatched with error: ${tx_result.dispatchError}`
+    );
+  }
+  console.debug(
+    `Transaction ${tx_result.txHash.toHex()} included in timepoint ${tx_result.blockNumber}-${tx_result.txIndex}`
+  );
+  return {
+    blockNumber: _optionalChain([tx_result, 'optionalAccess', _57 => _57.blockNumber, 'optionalAccess', _58 => _58.toNumber, 'call', _59 => _59()]),
+    index: _optionalChain([tx_result, 'optionalAccess', _60 => _60.txIndex]),
+    hash: tx_result.txHash.toHex(),
+    tx_result
+  };
+};
+var getFileMetadataCall = async (api2, metadataRef) => {
+  const block = await getBlock(api2, metadataRef[0]);
+  const call = block.block.extrinsics[metadataRef[1]];
+  return call.method;
+};
+var getBlock = async (api2, blockNumber) => {
+  const blockHash = await api2.rpc.chain.getBlockHash(blockNumber);
+  return await api2.rpc.chain.getBlock(blockHash);
+};
+var getGuardianAddress = async () => {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  assert(
+    _util.isFunction.call(void 0, _optionalChain([api2, 'access', _61 => _61.query, 'access', _62 => _62["guardian"], 'optionalAccess', _63 => _63["worker"]])),
+    `api.query.guardian.worker does not exist`
+  );
+  const list = await getGuardianList();
+  const addresses = await Promise.all(
+    list.map(async (item) => {
+      const peerid = _bs582.default.decode(item).slice(0, 32);
+      return (await api2.query["guardian"]["worker"](peerid)).toString();
+    })
+  );
+  return list.map((peerid, index) => ({ peerid, address: addresses[index] }));
+};
+var getGuardianNwParams = async () => {
+  try {
+    const api2 = await getApi();
+    if (!api2) throw new Error("API not initialized");
+    const rpc = api2.rpc;
+    const section = "guardian";
+    const method = "guardianNwParams";
+    assert(
+      _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _64 => _64[section], 'optionalAccess', _65 => _65[method]])),
+      `api.rpc.${section}.guardianNwParams does not exist`
+    );
+    const guardianNwParams = await rpc[section][method]();
+    if (typeof guardianNwParams === "object" && guardianNwParams !== null && "kzg" in guardianNwParams) {
+      return guardianNwParams.kzg.toHex().slice(2);
+    } else {
+      throw new Error(`Invalid ${guardianNwParams} format`);
+    }
+  } catch (error) {
+    console.error({ error });
+    throw error;
+  }
+};
+
+// src/chain/onchainfs.ts
+var getBlock2 = async (api2, blockNumber) => {
+  const blockHash = await api2.rpc.chain.getBlockHash(blockNumber);
+  return await api2.rpc.chain.getBlock(blockHash);
+};
+var getFileMetadataCall2 = async (api2, metadataRef) => {
+  const block = await getBlock2(api2, metadataRef[0]);
+  const call = block.block.extrinsics[metadataRef[1]];
+  return call.method;
+};
+var getFileMetadata = async (api2, metadataRef) => {
+  const call = await getFileMetadataCall2(api2, metadataRef);
+  const name = new TextDecoder().decode(call.args[0]);
+  const description = new TextDecoder().decode(call.args[1]);
+  const startRef = [call.args[2][0].toNumber(), call.args[2][1].toNumber()];
+  return {
+    name,
+    description,
+    startRef
+  };
+};
+async function getFileSHA256(file) {
+  const buffer = new Array(12).fill(8);
+  const hashArray = Array.from(new Uint8Array(buffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var readDataFromChain = async (api2, dataRef) => {
+  const call = await getFileMetadataCall2(api2, dataRef);
+  return call.args[0].toU8a();
+};
+var MCryptFs = class _MCryptFs {
+  constructor(mcryptApi, metadataRef, metadata) {
+    this._api = mcryptApi;
+    this._metaRef = metadataRef;
+    this._metadata = metadata;
+    this._init = true;
+  }
+  static dummyInstance(mcryptApi) {
+    return new _MCryptFs(mcryptApi, null, {
+      name: "on-chain-file-name.txt",
+      description: "File uploaded using mcrypt-onchain-fs"
+    });
+  }
+  isValid() {
+    if (!this._metaRef) {
+      throw new Error("Metadata reference not set");
+    }
+    if (!this._metadata || !this._metadata.name || !this._metadata.description || !this._metadata.startRef) {
+      throw new Error("Metadata not set properly");
+    }
+  }
+  getMetadata() {
+    this.isValid();
+    return this._metadata;
+  }
+};
+var MCryptFsWriter = class {
+  constructor(fileOptions, chunkSize = 500, mcryptApi, account) {
+    const {
+      file: iFile,
+      filePath,
+      fileName,
+      description,
+      baseCost,
+      ownerL2Address,
+      guardianInfo
+    } = fileOptions;
+    this._file = iFile;
+    this._filePath = filePath;
+    this._description = description;
+    this._fileName = fileName;
+    this._baseCost = baseCost;
+    this._fileKey = "";
+    this._ownerL2Address = ownerL2Address;
+    this._guardianInfo = guardianInfo;
+    this._chunkSize = chunkSize * 1024;
+    this._api = mcryptApi;
+    this._account = account;
+    this._chunkRefs = [];
+    this._blockNumber = 0;
+    this._extrinsicIndex = 0;
+    this._progress = {
+      iFileSize: iFile.size,
+      iBlocksWritten: 0
+    };
+    this._error = null;
+  }
+  prependMetadata(chunk) {
+    const blockNumberBuffer = new ArrayBuffer(4);
+    const blockView = new DataView(blockNumberBuffer);
+    blockView.setUint32(0, this._blockNumber, false);
+    const extIndexBuffer = new ArrayBuffer(4);
+    const extView = new DataView(extIndexBuffer);
+    extView.setUint32(0, this._extrinsicIndex, false);
+    return new Blob([blockNumberBuffer, extIndexBuffer, chunk]);
+  }
+  async writeChunk(chunk) {
+    const request = this._api.tx.dataAvailability.submitData(
+      Array.from(new Uint8Array(await chunk.arrayBuffer()))
+    );
+    console.log("account: ", this._account);
+    return new Promise((resolve) => {
+      request.signAndSend(this._account, { app_id: 1 }, (result) => {
+        if (result.isInBlock || result.isFinalized || result.isError) {
+          resolve({
+            blockNumber: _optionalChain([result, 'access', _66 => _66.blockNumber, 'optionalAccess', _67 => _67.toNumber, 'call', _68 => _68()]),
+            index: result.txIndex
+          });
+        }
+      });
+    });
+  }
+  async submitKey(account, data) {
+    const { encoded: encryptedKey, ikm } = testCrypt(this._guardianInfo.tauParams, this._guardianInfo.aggKey);
+    const td_params = uint8ArrayToBase64(hexToUint8Array(encryptedKey));
+    const shared_key = gen_stretched_key(
+      hexToUint8Array(ikm)
+    );
+    const { ciphertext, nonce } = encrypt2(
+      new Uint8Array(Uint8Array.from(data)),
+      shared_key
+    );
+    const blobRef = this._chunkRefs[this._chunkRefs.length - 1];
+    const modelSubmit = JSON.stringify({
+      nonce: uint8ArrayToBase64(Uint8Array.from(nonce)),
+      ciphertext: uint8ArrayToBase64(Uint8Array.from(ciphertext)),
+      td_params,
+      group_pk: this._guardianInfo.groupPk,
+      tau_params: this._guardianInfo.tau_params,
+      chosen_guardians: this._guardianInfo.guardians,
+      blobRef: [blobRef.blockNumber, blobRef.extrinsicIndex]
+    });
+    const request = this._api.tx.dataAvailability.submitData(modelSubmit);
+    return await signAndSend(request, account);
+  }
+  async writeMetadata() {
+    const encoder = new TextEncoder();
+    const fileName = this._fileName;
+    const datasetRef = await this.submitKey(this._account, this._fileKey);
+    const keyRef = [datasetRef.blockNumber, datasetRef.index];
+    const request = this._api.tx.dataAvailability.daccRegisterData(
+      Array.from(new TextEncoder().encode(fileName)),
+      Array.from(new TextEncoder().encode(this._description)),
+      keyRef,
+      this._baseCost,
+      0,
+      Array.from(encoder.encode(this._ownerL2Address)),
+      this._guardianInfo.groupId
+    );
+    return await signAndSend(request, this._account);
+  }
+  async writeFile() {
+    const chunks = [];
+    let offset = 0;
+    while (offset < this._file.size) {
+      const chunk = this._file.slice(offset, offset + this._chunkSize);
+      const prependedChunk = this.prependMetadata(chunk);
+      const blockInfo = await this.writeChunk(prependedChunk);
+      this._blockNumber = blockInfo.blockNumber;
+      this._extrinsicIndex = blockInfo.index;
+      this._progress.iBlocksWritten += chunk.size;
+      this._chunkRefs.push({
+        blockNumber: this._blockNumber,
+        extrinsicIndex: this._extrinsicIndex
+      });
+      offset += this._chunkSize;
+    }
+    this._fileKey = await getFileSHA256(this._file);
+    const metadataRef = await this.writeMetadata();
+    return await FileFromMetadataRef(this._api, [
+      metadataRef.blockNumber,
+      metadataRef.index
+    ]);
+  }
+};
+var MCryptFsReader = class {
+  constructor(filename, mcryptApi, onChainFile) {
+    this._filename = filename;
+    this._api = mcryptApi;
+    this._onChainFile = onChainFile;
+  }
+  async downloadFile() {
+    const chunks = [];
+    let _blockNumber = this._onChainFile._metadata.startRef[0];
+    let _extIndex = this._onChainFile._metadata.startRef[1];
+    while (_blockNumber !== 0) {
+      const prependedChunk = await readDataFromChain(this._api, [
+        _blockNumber,
+        _extIndex
+      ]);
+      const chunk = prependedChunk.slice(12);
+      chunks.push(chunk);
+      const view = new DataView(new Uint8Array(prependedChunk).buffer);
+      _blockNumber = view.getUint32(4);
+      _extIndex = view.getUint32(8);
+    }
+    const blob = new Blob(chunks.reverse());
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = this._filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+    return blob;
+  }
+};
+var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
+  const metadata = await getFileMetadata(mcryptApi, metadataRef);
+  return new MCryptFs(mcryptApi, metadataRef, metadata);
+};
+
+// src/compute/agreement.ts
+
+async function createAgreement() {
+  const api2 = await getApi();
+  if (!api2) throw new Error("Api not initialized");
+  const tx = api2.tx.compute.agreement();
+  const guardians = await getGuardianList();
+  const agreement = guardians.slice(0, 3).map((g) => _bs582.default.decode(g).subarray(6));
+  assert(agreement.length === 3, "Not enough guardians to create agreement");
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  const { tx_result } = await signAndSend(tx, account, {
+    compute: { da_type: 1, agreement, verification: 0, compute: 1 }
+  });
+  if (!tx_result.isError) {
+    const agreementCreatedEvent = tx_result.events.find((event) => {
+      return event.event.section === "compute" && event.event.method === "AgreementCreated";
+    });
+    if (agreementCreatedEvent) {
+      debugLog(
+        "Agreement data:",
+        agreementCreatedEvent.event.data.toString()
+      );
+    } else {
+      debugLog("AgreementCreated event not found");
+    }
+  }
+}
+
+// src/compute/participants.ts
+
+async function getGuardianParticipants() {
+  const api2 = await getApi();
+  if (!api2) throw new Error("Api not initialized");
+  try {
+    const guardians = await api2.query.guardian.guardians();
+    const nextGuardians = await api2.query.guardian.nextGuardians();
+    const currentEra = await api2.query.staking.currentEra();
+    const currentIndex = await api2.query.guardian.currentIndex();
+    const peerid = await api2.rpc.system.localPeerId();
+    const _peerid = _bs582.default.decode((peerid || "").toString());
+    const account = await api2.query.guardian.worker(_peerid.slice(0, 32));
+    const nextIndex = currentIndex ? Number(currentIndex) + 1 : 1;
+    const guardiansList = _optionalChain([guardians, 'optionalAccess', _69 => _69.toJSON, 'call', _70 => _70()]) || [];
+    const nextGuardiansList = _optionalChain([nextGuardians, 'optionalAccess', _71 => _71.toJSON, 'call', _72 => _72()]) || [];
+    const buildDetails = async (list) => {
+      return Promise.all(
+        list.map(async (guardian) => {
+          const guardianPrefs = await api2.query.staking.guardians(guardian);
+          const ledger = await api2.query.staking.ledger(guardian);
+          const bonded = await api2.query.staking.bonded(guardian);
+          const payee = await api2.query.staking.payee(guardian);
+          const stakersOverview = await api2.query.staking.erasStakersOverview(
+            _optionalChain([currentEra, 'optionalAccess', _73 => _73.toPrimitive, 'call', _74 => _74()]),
+            guardian
+          );
+          const guardianErasPrefs = await api2.query.staking.erasGuardianPrefs(
+            _optionalChain([currentEra, 'optionalAccess', _75 => _75.toPrimitive, 'call', _76 => _76()]),
+            guardian
+          );
+          return {
+            guardian,
+            rewardDestination: _optionalChain([payee, 'optionalAccess', _77 => _77.toHuman]) ? payee.toHuman() : null,
+            currentPreferences: _optionalChain([guardianErasPrefs, 'optionalAccess', _78 => _78.toHuman]) ? guardianErasPrefs.toHuman() : null,
+            upcomingPreferences: _optionalChain([guardianPrefs, 'optionalAccess', _79 => _79.toHuman]) ? guardianPrefs.toHuman() : null,
+            stash: _optionalChain([bonded, 'optionalAccess', _80 => _80.toHuman]) ? bonded.toHuman() : null,
+            currentStakeOverview: _optionalChain([stakersOverview, 'optionalAccess', _81 => _81.toHuman]) ? stakersOverview.toHuman() : null,
+            upcomingStakeOverview: _optionalChain([ledger, 'optionalAccess', _82 => _82.toHuman]) ? ledger.toHuman() : null
+          };
+        })
+      );
+    };
+    const currentGuardians = await buildDetails(guardiansList);
+    const upcomingGuardians = await buildDetails(nextGuardiansList);
+    return {
+      nwState: {
+        localPeerId: _optionalChain([peerid, 'optionalAccess', _83 => _83.toString, 'call', _84 => _84()]),
+        worker: _optionalChain([account, 'optionalAccess', _85 => _85.toHuman]) ? account.toHuman() : null,
+        currentEra: _optionalChain([currentEra, 'optionalAccess', _86 => _86.toHuman]) ? currentEra.toHuman() : null,
+        guardians: JSON.stringify(_optionalChain([guardians, 'optionalAccess', _87 => _87.toHuman]) ? guardians.toHuman() : null, null, 2),
+        nextGuardians: JSON.stringify(_optionalChain([nextGuardians, 'optionalAccess', _88 => _88.toHuman]) ? nextGuardians.toHuman() : null, null, 2),
+        currentIndex: _optionalChain([currentIndex, 'optionalAccess', _89 => _89.toHuman]) ? currentIndex.toHuman() : null,
+        nextIndex
+      },
+      currentGuardians,
+      upcomingGuardians
+    };
+  } finally {
+    api2.disconnect();
+  }
+}
+
+// src/crypto/random.ts
+function generateRandomBytes(length = 32) {
+  const bytes = new Uint8Array(length);
+  const cr = globalThis.crypto;
+  if (!cr || typeof cr.getRandomValues !== "function") {
+    throw new Error(
+      "crypto.getRandomValues is not available. Ensure you're running in a supported environment (browser or Node.js 18+)."
+    );
+  }
+  cr.getRandomValues(bytes);
+  return bytes;
+}
+
+// src/da/register.ts
+async function writeMetadata(account, name, description, ref, price, dataType, l2Owner, groupId) {
+  const blobRef = [ref.blockNumber, ref.index];
+  const encoder = new TextEncoder();
+  const nameBytes = Array.from(encoder.encode(name));
+  const descriptionBytes = Array.from(encoder.encode(description));
+  const ownerBytes = Array.from(encoder.encode(l2Owner));
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = api2.tx.dataAvailability.daccRegisterData(
+    nameBytes,
+    descriptionBytes,
+    blobRef,
+    price,
+    dataType,
+    ownerBytes,
+    groupId
+  );
+  const hash = await signAndSend(request, account);
+  debugLog(`Metadata registration transaction sent with hash: ${hash.hash}`);
+  return hash;
+}
+
+// src/da/submit.ts
+async function submitData(account, data) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  debugLog(`
+Submitting data with content length: ${data.length}`);
+  const tx = api2.tx.dataAvailability.submitData(data);
+  const hash = await signAndSend(tx, account, DEFAULT_EMPTY_PAYLOAD);
+  debugLog(`Data availability transaction sent with hash: ${hash.hash}`);
+}
+async function submitTEData(account, data, chosenGuardians, tau_params, agg_key, group_pk) {
+  const { encoded: encryptedKey, ikm } = testCrypt(tau_params, agg_key);
+  const td_params = uint8ArrayToBase64(hexToUint8Array(encryptedKey));
+  const shared_key = gen_stretched_key(hexToUint8Array(ikm));
+  const encoder = new TextEncoder();
+  const dataUint8Array = encoder.encode(data);
+  const { ciphertext, nonce } = encrypt2(dataUint8Array, shared_key);
+  const modelSubmit = JSON.stringify({
+    nonce: uint8ArrayToBase64(nonce),
+    ciphertext: uint8ArrayToBase64(ciphertext),
+    td_params,
+    group_pk: Array.from(new Uint8Array(hexToUint8Array(group_pk))),
+    tau_params: Array.from(new Uint8Array(hexToUint8Array(tau_params))),
+    chosen_guardians: chosenGuardians
+  });
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = await api2.tx.dataAvailability.submitData(modelSubmit);
+  const hash = await signAndSend(request, account, DEFAULT_EMPTY_PAYLOAD);
+  debugLog(`TE data availability transaction sent with hash: ${hash.hash}`);
+  return hash;
+}
+
+// src/da/upload.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+async function uploadData(options) {
+  const { name, description, price, type, guardianGroupInfo, ref, filePath } = options;
+  assert(
+    guardianGroupInfo.guardians && guardianGroupInfo.tauParams && guardianGroupInfo.aggKey && guardianGroupInfo.groupPk,
+    "Guardian group info is missing required properties"
+  );
+  const account = (await getKeyring()).pairs[0];
+  const ethAddress = "";
+  if (type === "dataset" && filePath) {
+    const fileContent = _fs2.default.readFileSync(filePath);
+    const selectedFile = new File([fileContent], _path2.default.basename(filePath), {
+      type: "application/octet-stream",
+      lastModified: Date.now()
+    });
+    const msCryptFsWriter = new MCryptFsWriter(
+      {
+        file: selectedFile,
+        fileName: selectedFile.name,
+        filePath: "",
+        description,
+        baseCost: BigInt(Number(price) * 10 ** 18),
+        ownerL2Address: ethAddress,
+        guardianInfo: guardianGroupInfo
+      },
+      500,
+      await getApi(),
+      account
+    );
+    await msCryptFsWriter.writeFile();
+  } else {
+    const dataRef = await submitTEData(
+      account,
+      ref || "",
+      guardianGroupInfo.guardians,
+      guardianGroupInfo.tauParams,
+      guardianGroupInfo.aggKey,
+      guardianGroupInfo.groupPk
+    );
+    const dtype = type === "model" ? 1 : type === "agent" ? 2 : 0;
+    await writeMetadata(
+      account,
+      name,
+      description,
+      dataRef,
+      BigInt(Number(price) * 10 ** 18),
+      dtype,
+      ethAddress,
+      guardianGroupInfo.groupId
+    );
+  }
+}
+
+// src/stake/add.ts
+async function addStake(account, amount) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  debugLog("Using account:", account.address);
+  const stakeTx = api2.tx.staking.bondExtra(amount);
+  const hash = await signAndSend(stakeTx, account);
+  debugLog(`Stake transaction sent with hash: ${hash.hash}`);
+}
+
+// src/stake/idle.ts
+async function joinIdleStaker(account) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  const chillTx = api2.tx.staking.chill();
+  const hash = await signAndSend(chillTx, account);
+  debugLog("Idle staker chill tx sent with hash:", hash.hash);
+}
+
+// src/stake/new.ts
+async function newStake(account, amount, rewardDestination = "Staked") {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  debugLog(
+    `Staking amount: ${amount} for account: ${account.address} with reward destination: ${rewardDestination}`
+  );
+  const stakeTx = api2.tx.staking.bond(amount, rewardDestination);
+  const hash = await signAndSend(stakeTx, account);
+  debugLog(`Stake transaction sent with hash: ${hash.hash}`);
+}
+
+// src/stake/payout.ts
+async function payoutStake(account, eras, address) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  for (const era of eras) {
+    debugLog("Paying account: ", address || account.address, " for era ", era);
+  }
+  const unstakeTxs = eras.map(
+    (era) => api2.tx.staking.payoutStakers(address || account.address, era)
+  );
+  const batchTx = api2.tx.utility.batch(unstakeTxs);
+  const hash = await signAndSend(batchTx, account);
+  debugLog(`Batch payout transaction sent with hash: ${hash.hash}`);
+}
+
+// src/stake/reduce.ts
+async function reduceStake(account, amount) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  debugLog("Using account:", account.address);
+  const unstakeTx = api2.tx.staking.unbond(amount);
+  const hash = await signAndSend(unstakeTx, account);
+  debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
+}
+
+// src/stake/remove.ts
+async function removeStake(account) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  const stakeAmount = await _asyncOptionalChain([(await api2.query.staking.ledger(account.address)), 'optionalAccess', async _90 => _90.toPrimitive, 'call', async _91 => _91()]);
+  debugLog("Removing entire stake amount:", _optionalChain([stakeAmount, 'optionalAccess', _92 => _92.active]) || 0n);
+  const unstakeTx = api2.tx.staking.unbond(_optionalChain([stakeAmount, 'optionalAccess', _93 => _93.active]) || 0n);
+  const hash = await signAndSend(unstakeTx, account);
+  debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
+}
+
+// src/stake/withdraw.ts
+async function withdrawStake(account) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  const unstakeTx = api2.tx.staking.withdrawUnbonded(0);
+  const hash = await signAndSend(unstakeTx, account);
+  debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
+}
+
+// src/token/fund.ts
+async function fundAccount(account, amount, address) {
+  const addr = address ? address : account.address;
+  const keyring2 = await getKeyring();
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  debugLog(`
+Funding account: ${addr} with amount: ${amount}`);
+  const tx = api2.tx.balances.transferKeepAlive(addr, amount);
+  const hash = await signAndSend(tx, keyring2.getPairs()[0]);
+  debugLog(`Fund transaction sent with hash: ${hash.hash}`);
+}
+
+// src/token/transfer.ts
+async function transfer(account, amount, address) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  debugLog(`
+Transferring funds to account: ${address} with amount: ${amount}`);
+  const tx = api2.tx.balances.transferKeepAlive(address, amount);
+  const hash = await signAndSend(tx, account);
+  debugLog(`Transfer transaction sent with hash: ${hash.hash}`);
+}
+
+// src/validator/join.ts
+async function joinValidator(account, commission) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  assert(account, "Account not initialized");
+  const validateTx = api2.tx.staking.validate({ commission, blocked: true });
+  const hash = await signAndSend(validateTx, account);
+  debugLog("Validator join tx sent with hash:", hash.hash);
+}
+
+// src/identity.ts
+var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
+async function setIdentity(account, { display = void 0 }) {
+  const api2 = await getApi();
+  _assert2.default.call(void 0, api2, "API not initialized");
+  debugLog(`
+Setting identity for account: ${account.address} as ${display}`);
+  const tx = api2.tx.identity.setIdentity({ display: { Raw: display } });
+  const hash = await signAndSend(tx, account);
+  debugLog(`Set identity transaction sent with hash: ${hash.hash}`);
+}
+
+// src/rotateKeys.ts
+
+
+async function rotateAndSetKeys(account) {
+  const api2 = await getApi();
+  _assert2.default.call(void 0, api2, "API not initialized");
+  debugLog(`Rotating session keys for ${account.meta.name} on ${provider.endpoint}`);
+  const newKeys = await api2.rpc.author.rotateKeys();
+  debugLog(`${account.meta.name} rotated keys on ${provider.endpoint}:`, _nullishCoalesce(_optionalChain([newKeys, 'optionalAccess', _94 => _94.toHex, 'optionalCall', _95 => _95()]), () => ( newKeys)));
+  const setKeysTx = api2.tx.session.setKeys(newKeys, []);
+  const hash = await signAndSend(setKeysTx, account);
+  debugLog(`Rotate session transaction sent with hash: ${hash.hash}`);
+}
+async function setWorker(account) {
+  const api2 = await getApi();
+  _assert2.default.call(void 0, api2, "API not initialized");
+  const peerid = _bs582.default.decode((await api2.rpc.system.localPeerId()).toString());
+  const setWorkerTx = api2.tx.guardian.setWorker(peerid.slice(0, 32));
+  const hash = await signAndSend(setWorkerTx, account);
+  debugLog(`Set worker id transaction sent with hash: ${hash.hash}`);
+}
+
+// src/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.API_EXTENSIONS = API_EXTENSIONS; exports.API_RPC = API_RPC; exports.API_TYPES = API_TYPES; exports.AccountSourceType = AccountSourceType; exports.ApiPromise = _api2.ApiPromise; exports.CryptoType = CryptoType; exports.DEBUG = DEBUG; exports.DEFAULT_COMPUTE_PAYLOAD = DEFAULT_COMPUTE_PAYLOAD; exports.DEFAULT_EMPTY_PAYLOAD = DEFAULT_EMPTY_PAYLOAD; exports.FileFromMetadataRef = FileFromMetadataRef; exports.HttpProvider = _api2.HttpProvider; exports.MCryptFs = MCryptFs; exports.MCryptFsReader = MCryptFsReader; exports.MCryptFsWriter = MCryptFsWriter; exports.PALLIORA_RPC_URL = PALLIORA_RPC_URL; exports.PALLIORA_WS = PALLIORA_WS; exports.RpcApi = RpcApi; exports.TX_WAIT_FINALIZATION = TX_WAIT_FINALIZATION; exports.WsProvider = _api2.WsProvider; exports.addStake = addStake; exports.base64ToUint8Array = base64ToUint8Array; exports.clearTokenCache = clearTokenCache; exports.configure = configure; exports.createAccount = createAccount; exports.createAgreement = createAgreement; exports.createGuardianGroup = createGuardianGroup; exports.debugLog = debugLog; exports.decodeAggregateKey = decodeAggregateKey; exports.decodeField = decodeField; exports.decodePowersOfTau = decodePowersOfTau; exports.decrypt = decrypt; exports.ecncryptTest = encrypt; exports.encodeCiphertext = encodeCiphertext; exports.encrypt = encrypt2; exports.fetchTokenProperties = fetchTokenProperties; exports.formatBalanceWithTokenProperties = formatBalanceWithTokenProperties; exports.fundAccount = fundAccount; exports.gen_shared_key = gen_shared_key; exports.gen_stretched_key = gen_stretched_key; exports.generateRandomBytes = generateRandomBytes; exports.getApi = getApi; exports.getCachedTokenProperties = getCachedTokenProperties; exports.getEncKeyring = getEncKeyring; exports.getFileMetadataCall = getFileMetadataCall; exports.getGuardianAddress = getGuardianAddress; exports.getGuardianList = getGuardianList; exports.getGuardianNwParams = getGuardianNwParams; exports.getGuardianParticipants = getGuardianParticipants; exports.getKeyring = getKeyring; exports.getRpcApi = getRpcApi; exports.hexToUint8Array = hexToUint8Array; exports.joinGuardian = joinGuardian; exports.joinIdleStaker = joinIdleStaker; exports.joinValidator = joinValidator; exports.newStake = newStake; exports.pairFromPrivateKeyHex = pairFromPrivateKeyHex; exports.payoutStake = payoutStake; exports.provider = provider; exports.reduceStake = reduceStake; exports.removeStake = removeStake; exports.rotateAndSetKeys = rotateAndSetKeys; exports.setIdentity = setIdentity; exports.setWorker = setWorker; exports.signAndSend = signAndSend; exports.submitData = submitData; exports.submitTEData = submitTEData; exports.testCrypt = testCrypt; exports.tokenToBigint = tokenToBigint; exports.transfer = transfer; exports.uint8ArrayToBase64 = uint8ArrayToBase64; exports.uploadData = uploadData; exports.utilCrypto = utilCrypto; exports.wasmCrypto = wasmCrypto; exports.withdrawStake = withdrawStake; exports.writeMetadata = writeMetadata;
+//# sourceMappingURL=index.cjs.map