@palliora.org/chainsdk 0.1.0 → 0.3.0

package/dist/index.js

@@ -220,12 +220,182 @@ var API_TYPES = {
     extra: "CheckAppIdExtra",
     types: "CheckAppIdTypes"
   },
+  FeePayload: {
+    compute: "u128",
+    guardian: "u128",
+    verifier: "u128"
+  },
+  SilentThresholdParams: {
+    td_params: "Vec<u8>",
+    pk_bytes: "Vec<u8>",
+    tau_params: "Vec<u8>"
+  },
+  ThresholdParams: {
+    _enum: {
+      SilentThreshold: "SilentThresholdParams"
+    }
+  },
+  ChaCha20Poly1305Params: {
+    nonce: "[u8; 12]"
+  },
+  Aes256GcmParams: {
+    nonce: "[u8; 12]"
+  },
+  SymmetricParams: {
+    _enum: {
+      ChaCha20Poly1305: "ChaCha20Poly1305Params",
+      Aes256Gcm: "Aes256GcmParams"
+    }
+  },
+  KdfParams: {
+    _enum: {
+      HkdfSha256: "Null",
+      HkdfSha512: "Null"
+    }
+  },
+  Secp256k1Params: {
+    recipient_public_key: "Vec<u8>",
+    ephemeral_public_key: "Option<Vec<u8>>",
+    compressed: "bool",
+    kdf: "KdfParams",
+    salt: "Option<Vec<u8>>",
+    info: "Option<Vec<u8>>"
+  },
+  Ed25519Params: {
+    recipient_public_key: "Vec<u8>",
+    ephemeral_public_key: "Option<Vec<u8>>",
+    kdf: "KdfParams",
+    salt: "Option<Vec<u8>>",
+    info: "Option<Vec<u8>>"
+  },
+  AsymmetricParams: {
+    _enum: {
+      Secp256k1: "Secp256k1Params",
+      Ed25519: "Ed25519Params"
+    }
+  },
+  ThresholdHybridParams: {
+    threshold_params: "ThresholdParams",
+    symmetric_params: "SymmetricParams"
+  },
+  AsymmetricHybridParams: {
+    asymmetric_params: "AsymmetricParams",
+    symmetric_params: "SymmetricParams"
+  },
+  CipherSuite: {
+    _enum: {
+      Plaintext: "Null",
+      ThresholdHybrid: "ThresholdHybridParams",
+      AsymmetricHybrid: "AsymmetricHybridParams"
+    }
+  },
+  ConfidentialityLevel: {
+    _enum: {
+      Trusted: "u32",
+      TEE: "Null",
+      FHE: "Null",
+      SMPC: "Null"
+    }
+  },
+  NativeExecuteDA: {
+    _enum: ["Inference"]
+  },
+  NativeDataDA: {
+    _enum: ["DaFalse", "DaTrue"]
+  },
+  DAInputInline: {
+    data: "Vec<u8>"
+  },
+  DAInputChainTransaction: {
+    block_number: "u64",
+    extrinsic_index: "u32"
+  },
+  DAInputIpfs: {
+    cid: "Vec<u8>",
+    size: "u64"
+  },
+  DAInputUrl: {
+    url: "Vec<u8>",
+    size: "u64",
+    hash: "Option<Vec<u8>>"
+  },
+  DAInput: {
+    _enum: {
+      Null: "Null",
+      Inline: "DAInputInline",
+      ChainTransaction: "DAInputChainTransaction",
+      Ipfs: "DAInputIpfs",
+      Url: "DAInputUrl",
+      NativeExecute: "NativeExecuteDA",
+      NativeData: "NativeDataDA"
+    }
+  },
+  ContractType: {
+    _enum: {
+      Dormant: "Null",
+      Active: "Null"
+    }
+  },
+  StoreType: {
+    _enum: {
+      Dataset: "Null",
+      Model: "Null",
+      Agent: "Null",
+      Other: "Null"
+    }
+  },
+  ComputeMetadata: {
+    name: "Vec<u8>",
+    description: "Vec<u8>",
+    store_type: "StoreType",
+    group_id: "H256"
+  },
+  ComputeInfo: {
+    cipher: "CipherSuite",
+    computer_indices: "Vec<u32>",
+    fees: "u128",
+    deadline: "u64",
+    confidentiality: "ConfidentialityLevel",
+    fee_function: "Option<u8>",
+    program_env: "Option<Vec<u8>>",
+    input: "DAInput",
+    program: "DAInput",
+    metadata: "Option<ComputeMetadata>"
+  },
+  Contract: {
+    contract_type: "ContractType",
+    guardians: "Vec<AccountId>",
+    pre_check: "Option<ComputeInfo>",
+    compute: "ComputeInfo",
+    post_check: "Option<ComputeInfo>",
+    result_cipher: "CipherSuite"
+  },
+  AgreementInfo: {
+    status: "AgreementStatus",
+    creator: "AccountId",
+    index: "u32"
+  },
   ComputePayload: {
     da_type: "u8",
     agreement: "Option<BoundedVec<[u8; 32], 10>>",
     verification: "u8",
     compute: "u8"
   },
+  ComputePrefs: {
+    trusted: "bool",
+    tee: "bool",
+    mpc: "bool",
+    fhe: "bool",
+    zkp: "bool"
+  },
+  GuardianPrefs: {
+    pubKey: "[u8; 32]",
+    guardian: "bool",
+    verifier: "bool",
+    compute: "bool",
+    computePrefs: "Option<ComputePrefs>",
+    feeThreshold: "u128"
+  },
   BlockLengthColumns: "Compact<u32>",
   BlockLengthRows: "Compact<u32>",
   BlockLength: {
@@ -599,10 +769,6 @@ function configure(opts) {
 }
 
 // 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");
@@ -653,8 +819,23 @@ var debugLog = (message, ...optionalParams) => {
 };
 
 // src/utils/token.ts
-import { formatBalance } from "@polkadot/util";
+import { formatUnits, parseUnits } from "viem";
+var PALI_SYMBOL = "PALI";
+var PALI_DECIMALS = 18;
 var tokenCache = null;
+var toAtomicPaliAmount = (amount) => {
+  const normalizedAmount = String(amount).trim();
+  if (!normalizedAmount) {
+    throw new Error("Token amount cannot be empty");
+  }
+  return parseUnits(normalizedAmount, PALI_DECIMALS);
+};
+var fromAtomicPaliAmount = (amount) => {
+  return formatUnits(amount, PALI_DECIMALS);
+};
+var formatPaliAmount = (amount, symbol = PALI_SYMBOL) => {
+  return `${fromAtomicPaliAmount(amount)} ${symbol}`;
+};
 async function fetchTokenProperties() {
   if (tokenCache) {
     return tokenCache;
@@ -663,13 +844,12 @@ async function fetchTokenProperties() {
     const systemProperties = (await (await getApi())?.rpc.system.properties())?.toHuman();
     assert(systemProperties, "Failed to fetch system properties from RPC");
     const tokenProperties = {
-      symbol: (systemProperties?.tokenSymbol || ["UNIT"])[0],
-      decimals: Number((systemProperties?.tokenDecimals || ["18"])[0])
+      symbol: (systemProperties?.tokenSymbol || [PALI_SYMBOL])[0],
+      decimals: Number((systemProperties?.tokenDecimals || [String(PALI_DECIMALS)])[0])
     };
     tokenCache = tokenProperties;
     return tokenProperties;
   } catch (error) {
-    console.error("Failed to fetch token properties:", error);
     throw error;
   }
 }
@@ -681,20 +861,12 @@ function clearTokenCache() {
 }
 async function formatBalanceWithTokenProperties(balance) {
   const tokenProperties = await fetchTokenProperties();
-  if (!tokenProperties) {
-    throw new Error(
-      "Token properties not yet cached. Call fetchTokenProperties first."
-    );
-  }
-  return formatBalance(balance, {
-    decimals: tokenProperties.decimals,
-    withSi: true,
-    withUnit: tokenProperties.symbol
-  });
+  return `${formatUnits(typeof balance === "bigint" ? balance : BigInt(balance), tokenProperties.decimals)} ${tokenProperties.symbol}`;
 }
+var tokenToBigint = toAtomicPaliAmount;
 
 // src/chain/singleton.ts
-import { ApiPromise, Keyring as Keyring2, WsProvider as WsProvider2 } from "@polkadot/api";
+import { ApiPromise, Keyring as Keyring2 } from "@polkadot/api";
 
 // src/chain/wsProvider.ts
 import { WsProvider } from "@polkadot/api";
@@ -702,128 +874,13 @@ var provider = new WsProvider(PALLIORA_WS, 1e4);
 
 // src/chain/singleton.ts
 import { waitReady as waitReady2 } from "@polkadot/wasm-crypto";
-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 WsProvider2(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 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 Keyring2({ type: "sr25519" });
-      }
-      if (!encKeyring) {
-        encKeyring = new Keyring2({ 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() {
+var apiListenersAttached = false;
+var apiTeardownInProgress = false;
+async function getApi(cb) {
   if (!provider) return;
-  console.debug(provider.endpoint);
   if (!api) {
     api = await ApiPromise.create({
       provider,
@@ -834,14 +891,24 @@ async function getApi() {
   }
   const isNode = typeof process !== "undefined" && typeof process.exit === "function";
   const isTest = typeof process !== "undefined" && process.env?.NODE_ENV === "test";
-  if (isNode && !isTest) {
+  if (isNode && !isTest && api && !apiListenersAttached) {
+    apiListenersAttached = true;
     api.on("error", (err) => {
-      console.error("api error, will restart:", err);
-      process.exit(0);
+      if (apiTeardownInProgress) return;
+      apiTeardownInProgress = true;
+      apiListenersAttached = false;
+      const currentApi = api;
+      api = null;
+      void currentApi?.disconnect().catch((disconnectErr) => {
+        apiTeardownInProgress = false;
+        console.error("api disconnect after error failed:", disconnectErr);
+      });
     });
     api.on("disconnected", () => {
-      console.error("api disconnected, will restart.");
-      process.exit(0);
+      api = null;
+      apiListenersAttached = false;
+      apiTeardownInProgress = false;
+      if (cb) cb();
     });
   }
   return api;
@@ -862,13 +929,6 @@ async function getEncKeyring() {
   }
   return encKeyring;
 }
-var apiInstance = null;
-function getRpcApi() {
-  if (!apiInstance) {
-    apiInstance = new RpcApi();
-  }
-  return apiInstance;
-}
 
 // src/chain/utils.ts
 import { isFunction as isFunction2 } from "@polkadot/util";
@@ -907,11 +967,48 @@ var createGuardianGroup = async (account, selectedGuardians) => {
     );
     const result = await signAndSend(tx, account);
     debugLog("Guardian group created:", result);
+    return result;
   } catch (error) {
     console.error("Error creating guardian group:", error);
     throw new Error(`Failed to create guardian group: ${error instanceof Error ? error.message : error}`);
   }
 };
+var createGuardianGroupAndWatch = async (account, guardians, maxBlocks = 20) => {
+  assert(guardians.length === 3, "Exactly 3 guardians are required");
+  assert(account, "Failed to load account");
+  const api2 = await getApi();
+  assert(api2, "Failed to initialize API");
+  debugLog(`Submitting guardian group creation...`);
+  const creationResult = await createGuardianGroup(account, guardians);
+  const startBlock = (creationResult?.blockNumber ?? 0) + 1;
+  debugLog(`Group creation tx confirmed at block ${startBlock - 1}. Listening for DaccGuardianGroup event from block ${startBlock}...`);
+  const match = await scanForBlockEvent(
+    api2,
+    {
+      predicate: async (block2, event, phase) => {
+        if (event.section.toLowerCase() !== "dataavailability" || event.method.toLowerCase() !== "daccguardiangroup") return false;
+        if (!phase.isApplyExtrinsic) return false;
+        const ext2 = block2.block.extrinsics[phase.asApplyExtrinsic.toNumber()];
+        return ext2?.method?.section?.toLowerCase() === "dataavailability" && ext2?.method?.method?.toLowerCase() === "daccguardiangroupinfo";
+      }
+    },
+    startBlock,
+    maxBlocks
+  );
+  assert(match.extrinsicIndex !== null, "DaccGuardianGroup event was not emitted by an extrinsic");
+  debugLog(`DaccGuardianGroup event found at block ${match.blockNumber}, extrinsic index ${match.extrinsicIndex}. Decoding args...`);
+  const block = await match.block();
+  const ext = block.block.extrinsics[match.extrinsicIndex];
+  const [group_id, group_pk, tau_params, agg_key] = ext.method.args;
+  debugLog(`Guardian group parameters decoded: group_id=${group_id.toHex()}`);
+  return {
+    groupId: group_id.toHex(),
+    groupPk: group_pk.toHex(),
+    tauParams: tau_params.toHex(),
+    aggKey: agg_key.toHex(),
+    guardians
+  };
+};
 
 // src/guardian/join.ts
 async function joinGuardian(account, prefs) {
@@ -919,6 +1016,7 @@ async function joinGuardian(account, prefs) {
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
   const computeOpts = prefs.compute?.split(",").map((s) => s.trim()).filter((s) => s.length > 0) || void 0;
+  const feeThreshold = typeof prefs.fee === "bigint" ? prefs.fee : BigInt(prefs.fee || "0");
   const guardianPrefs = {
     pubKey: account.publicKey,
     guardian: prefs.standard,
@@ -930,12 +1028,13 @@ async function joinGuardian(account, prefs) {
       mpc: computeOpts?.includes("mpc") || false,
       fhe: computeOpts?.includes("fhe") || false,
       zkp: computeOpts?.includes("zkp") || false
-    }
+    },
+    feeThreshold
   };
   debugLog(
     account.address,
     "joining as guardian with preferences:",
-    guardianPrefs
+    { ...guardianPrefs, feeThreshold: formatPaliAmount(feeThreshold) }
   );
   const guardTx = api2.tx.staking.guard(guardianPrefs);
   const hash = await signAndSend(guardTx, account);
@@ -956,7 +1055,7 @@ var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
     });
   });
   if (tx_result.isError) {
-    throw new Error(`Transaction failed with error: ${tx_result.error}`);
+    throw new Error(`Transaction failed with error: ${tx_result.dispatchError}`);
   }
   if (tx_result.dispatchError) {
     throw new Error(
@@ -967,8 +1066,8 @@ var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
     `Transaction ${tx_result.txHash.toHex()} included in timepoint ${tx_result.blockNumber}-${tx_result.txIndex}`
   );
   return {
-    blockNumber: tx_result?.blockNumber?.toNumber(),
-    index: tx_result?.txIndex,
+    blockNumber: tx_result.blockNumber?.toNumber() ?? 0,
+    index: tx_result.txIndex ?? 0,
     hash: tx_result.txHash.toHex(),
     tx_result
   };
@@ -986,14 +1085,14 @@ var getGuardianAddress = async () => {
   const api2 = await getApi();
   if (!api2) throw new Error("API not initialized");
   assert(
-    isFunction2(api2.query["guardian"]?.["worker"]),
-    `api.query.guardian.worker does not exist`
+    isFunction2(api2.query["guardian"]?.["workerByKey"]),
+    `api.query.guardian.workerByKey does not exist`
   );
   const list = await getGuardianList();
   const addresses = await Promise.all(
     list.map(async (item) => {
-      const peerid = bs58.decode(item).slice(0, 32);
-      return (await api2.query["guardian"]["worker"](peerid)).toString();
+      const peerid = bs58.decode(item).slice(6, 38);
+      return (await api2.query["guardian"]["workerByKey"](peerid)).toString();
     })
   );
   return list.map((peerid, index) => ({ peerid, address: addresses[index] }));
@@ -1020,6 +1119,149 @@ var getGuardianNwParams = async () => {
     throw error;
   }
 };
+async function fetchAndDecodeExtrinsic(blockHeight, extrinsicIndex) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  const blockHash = await api2.rpc.chain.getBlockHash(blockHeight);
+  const signedBlock = await api2.rpc.chain.getBlock(blockHash);
+  const extrinsics = signedBlock.block.extrinsics;
+  if (extrinsicIndex >= extrinsics.length) {
+    throw new Error(
+      `extrinsic index ${extrinsicIndex} out of range \u2014 block ${blockHeight} has ${extrinsics.length} extrinsics`
+    );
+  }
+  const raw = extrinsics[extrinsicIndex];
+  const decoded = raw.toHuman();
+  return { raw, decoded };
+}
+var scanForBlockEvent = (api2, filter, startBlock, maxBlocks = 20) => {
+  const hasPredicate = "predicate" in filter;
+  let blocksScanned = 0;
+  let done = false;
+  return new Promise((resolve, reject) => {
+    const unsubPromise = api2.rpc.chain.subscribeNewHeads(
+      async (header) => {
+        if (done) return;
+        const currentBlock = header.number.toNumber();
+        if (startBlock !== void 0 && currentBlock < startBlock) return;
+        blocksScanned++;
+        if (maxBlocks > 0 && blocksScanned > maxBlocks) {
+          done = true;
+          unsubPromise.then((unsub) => unsub());
+          reject(new Error(`No matching event found within ${maxBlocks} blocks`));
+          return;
+        }
+        try {
+          const blockHash = await api2.rpc.chain.getBlockHash(currentBlock);
+          const eventsResult = await api2.query.system.events.at(blockHash);
+          const events = eventsResult;
+          const blockData = await (hasPredicate ? api2.rpc.chain.getBlock(blockHash) : Promise.resolve(null));
+          for (const record of events) {
+            const { event, phase } = record;
+            const matched = hasPredicate ? await filter.predicate(blockData, event, phase) : event.section.toLowerCase() === filter.section.toLowerCase() && event.method.toLowerCase() === filter.method.toLowerCase();
+            if (!matched) continue;
+            done = true;
+            unsubPromise.then((unsub) => unsub());
+            resolve({
+              blockHash: blockHash.toHex(),
+              blockNumber: currentBlock,
+              extrinsicIndex: phase.isApplyExtrinsic ? phase.asApplyExtrinsic.toNumber() : null,
+              block: blockData ? () => Promise.resolve(blockData) : () => api2.rpc.chain.getBlock(blockHash),
+              events
+            });
+            return;
+          }
+        } catch (err) {
+          debugLog(`scanForBlockEvent: error scanning block ${currentBlock}: ${err}`);
+        }
+      }
+    );
+  });
+};
+async function watchForSubmissionReceipt(requestId, timeoutMs = 10 * 60 * 1e3) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  return new Promise((resolve, reject) => {
+    let unsubFn;
+    let settled = false;
+    const cleanup = (settleFn) => {
+      if (settled) return;
+      settled = true;
+      unsubFn?.();
+      settleFn();
+    };
+    const timer = setTimeout(
+      () => cleanup(() => reject(new Error(`receipt watch timed out for requestId=${requestId}`))),
+      timeoutMs
+    );
+    api2.rpc.chain.subscribeNewHeads(async (header) => {
+      if (settled) return;
+      try {
+        const blockNumber = header.number.toNumber();
+        const blockHash = header.hash;
+        const signedBlock = await api2.rpc.chain.getBlock(blockHash);
+        const extrinsics = signedBlock.block.extrinsics;
+        for (let i = 0; i < extrinsics.length; i++) {
+          const ext = extrinsics[i];
+          const decoded = ext.toHuman();
+          const method = decoded?.method;
+          if (String(method?.section ?? "").toLowerCase() === "compute" && String(method?.method ?? "").toLowerCase() === "result") {
+            const args = method?.args;
+            const onChainId = String(args?.request_id ?? args?.requestId ?? args?.[0] ?? "");
+            if (onChainId === requestId) {
+              clearTimeout(timer);
+              cleanup(
+                () => resolve({
+                  extrinsicHash: ext.hash.toHex(),
+                  blockHeight: blockNumber,
+                  extrinsicIndex: i
+                })
+              );
+              return;
+            }
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[watchReceipt] block check failed requestId=${requestId}: ${msg}`);
+      }
+    }).then((fn) => {
+      if (settled) {
+        fn();
+      } else {
+        unsubFn = fn;
+      }
+    }).catch((err) => {
+      clearTimeout(timer);
+      cleanup(() => reject(err));
+    });
+  });
+}
+async function getAgreementCreatedRequestId(blockHeight, extrinsicIndex) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  const blockHash = await api2.rpc.chain.getBlockHash(blockHeight);
+  const apiAt = await api2.at(blockHash);
+  const allEvents = await apiAt.query.system.events();
+  for (const record of allEvents) {
+    const { phase, event } = record;
+    if (!phase.isApplyExtrinsic || phase.asApplyExtrinsic.toNumber() !== extrinsicIndex) {
+      continue;
+    }
+    if (String(event.section ?? "").toLowerCase() !== "compute" || String(event.method ?? "").toLowerCase() !== "agreementcreated") {
+      continue;
+    }
+    const dataHuman = event.data.toHuman();
+    if (Array.isArray(dataHuman)) {
+      const first = dataHuman[0];
+      if (first != null) return String(first);
+    } else if (dataHuman !== null && typeof dataHuman === "object") {
+      const id = dataHuman["requestId"] ?? dataHuman["request_id"] ?? dataHuman["id"];
+      if (id != null) return String(id);
+    }
+  }
+  return null;
+}
 
 // src/chain/onchainfs.ts
 var getBlock2 = async (api2, blockNumber) => {
@@ -1058,12 +1300,10 @@ var MCryptFs = class _MCryptFs {
     this._metaRef = metadataRef;
     this._metadata = metadata;
     this._init = true;
+    this._chunkRefs = [];
   }
   static dummyInstance(mcryptApi) {
-    return new _MCryptFs(mcryptApi, null, {
-      name: "on-chain-file-name.txt",
-      description: "File uploaded using mcrypt-onchain-fs"
-    });
+    return new _MCryptFs(mcryptApi, null, null);
   }
   isValid() {
     if (!this._metaRef) {
@@ -1127,8 +1367,8 @@ var MCryptFsWriter = class {
       request.signAndSend(this._account, { app_id: 1 }, (result) => {
         if (result.isInBlock || result.isFinalized || result.isError) {
           resolve({
-            blockNumber: result.blockNumber?.toNumber(),
-            index: result.txIndex
+            blockNumber: result.blockNumber?.toNumber() ?? 0,
+            index: result.txIndex ?? 0
           });
         }
       });
@@ -1150,7 +1390,7 @@ var MCryptFsWriter = class {
       ciphertext: uint8ArrayToBase64(Uint8Array.from(ciphertext)),
       td_params,
       group_pk: this._guardianInfo.groupPk,
-      tau_params: this._guardianInfo.tau_params,
+      tau_params: this._guardianInfo.tauParams,
       chosen_guardians: this._guardianInfo.guardians,
       blobRef: [blobRef.blockNumber, blobRef.extrinsicIndex]
     });
@@ -1193,7 +1433,7 @@ var MCryptFsWriter = class {
     const metadataRef = await this.writeMetadata();
     return await FileFromMetadataRef(this._api, [
       metadataRef.blockNumber,
-      metadataRef.index
+      metadataRef.index ?? 0
     ]);
   }
 };
@@ -1205,6 +1445,9 @@ var MCryptFsReader = class {
   }
   async downloadFile() {
     const chunks = [];
+    if (!this._onChainFile._metadata) {
+      throw new Error("Metadata not loaded");
+    }
     let _blockNumber = this._onChainFile._metadata.startRef[0];
     let _extIndex = this._onChainFile._metadata.startRef[1];
     while (_blockNumber !== 0) {
@@ -1236,36 +1479,125 @@ var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
 };
 
 // src/compute/agreement.ts
-import bs582 from "bs58";
-async function createAgreement() {
+async function createAgreement(contract, account) {
   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.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 }
-  });
+  const tx = api2.tx["compute"]["agreement"](contract);
+  const opts = {
+    compute: {
+      da_type: 1,
+      verification: 0,
+      compute: contract.contract_type === "Active" ? 1 : 0
+    }
+  };
+  const { tx_result, blockNumber, index, hash } = await signAndSend(
+    tx,
+    account,
+    opts
+  );
   if (!tx_result.isError) {
-    const agreementCreatedEvent = tx_result.events.find((event) => {
-      return event.event.section === "compute" && event.event.method === "AgreementCreated";
-    });
+    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()
-      );
+      debugLog("Agreement data:", agreementCreatedEvent.event.data.toString());
+      return {
+        blockNumber,
+        index: index ?? 0,
+        hash,
+        agreementId: agreementCreatedEvent.event.data[0]?.toHex?.() ?? agreementCreatedEvent.event.data.toString()
+      };
     } else {
       debugLog("AgreementCreated event not found");
     }
   }
+  return { blockNumber, index: index ?? 0, hash };
+}
+async function createSimpleAgreement() {
+  const guardianIds = (await getGuardianAddress()).slice(0, 3).map((g) => g.address);
+  assert(guardianIds.length === 3, "Not enough guardians to create agreement");
+  const contract = {
+    contract_type: "Dormant",
+    guardians: guardianIds,
+    pre_check: null,
+    compute: {
+      cipher: "Plaintext",
+      computer_indices: [0, 1, 2],
+      fees: toAtomicPaliAmount("0.01"),
+      deadline: 0,
+      confidentiality: { Trusted: 0 },
+      fee_function: null,
+      input: null,
+      program: { NativeData: "DaFalse" },
+      metadata: null
+    },
+    post_check: null,
+    result_cipher: "Plaintext"
+  };
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  return createAgreement(contract, account);
+}
+
+// src/compute/data.ts
+async function dataContract(params, account) {
+  const plaintextCipher = "Plaintext";
+  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: params.trustIndex ?? 0 },
+    fee_function: null,
+    input: {
+      Url: {
+        url: Array.from(new TextEncoder().encode(params.url))
+      }
+    },
+    program: {
+      NativeData: "DaFalse"
+    }
+  };
+  const contract = {
+    contract_type: "Dormant",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
+}
+
+// src/compute/inference.ts
+async function inferenceCompute(params, account) {
+  const inputData = typeof params.input === "string" ? Array.from(new TextEncoder().encode(params.input)) : Array.from(params.input);
+  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
+  const plaintextCipher = "Plaintext";
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: 0 },
+    fee_function: null,
+    input: { Inline: { data: inputData } },
+    program: { NativeExecute: "Inference" }
+  };
+  const contract = {
+    contract_type: "Active",
+    guardians: params.guardians,
+    compute: computeStep,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
 }
 
 // src/compute/participants.ts
-import bs583 from "bs58";
+import bs582 from "bs58";
 async function getGuardianParticipants() {
   const api2 = await getApi();
   if (!api2) throw new Error("Api not initialized");
@@ -1275,8 +1607,8 @@ async function getGuardianParticipants() {
     const currentEra = await api2.query.staking.currentEra();
     const currentIndex = await api2.query.guardian.currentIndex();
     const peerid = await api2.rpc.system.localPeerId();
-    const _peerid = bs583.decode((peerid || "").toString());
-    const account = await api2.query.guardian.worker(_peerid.slice(0, 32));
+    const _peerid = bs582.decode((peerid || "").toString());
+    const account = await api2.query.guardian.workerByKey(_peerid.slice(6, 38));
     const nextIndex = currentIndex ? Number(currentIndex) + 1 : 1;
     const guardiansList = guardians?.toJSON() || [];
     const nextGuardiansList = nextGuardians?.toJSON() || [];
@@ -1327,6 +1659,35 @@ async function getGuardianParticipants() {
   }
 }
 
+// src/compute/simple.ts
+async function simpleCompute(params, account) {
+  const plaintextCipher = "Plaintext";
+  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: params.trustIndex ?? 0 },
+    fee_function: null,
+    input: null,
+    program: {
+      Url: {
+        url: Array.from(new TextEncoder().encode(params.programUrl))
+      }
+    }
+  };
+  const contract = {
+    contract_type: "Active",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
+}
+
 // src/crypto/random.ts
 function generateRandomBytes(length = 32) {
   const bytes = new Uint8Array(length);
@@ -1349,6 +1710,7 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
   const ownerBytes = Array.from(encoder.encode(l2Owner));
   const api2 = await getApi();
   assert(api2, "Failed to get API connection");
+  debugLog(`Registering metadata for ${name} at ${formatPaliAmount(price)}`);
   const request = api2.tx.dataAvailability.daccRegisterData(
     nameBytes,
     descriptionBytes,
@@ -1362,6 +1724,78 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
   debugLog(`Metadata registration transaction sent with hash: ${hash.hash}`);
   return hash;
 }
+async function registerDataAgreement(account, params) {
+  debugLog(
+    `Registering data agreement for DA ref ${params.ref.blockNumber}-${params.ref.index} at ${formatPaliAmount(params.fees)}`
+  );
+  const cipher = params.cipher ?? "Plaintext";
+  const resultCipher = params.resultCipher ?? "Plaintext";
+  const encoder = new TextEncoder();
+  const computeMetadata = params.metadata ? {
+    name: Array.from(encoder.encode(params.metadata.name)),
+    description: Array.from(encoder.encode(params.metadata.description)),
+    store_type: params.metadata.storeType,
+    group_id: params.metadata.groupId
+  } : null;
+  const computeStep = {
+    cipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: params.fees,
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: params.trustIndex ?? 0 },
+    fee_function: null,
+    input: {
+      ChainTransaction: {
+        block_number: params.ref.blockNumber,
+        extrinsic_index: params.ref.index
+      }
+    },
+    program: {
+      NativeData: "DaFalse"
+    },
+    metadata: computeMetadata
+  };
+  const contract = {
+    contract_type: "Dormant",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: resultCipher
+  };
+  return createAgreement(contract, account);
+}
+
+// src/da/runAgent.ts
+async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes, tauParams, baseModel, publicKey, guardians, guardian, agreementId) {
+  const agentRefTuple = [agentRef.blockNumber, agentRef.index];
+  const baseModelTuple = [baseModel.blockNumber, baseModel.index];
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = api2.tx.dataAvailability.daccRunAgent(
+    agentRefTuple,
+    Array.from(nonce),
+    Array.from(ciphertext),
+    guardian ? Array.from(guardian) : null,
+    Array.from(tdParams),
+    Array.from(pkBytes),
+    Array.from(tauParams),
+    baseModelTuple,
+    Array.from(publicKey),
+    guardians.map((g) => Array.from(g))
+  );
+  const opts = {
+    compute: {
+      da_type: 4,
+      verification: 0,
+      compute: 1,
+      agreement: [agreementId]
+    }
+  };
+  const hash = await signAndSend(request, account, opts);
+  debugLog(`Run agent transaction sent with hash: ${hash.hash}`);
+  return hash;
+}
 
 // src/da/submit.ts
 async function submitData(account, data) {
@@ -1395,11 +1829,76 @@ async function submitTEData(account, data, chosenGuardians, tau_params, agg_key,
   debugLog(`TE data availability transaction sent with hash: ${hash.hash}`);
   return hash;
 }
+async function submitTEDataWithCipher(account, data, chosenGuardians, tau_params, agg_key, group_pk) {
+  const { encoded: encryptedKey, ikm } = testCrypt(tau_params, agg_key);
+  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 ciphertextHex = "0x" + Array.from(ciphertext).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = await api2.tx.dataAvailability.submitData(ciphertextHex);
+  const ref = await signAndSend(request, account, DEFAULT_EMPTY_PAYLOAD);
+  debugLog(`TE data availability transaction sent with hash: ${ref.hash}`);
+  return {
+    ref,
+    cipher: {
+      ThresholdHybrid: {
+        threshold_params: {
+          SilentThreshold: {
+            td_params: Array.from(hexToUint8Array(encryptedKey)),
+            pk_bytes: Array.from(hexToUint8Array(group_pk)),
+            tau_params: Array.from(hexToUint8Array(tau_params))
+          }
+        },
+        symmetric_params: {
+          ChaCha20Poly1305: { nonce: Array.from(nonce) }
+        }
+      }
+    }
+  };
+}
 
 // src/da/upload.ts
 import fs from "fs";
 import path from "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"
+  );
+  console.log("Guardian group info:", guardianGroupInfo);
+  const account = (await getKeyring()).pairs[0];
+  const atomicPrice = toAtomicPaliAmount(price);
+  if (filePath) {
+    throw new Error("uploadData: file path upload is not implemented");
+  } else {
+    const storeType = type === "model" ? "Model" : type === "agent" ? "Agent" : "Dataset";
+    const { ref: dataRef, cipher } = await submitTEDataWithCipher(
+      account,
+      ref || "",
+      guardianGroupInfo.guardians,
+      guardianGroupInfo.tauParams,
+      guardianGroupInfo.aggKey,
+      guardianGroupInfo.groupPk
+    );
+    await registerDataAgreement(account, {
+      ref: dataRef,
+      guardians: guardianGroupInfo.guardians,
+      fees: atomicPrice,
+      cipher,
+      metadata: {
+        name,
+        description,
+        storeType,
+        groupId: guardianGroupInfo.groupId
+      }
+    });
+  }
+}
+async function uploadDataLegacy(options) {
   const { name, description, price, type, guardianGroupInfo, ref, filePath } = options;
   assert(
     guardianGroupInfo.guardians && guardianGroupInfo.tauParams && guardianGroupInfo.aggKey && guardianGroupInfo.groupPk,
@@ -1407,6 +1906,7 @@ async function uploadData(options) {
   );
   const account = (await getKeyring()).pairs[0];
   const ethAddress = "";
+  const atomicPrice = toAtomicPaliAmount(price);
   if (type === "dataset" && filePath) {
     const fileContent = fs.readFileSync(filePath);
     const selectedFile = new File([fileContent], path.basename(filePath), {
@@ -1419,7 +1919,7 @@ async function uploadData(options) {
         fileName: selectedFile.name,
         filePath: "",
         description,
-        baseCost: BigInt(Number(price) * 10 ** 18),
+        baseCost: atomicPrice,
         ownerL2Address: ethAddress,
         guardianInfo: guardianGroupInfo
       },
@@ -1452,12 +1952,12 @@ async function uploadData(options) {
 }
 
 // src/stake/add.ts
-async function addStake(account, amount) {
+async function addStake(account, amountBaseUnits) {
   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);
+  debugLog("Using account:", account.address, "adding:", formatPaliAmount(amountBaseUnits));
+  const stakeTx = api2.tx.staking.bondExtra(amountBaseUnits);
   const hash = await signAndSend(stakeTx, account);
   debugLog(`Stake transaction sent with hash: ${hash.hash}`);
 }
@@ -1473,14 +1973,14 @@ async function joinIdleStaker(account) {
 }
 
 // src/stake/new.ts
-async function newStake(account, amount, rewardDestination = "Staked") {
+async function newStake(account, amountBaseUnits, 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}`
+    `Staking amount: ${formatPaliAmount(amountBaseUnits)} for account: ${account.address} with reward destination: ${rewardDestination}`
   );
-  const stakeTx = api2.tx.staking.bond(amount, rewardDestination);
+  const stakeTx = api2.tx.staking.bond(amountBaseUnits, rewardDestination);
   const hash = await signAndSend(stakeTx, account);
   debugLog(`Stake transaction sent with hash: ${hash.hash}`);
 }
@@ -1502,12 +2002,12 @@ async function payoutStake(account, eras, address) {
 }
 
 // src/stake/reduce.ts
-async function reduceStake(account, amount) {
+async function reduceStake(account, amountBaseUnits) {
   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);
+  debugLog("Using account:", account.address, "reducing:", formatPaliAmount(amountBaseUnits));
+  const unstakeTx = api2.tx.staking.unbond(amountBaseUnits);
   const hash = await signAndSend(unstakeTx, account);
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
 }
@@ -1518,7 +2018,7 @@ async function removeStake(account) {
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
   const stakeAmount = (await api2.query.staking.ledger(account.address))?.toPrimitive();
-  debugLog("Removing entire stake amount:", stakeAmount?.active || 0n);
+  debugLog("Removing entire stake amount:", formatPaliAmount(stakeAmount?.active || 0n));
   const unstakeTx = api2.tx.staking.unbond(stakeAmount?.active || 0n);
   const hash = await signAndSend(unstakeTx, account);
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
@@ -1535,25 +2035,25 @@ async function withdrawStake(account) {
 }
 
 // src/token/fund.ts
-async function fundAccount(account, amount, address) {
+async function fundAccount(account, amountBaseUnits, 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);
+Funding account: ${addr} with amount: ${formatPaliAmount(amountBaseUnits)}`);
+  const tx = api2.tx.balances.transferKeepAlive(addr, amountBaseUnits);
   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) {
+async function transfer(account, amountBaseUnits, 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);
+Transferring funds to account: ${address} with amount: ${formatPaliAmount(amountBaseUnits)}`);
+  const tx = api2.tx.balances.transferKeepAlive(address, amountBaseUnits);
   const hash = await signAndSend(tx, account);
   debugLog(`Transfer transaction sent with hash: ${hash.hash}`);
 }
@@ -1581,7 +2081,7 @@ Setting identity for account: ${account.address} as ${display}`);
 }
 
 // src/rotateKeys.ts
-import bs584 from "bs58";
+import bs583 from "bs58";
 import assert3 from "assert";
 async function rotateAndSetKeys(account) {
   const api2 = await getApi();
@@ -1596,8 +2096,8 @@ async function rotateAndSetKeys(account) {
 async function setWorker(account) {
   const api2 = await getApi();
   assert3(api2, "API not initialized");
-  const peerid = bs584.decode((await api2.rpc.system.localPeerId()).toString());
-  const setWorkerTx = api2.tx.guardian.setWorker(peerid.slice(0, 32));
+  const peerid = bs583.decode((await api2.rpc.system.localPeerId()).toString());
+  const setWorkerTx = api2.tx.guardian.setWorker(peerid.slice(6, 38));
   const hash = await signAndSend(setWorkerTx, account);
   debugLog(`Set worker id transaction sent with hash: ${hash.hash}`);
 }
@@ -1622,9 +2122,10 @@ export {
   MCryptFs,
   MCryptFsReader,
   MCryptFsWriter,
+  PALI_DECIMALS,
+  PALI_SYMBOL,
   PALLIORA_RPC_URL,
   PALLIORA_WS,
-  RpcApi,
   TX_WAIT_FINALIZATION,
   WsProvider3 as WsProvider,
   addStake,
@@ -1634,6 +2135,9 @@ export {
   createAccount,
   createAgreement,
   createGuardianGroup,
+  createGuardianGroupAndWatch,
+  createSimpleAgreement,
+  dataContract,
   debugLog,
   decodeAggregateKey,
   decodeField,
@@ -1642,12 +2146,16 @@ export {
   encrypt as ecncryptTest,
   encodeCiphertext,
   encrypt2 as encrypt,
+  fetchAndDecodeExtrinsic,
   fetchTokenProperties,
   formatBalanceWithTokenProperties,
+  formatPaliAmount,
+  fromAtomicPaliAmount,
   fundAccount,
   gen_shared_key,
   gen_stretched_key,
   generateRandomBytes,
+  getAgreementCreatedRequestId,
   getApi,
   getCachedTokenProperties,
   getEncKeyring,
@@ -1657,8 +2165,8 @@ export {
   getGuardianNwParams,
   getGuardianParticipants,
   getKeyring,
-  getRpcApi,
   hexToUint8Array,
+  inferenceCompute,
   joinGuardian,
   joinIdleStaker,
   joinValidator,
@@ -1667,20 +2175,28 @@ export {
   payoutStake,
   provider,
   reduceStake,
+  registerDataAgreement,
   removeStake,
   rotateAndSetKeys,
+  runAgent,
+  scanForBlockEvent,
   setIdentity,
   setWorker,
   signAndSend,
+  simpleCompute,
   submitData,
   submitTEData,
+  submitTEDataWithCipher,
   testCrypt,
+  toAtomicPaliAmount,
   tokenToBigint,
   transfer,
   uint8ArrayToBase64,
   uploadData,
+  uploadDataLegacy,
   utilCrypto,
   wasmCrypto,
+  watchForSubmissionReceipt,
   withdrawStake,
   writeMetadata
 };