@palliora.org/chainsdk 0.3.3 → 0.5.0

package/dist/index.js

@@ -71,6 +71,9 @@ async function createAccount(input, type, name = "default", cryptoType = "sr2551
       throw new Error("Invalid input type");
   }
 }
+async function createAccountFromMagicLink(signature, name = "default", cryptoType = "sr25519" /* SR25519 */) {
+  return createAccount(signature, "derived" /* DERIVED */, name, cryptoType);
+}
 function pairFromPrivateKeyHex(privateKeyHex, cryptoType) {
   const privateKey = hexToU8a(privateKeyHex);
   switch (cryptoType) {
@@ -201,6 +204,13 @@ var API_TYPES = {
     active: "u32",
     maximum: "u32"
   },
+  CurrencyId: {
+    _enum: {
+      Native: "Null",
+      USDC: "Null",
+      ForeignAsset: "u32"
+    }
+  },
   GuardianNwParams: {
     kzg: "Vec<u8>",
     aggKey: "Vec<u8>"
@@ -372,9 +382,15 @@ var API_TYPES = {
   StoreType: {
     _enum: {
       Dataset: "Null",
+      // 0
       Model: "Null",
+      // 1
       Agent: "Null",
+      // 2
+      Executable: "Null",
+      // 3
       Other: "Null"
+      // 4
     }
   },
   ComputeMetadata: {
@@ -402,7 +418,8 @@ var API_TYPES = {
     preCheck: "Option<ComputeInfo>",
     compute: "ComputeInfo",
     postCheck: "Option<ComputeInfo>",
-    resultCipher: "CipherSuite"
+    resultCipher: "CipherSuite",
+    currencyId: "CurrencyId"
   },
   AgreementInfo: {
     status: "AgreementStatus",
@@ -422,13 +439,16 @@ var API_TYPES = {
     fhe: "bool",
     zkp: "bool"
   },
+  ComputeType: {
+    _enum: ["Trusted", "Tee", "Mpc", "Fhe", "Zkp"]
+  },
   GuardianPrefs: {
     pubKey: "[u8; 32]",
     guardian: "bool",
     verifier: "bool",
     compute: "bool",
     computePrefs: "Option<ComputePrefs>",
-    feeThreshold: "u128"
+    feeThresholds: "Vec<(ComputeType, u128)>"
   },
   BlockLengthColumns: "Compact<u32>",
   BlockLengthRows: "Compact<u32>",
@@ -538,6 +558,18 @@ var API_EXTENSIONS = {
       compute: "ComputePayload"
     },
     payload: {}
+  },
+  // Replaces pallet_transaction_payment::ChargeTransactionPayment. Since this
+  // identifier isn't one @polkadot/api knows natively, this definition entirely
+  // replaces (not merges with) the built-in one, so `tip` must be re-declared
+  // here alongside the new `currencyId` field or it silently drops from the
+  // encoded extra bytes, shifting every extrinsic out of alignment.
+  ChargeCurrencyTransactionPayment: {
+    extrinsic: {
+      tip: "Compact<Balance>",
+      currencyId: "Option<CurrencyId>"
+    },
+    payload: {}
   }
 };
 
@@ -827,18 +859,49 @@ function assert(condition, message) {
 
 // src/config.ts
 import { WsProvider } from "@polkadot/api";
-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;
-var provider = new WsProvider(PALLIORA_WS, 1e4);
-function configure(opts) {
-  if (opts.pallioraWs !== void 0) PALLIORA_WS = opts.pallioraWs;
-  if (opts.pallioraRpcUrl !== void 0) PALLIORA_RPC_URL = opts.pallioraRpcUrl;
-  if (opts.debug !== void 0) DEBUG = opts.debug;
-  if (opts.txWaitFinalization !== void 0) TX_WAIT_FINALIZATION = opts.txWaitFinalization;
-  provider = new WsProvider(PALLIORA_WS, 1e4);
+var config = null;
+var cachedProvider = null;
+var cachedProviderUrl = null;
+function init(options) {
+  config = { ...config, ...options };
+}
+function isInitialized() {
+  return config !== null;
+}
+function resetConfig() {
+  config = null;
+  cachedProvider = null;
+  cachedProviderUrl = null;
+}
+function read(key) {
+  if (!config) {
+    throw new Error(
+      `Palliora SDK is not initialized: cannot read "${key}". Call init({ ${key}: ... }) before using the SDK.`
+    );
+  }
+  const value = config[key];
+  if (value === void 0) {
+    throw new Error(
+      `Palliora SDK config "${key}" is not set. Pass it to init({ ${key}: ... }).`
+    );
+  }
+  return value;
+}
+var getPallioraWs = () => read("pallioraWs");
+var getPallioraRpcUrl = () => read("pallioraRpcUrl");
+var getCostEstimatorUrl = () => read("costEstimatorUrl");
+var getAuthServiceUrl = () => read("authServiceUrl");
+var getAwsRegion = () => read("awsRegion");
+var getAwsS3Bucket = () => read("awsS3Bucket");
+var isDebug = () => config?.debug ?? false;
+var waitsForFinalization = () => config?.txWaitFinalization ?? false;
+function getProvider() {
+  const url = getPallioraWs();
+  if (!cachedProvider || cachedProviderUrl !== url) {
+    cachedProvider = new WsProvider(url, 1e4);
+    cachedProviderUrl = url;
+  }
+  return cachedProvider;
 }
 
 // src/utils/helper.ts
@@ -886,7 +949,7 @@ var decodeField = (field, expectedLength) => {
   return bytes;
 };
 var debugLog = (message, ...optionalParams) => {
-  if (DEBUG) {
+  if (isDebug()) {
     console.log(message, ...optionalParams);
   }
 };
@@ -948,8 +1011,8 @@ var encKeyring = null;
 var apiListenersAttached = false;
 var apiTeardownInProgress = false;
 async function getApi(cb) {
-  if (!provider) return;
-  if (api && PALLIORA_WS !== apiUrl) {
+  const pallioraWs = getPallioraWs();
+  if (api && pallioraWs !== apiUrl) {
     const staleApi = api;
     api = null;
     apiUrl = null;
@@ -960,12 +1023,12 @@ async function getApi(cb) {
   }
   if (!api) {
     api = await ApiPromise.create({
-      provider,
+      provider: getProvider(),
       rpc: API_RPC,
       types: API_TYPES,
       signedExtensions: API_EXTENSIONS
     });
-    apiUrl = PALLIORA_WS;
+    apiUrl = pallioraWs;
   }
   const isNode = typeof process !== "undefined" && typeof process.exit === "function";
   const isTest = typeof process !== "undefined" && process.env?.NODE_ENV === "test";
@@ -991,6 +1054,16 @@ async function getApi(cb) {
   }
   return api;
 }
+async function disconnectApi() {
+  if (!api) return;
+  const current = api;
+  api = null;
+  apiUrl = null;
+  apiListenersAttached = false;
+  apiTeardownInProgress = false;
+  await current.disconnect().catch(() => {
+  });
+}
 async function getKeyring() {
   if (!keyring) {
     await waitReady2();
@@ -1013,6 +1086,7 @@ import { isFunction as isFunction2 } from "@polkadot/util";
 import bs58 from "bs58";
 
 // src/guardian/active.ts
+import { waitReady as waitReady3 } from "@polkadot/wasm-crypto";
 import { isFunction } from "@polkadot/util";
 var getGuardianList = async () => {
   const api2 = await getApi();
@@ -1027,6 +1101,26 @@ var getGuardianList = async () => {
   const list = (await rpc[section]["guardianList"]()).map((item) => [item.toString()]).flat(1);
   return list;
 };
+async function getActiveGuardians(apiInstance) {
+  await waitReady3();
+  const api2 = apiInstance ?? await getApi();
+  if (!api2) throw new Error("API not initialized");
+  const guardians = await api2.query.guardian.guardians();
+  const accounts = guardians?.toJSON() || [];
+  return Promise.all(
+    accounts.map(async (account) => {
+      const [prefs, ledger] = await Promise.all([
+        api2.query.staking.guardians(account),
+        api2.query.staking.ledger(account)
+      ]);
+      return {
+        account,
+        guardianPrefs: prefs?.toHuman?.() ?? null,
+        stakersOverview: ledger?.toHuman?.() ?? null
+      };
+    })
+  );
+}
 
 // src/guardian/group.ts
 var createGuardianGroup = async (account, selectedGuardians) => {
@@ -1087,32 +1181,125 @@ var createGuardianGroupAndWatch = async (account, guardians, maxBlocks = 20) =>
     guardians
   };
 };
+async function findGuardianGroupInfoExtrinsic(api2, startBlock, maxBlocks) {
+  const tip = (await api2.rpc.chain.getHeader()).number.toNumber();
+  const endBlock = maxBlocks > 0 ? Math.min(startBlock + maxBlocks - 1, tip) : tip;
+  for (let blockNumber = startBlock; blockNumber <= endBlock; blockNumber++) {
+    const blockHash = await api2.rpc.chain.getBlockHash(blockNumber);
+    const signedBlock = await api2.rpc.chain.getBlock(blockHash);
+    const extrinsics = signedBlock.block.extrinsics;
+    for (let index = 0; index < extrinsics.length; index++) {
+      const ext = extrinsics[index];
+      if (ext?.method?.section?.toLowerCase() === "dataavailability" && ext?.method?.method?.toLowerCase() === "daccguardiangroupinfo") {
+        return { blockNumber, index };
+      }
+    }
+  }
+  throw new Error(
+    `No daccGuardianGroupInfo extrinsic found in blocks ${startBlock}-${endBlock} (searched ${Math.max(endBlock - startBlock + 1, 0)} block(s) after the creation extrinsic)`
+  );
+}
+var getGuardianGroupInfo = async (creationRef, resultRef, maxBlocks = 20) => {
+  assert(creationRef, "Group creation extrinsic reference is required");
+  const api2 = await getApi();
+  assert(api2, "Failed to initialize API");
+  debugLog(`Reading guardian group creation extrinsic at block ${creationRef.blockNumber}, index ${creationRef.index}...`);
+  const { raw: creationExt } = await fetchAndDecodeExtrinsic(creationRef.blockNumber, creationRef.index);
+  assert(
+    creationExt?.method?.section?.toLowerCase() === "dataavailability" && creationExt?.method?.method?.toLowerCase() === "daccguardiangroup",
+    `Extrinsic at block ${creationRef.blockNumber}, index ${creationRef.index} is not a daccGuardianGroup call (found ${creationExt?.method?.section}.${creationExt?.method?.method})`
+  );
+  const [selectedGuardiansArg] = creationExt.method.args;
+  const guardians = Array.from(selectedGuardiansArg).map((g) => g.toString());
+  debugLog(`Guardian group creation extrinsic decoded: guardians=${guardians.join(", ")}`);
+  const resolvedResultRef = resultRef ?? await (async () => {
+    debugLog(
+      `No result extrinsic reference given, scanning forward from block ${creationRef.blockNumber + 1} for daccGuardianGroupInfo...`
+    );
+    return findGuardianGroupInfoExtrinsic(api2, creationRef.blockNumber + 1, maxBlocks);
+  })();
+  debugLog(`Reading guardian group result extrinsic at block ${resolvedResultRef.blockNumber}, index ${resolvedResultRef.index}...`);
+  const { raw: resultExt } = await fetchAndDecodeExtrinsic(resolvedResultRef.blockNumber, resolvedResultRef.index);
+  assert(
+    resultExt?.method?.section?.toLowerCase() === "dataavailability" && resultExt?.method?.method?.toLowerCase() === "daccguardiangroupinfo",
+    `Extrinsic at block ${resolvedResultRef.blockNumber}, index ${resolvedResultRef.index} is not a daccGuardianGroupInfo call (found ${resultExt?.method?.section}.${resultExt?.method?.method})`
+  );
+  const [group_id, group_pk, tau_params, agg_key] = resultExt.method.args;
+  debugLog(`Guardian group result extrinsic 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
+var COMPUTE_TYPES = ["trusted", "tee", "mpc", "fhe", "zkp"];
+var CHAIN_COMPUTE_TYPE = {
+  trusted: "Trusted",
+  tee: "Tee",
+  mpc: "Mpc",
+  fhe: "Fhe",
+  zkp: "Zkp"
+};
+function parseComputeTypes(compute) {
+  const requested = (compute || "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return COMPUTE_TYPES.filter((type) => requested.includes(type));
+}
+function buildFeeThresholds(fee, computeTypes) {
+  if (fee === void 0 || fee === null || fee === "") {
+    return [];
+  }
+  if (typeof fee !== "object") {
+    assert(
+      computeTypes.length > 0,
+      "A single fee threshold needs compute preferences to apply to. Set compute preferences, or declare thresholds per compute type."
+    );
+    return computeTypes.map((type) => [CHAIN_COMPUTE_TYPE[type], BigInt(fee)]);
+  }
+  return Object.entries(fee).map(([type, amount]) => {
+    assert(
+      COMPUTE_TYPES.includes(type),
+      `Unknown compute type "${type}" in fee thresholds. Allowed: ${COMPUTE_TYPES.join(", ")}`
+    );
+    assert(
+      computeTypes.includes(type),
+      `Fee threshold declared for "${type}", which is not among the compute preferences (${computeTypes.join(", ") || "none"})`
+    );
+    return [CHAIN_COMPUTE_TYPE[type], BigInt(amount)];
+  });
+}
 async function joinGuardian(account, prefs) {
   const api2 = await getApi();
   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 computeTypes = parseComputeTypes(prefs.compute);
+  const feeThresholds = buildFeeThresholds(prefs.fee, computeTypes);
   const guardianPrefs = {
     pubKey: account.publicKey,
     guardian: prefs.standard,
     verifier: prefs.verifier,
     compute: prefs.compute ? true : false,
     computePrefs: {
-      trusted: computeOpts?.includes("trusted") || false,
-      tee: computeOpts?.includes("tee") || false,
-      mpc: computeOpts?.includes("mpc") || false,
-      fhe: computeOpts?.includes("fhe") || false,
-      zkp: computeOpts?.includes("zkp") || false
+      trusted: computeTypes.includes("trusted"),
+      tee: computeTypes.includes("tee"),
+      mpc: computeTypes.includes("mpc"),
+      fhe: computeTypes.includes("fhe"),
+      zkp: computeTypes.includes("zkp")
     },
-    feeThreshold
+    feeThresholds
   };
   debugLog(
     account.address,
     "joining as guardian with preferences:",
-    { ...guardianPrefs, feeThreshold: formatPaliAmount(feeThreshold) }
+    {
+      ...guardianPrefs,
+      feeThresholds: feeThresholds.map(
+        ([type, threshold]) => `${type}: ${formatPaliAmount(threshold)}`
+      )
+    }
   );
   const guardTx = api2.tx.staking.guard(guardianPrefs);
   const hash = await signAndSend(guardTx, account);
@@ -1120,13 +1307,14 @@ async function joinGuardian(account, prefs) {
 }
 
 // src/chain/utils.ts
-var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
+var signAndSend = async (request2, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
+  const signOpts = { currencyId: null, ...opts };
   const tx_result = await new Promise((res, err) => {
-    request.signAndSend(account, opts, (result) => {
+    request2.signAndSend(account, signOpts, (result) => {
       if (result.isFinalized) {
         res(result);
       }
-      if (!TX_WAIT_FINALIZATION && result.isInBlock) {
+      if (!waitsForFinalization() && result.isInBlock) {
         res(result);
       }
       if (result.isError) err(result);
@@ -1150,6 +1338,21 @@ var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
     tx_result
   };
 };
+var retrySignAndSend = async (request2, account, opts, retries = 3, backoffMs = 1e3) => {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await signAndSend(request2, account, opts);
+    } catch (err) {
+      lastError = err;
+      if (attempt === retries) break;
+      const delay = backoffMs * 2 ** attempt;
+      debugLog(`retrySignAndSend: attempt ${attempt + 1} failed, retrying in ${delay}ms`, err);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+};
 var getFileMetadataCall = async (api2, metadataRef) => {
   const block = await getBlock(api2, metadataRef[0]);
   const call = block.block.extrinsics[metadataRef[1]];
@@ -1197,6 +1400,26 @@ var getGuardianNwParams = async () => {
     throw error;
   }
 };
+async function getContractInfo(contractId) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  assert(
+    isFunction2(api2.query["compute"]?.["contracts"]),
+    `api.query.compute.contracts does not exist`
+  );
+  const raw = await api2.query["compute"]["contracts"](contractId);
+  const info = raw.toPrimitive();
+  if (!info) return null;
+  return {
+    status: info.status,
+    owner: info.owner,
+    originBlock: info.originBlock,
+    invocationBlock: info.invocationBlock,
+    index: info.index,
+    usagePrice: BigInt(info.usagePrice),
+    contractType: info.contractType
+  };
+}
 async function fetchAndDecodeExtrinsic(blockHeight, extrinsicIndex) {
   const api2 = await getApi();
   if (!api2) throw new Error("API not initialized");
@@ -1212,6 +1435,11 @@ async function fetchAndDecodeExtrinsic(blockHeight, extrinsicIndex) {
   const decoded = raw.toHuman();
   return { raw, decoded };
 }
+function findEvent(events, section, method) {
+  return events.find(
+    (record) => record.event.section.toLowerCase() === section.toLowerCase() && record.event.method.toLowerCase() === method.toLowerCase()
+  );
+}
 var scanForBlockEvent = (api2, filter, startBlock, maxBlocks = 20) => {
   const hasPredicate = "predicate" in filter;
   let blocksScanned = 0;
@@ -1256,6 +1484,28 @@ var scanForBlockEvent = (api2, filter, startBlock, maxBlocks = 20) => {
     );
   });
 };
+async function waitForNextBlock() {
+  const api2 = await getApi();
+  if (!api2) throw new Error("API not initialized");
+  return new Promise((resolve, reject) => {
+    let unsubFn;
+    let settled = false;
+    api2.rpc.chain.subscribeNewHeads((header) => {
+      if (settled) return;
+      settled = true;
+      unsubFn?.();
+      resolve({ blockNumber: header.number.toNumber(), blockHash: header.hash.toHex() });
+    }).then((fn) => {
+      if (settled) fn();
+      else unsubFn = fn;
+    }).catch((err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+  });
+}
 async function watchForSubmissionReceipt(requestId, timeoutMs = 10 * 60 * 1e3) {
   const api2 = await getApi();
   if (!api2) throw new Error("API not initialized");
@@ -1321,22 +1571,18 @@ async function getAgreementCreatedRequestId(blockHeight, extrinsicIndex) {
   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);
-    }
+  const extrinsicEvents = allEvents.filter(
+    (record) => record.phase.isApplyExtrinsic && record.phase.asApplyExtrinsic.toNumber() === extrinsicIndex
+  );
+  const match = findEvent(extrinsicEvents, "compute", "AgreementCreated");
+  if (!match) return null;
+  const dataHuman = match.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;
 }
@@ -1437,12 +1683,12 @@ var MCryptFsWriter = class {
     return new Blob([blockNumberBuffer, extIndexBuffer, chunk]);
   }
   async writeChunk(chunk) {
-    const request = this._api.tx.dataAvailability.submitData(
+    const request2 = 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) => {
+      request2.signAndSend(this._account, { app_id: 1, currencyId: null }, (result) => {
         if (result.isInBlock || result.isFinalized || result.isError) {
           resolve({
             blockNumber: result.blockNumber?.toNumber() ?? 0,
@@ -1472,15 +1718,15 @@ var MCryptFsWriter = class {
       chosen_guardians: this._guardianInfo.guardians,
       blobRef: [blobRef.blockNumber, blobRef.extrinsicIndex]
     });
-    const request = this._api.tx.dataAvailability.submitData(modelSubmit);
-    return await signAndSend(request, account);
+    const request2 = this._api.tx.dataAvailability.submitData(modelSubmit);
+    return await signAndSend(request2, 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(
+    const request2 = this._api.tx.dataAvailability.daccRegisterData(
       Array.from(new TextEncoder().encode(fileName)),
       Array.from(new TextEncoder().encode(this._description)),
       keyRef,
@@ -1489,7 +1735,7 @@ var MCryptFsWriter = class {
       Array.from(encoder.encode(this._ownerL2Address)),
       this._guardianInfo.groupId
     );
-    return await signAndSend(request, this._account);
+    return await signAndSend(request2, this._account);
   }
   async writeFile() {
     const chunks = [];
@@ -1556,6 +1802,90 @@ var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
   return new MCryptFs(mcryptApi, metadataRef, metadata);
 };
 
+// src/chain/blocks.ts
+import { waitReady as waitReady4 } from "@polkadot/wasm-crypto";
+async function getLatestBlocks(count, page = 0, apiInstance) {
+  await waitReady4();
+  const api2 = apiInstance ?? await getApi();
+  if (!api2) throw new Error("API not initialized");
+  const header = await api2.rpc.chain.getHeader();
+  const latestHeight = header.number.toNumber();
+  const start = latestHeight - page * count;
+  if (start < 0) {
+    return { blocks: [], latestHeight };
+  }
+  const heights = [];
+  for (let height = start; height >= Math.max(0, start - count + 1); height -= 1) {
+    heights.push(height);
+  }
+  const blocks = await Promise.all(
+    heights.map(async (height) => {
+      const hash = await api2.rpc.chain.getBlockHash(height);
+      const [signed, derived, at] = await Promise.all([
+        api2.rpc.chain.getBlock(hash),
+        api2.derive.chain.getHeader(hash).catch(() => null),
+        api2.at(hash)
+      ]);
+      const [timestamp, events] = await Promise.all([
+        at.query.timestamp.now(),
+        at.query.system.events()
+      ]);
+      return {
+        height,
+        hash: hash.toHex(),
+        time: Number(timestamp.toString()),
+        validator: derived?.author?.toString?.() ?? "",
+        extrinsicsCount: signed.block.extrinsics.length,
+        eventsCount: events.length
+      };
+    })
+  );
+  return { blocks, latestHeight };
+}
+
+// src/token/balance.ts
+async function getBalance(address) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  const account = (await api2.query.system.account(address)).toPrimitive();
+  const free = BigInt(account.data.free);
+  const reserved = BigInt(account.data.reserved);
+  const frozen = BigInt(account.data.frozen);
+  return {
+    free,
+    reserved,
+    frozen,
+    formatted: await formatBalanceWithTokenProperties(free)
+  };
+}
+
+// src/account/info.ts
+function extractDisplayName(display) {
+  if (!display || display === "None") return null;
+  if (typeof display === "string") return display;
+  if (typeof display === "object" && "Raw" in display) {
+    return String(display.Raw);
+  }
+  return null;
+}
+async function getAccountInfo(address) {
+  const api2 = await getApi();
+  assert(api2, "API not initialized");
+  const [accountData, balance, identity] = await Promise.all([
+    api2.query.system.account(address),
+    getBalance(address),
+    api2.query.identity.identityOf(address)
+  ]);
+  const nonce = accountData.toPrimitive().nonce;
+  const identityHuman = identity.toHuman();
+  return {
+    address,
+    nonce,
+    balance,
+    displayName: extractDisplayName(identityHuman?.info?.display)
+  };
+}
+
 // src/compute/agreement.ts
 function buildFee(fee) {
   return {
@@ -1563,10 +1893,22 @@ function buildFee(fee) {
     computeRate: toAtomicPaliAmount(fee?.computeRate ?? "0")
   };
 }
+var NO_GUARDIAN_GROUP = `0x${"00".repeat(32)}`;
+function buildComputeMetadata(metadata) {
+  if (!metadata) return null;
+  const encoder = new TextEncoder();
+  return {
+    name: Array.from(encoder.encode(metadata.name)),
+    description: Array.from(encoder.encode(metadata.description)),
+    storeType: metadata.storeType,
+    groupId: metadata.groupId ?? NO_GUARDIAN_GROUP
+  };
+}
 async function createAgreement(contract, account, oracle_quore_id = void 0) {
   const api2 = await getApi();
   if (!api2) throw new Error("Api not initialized");
-  const tx = api2.tx["compute"]["agreement"](contract, oracle_quore_id ?? null);
+  const onChainContract = { currencyId: "Native", ...contract };
+  const tx = api2.tx["compute"]["agreement"](onChainContract, oracle_quore_id ?? null);
   const opts = {
     compute: {
       daType: 1,
@@ -1580,11 +1922,7 @@ async function createAgreement(contract, account, oracle_quore_id = void 0) {
     opts
   );
   if (!tx_result.isError) {
-    const agreementCreatedEvent = tx_result.events.find(
-      (event) => {
-        return event.event.section === "compute" && event.event.method === "AgreementCreated";
-      }
-    );
+    const agreementCreatedEvent = findEvent(tx_result.events, "compute", "AgreementCreated");
     if (agreementCreatedEvent) {
       debugLog("Agreement data:", agreementCreatedEvent.event.data.toString());
       return {
@@ -1599,6 +1937,17 @@ async function createAgreement(contract, account, oracle_quore_id = void 0) {
   }
   return { blockNumber, index: index ?? 0, hash };
 }
+async function invokeAgreement(agreementId, input, account, opts) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("Api not initialized");
+  const tx = api2.tx["compute"]["invoke"](
+    agreementId,
+    input.guardians,
+    input.cipher,
+    { Inline: { data: Array.from(input.data) } }
+  );
+  return signAndSend(tx, account, opts);
+}
 async function createSimpleAgreement() {
   const guardianIds = (await getGuardianAddress()).slice(0, 3).map((g) => g.address);
   assert(guardianIds.length === 3, "Not enough guardians to create agreement");
@@ -1628,6 +1977,17 @@ async function createSimpleAgreement() {
 // src/compute/data.ts
 async function dataContract(params, account) {
   const plaintextCipher = "Plaintext";
+  assert(
+    params.url === void 0 !== (params.data === void 0),
+    "dataContract requires exactly one of `url` or `data`"
+  );
+  const input = params.url !== void 0 ? { Url: { url: Array.from(new TextEncoder().encode(params.url)) } } : {
+    Inline: {
+      data: Array.from(
+        typeof params.data === "string" ? new TextEncoder().encode(params.data) : params.data
+      )
+    }
+  };
   const computeStep = {
     cipher: plaintextCipher,
     computerIndices: params.guardians.map((_, i) => i),
@@ -1635,14 +1995,11 @@ async function dataContract(params, account) {
     deadline: params.deadline ?? 0,
     confidentiality: { Trusted: params.trustIndex ?? 0 },
     feeFunction: null,
-    input: {
-      Url: {
-        url: Array.from(new TextEncoder().encode(params.url))
-      }
-    },
+    input,
     program: {
       NativeData: "DaFalse"
-    }
+    },
+    metadata: buildComputeMetadata(params.metadata)
   };
   const contract = {
     contractType: "Dormant",
@@ -1655,6 +2012,157 @@ async function dataContract(params, account) {
   return createAgreement(contract, account);
 }
 
+// src/compute/fees.ts
+async function readMillisecondsPerBlock() {
+  const api2 = await getApi();
+  assert(api2, "Api not initialized");
+  const expectedBlockTime = api2.consts.babe?.expectedBlockTime;
+  if (expectedBlockTime) {
+    return BigInt(expectedBlockTime.toString());
+  }
+  const minimumPeriod = api2.consts.timestamp?.minimumPeriod;
+  assert(minimumPeriod, "Cannot determine block time: neither babe.expectedBlockTime nor timestamp.minimumPeriod exists");
+  return BigInt(minimumPeriod.toString()) * 2n;
+}
+async function getFeeParams() {
+  const api2 = await getApi();
+  assert(api2, "Api not initialized");
+  assert(
+    api2.query.compute?.maxDaStorageSize,
+    "compute.maxDaStorageSize does not exist on this runtime: the connected chain predates metered compute, and has no fee floor. Check PALLIORA_WS points at a current node."
+  );
+  const [maxDaStorageSize, providerStorageRate, thresholdDecryptionFee, millisecondsPerBlock] = await Promise.all([
+    api2.query.compute.maxDaStorageSize(),
+    api2.query.compute.providerStorageRate(),
+    api2.query.compute.thresholdDecryptionFee(),
+    readMillisecondsPerBlock()
+  ]);
+  return {
+    maxDaStorageSize: BigInt(maxDaStorageSize.toString()),
+    providerStorageRate: BigInt(providerStorageRate.toString()),
+    thresholdDecryptionFee: BigInt(thresholdDecryptionFee.toString()),
+    millisecondsPerBlock
+  };
+}
+async function estimateMinFee(input) {
+  const api2 = await getApi();
+  assert(api2, "Api not initialized");
+  const params = await getFeeParams();
+  const resultFee = params.maxDaStorageSize * params.providerStorageRate;
+  let inputFee = 0n;
+  if (input.inputContractId) {
+    const contract = (await api2.query.compute.contracts(input.inputContractId)).toJSON();
+    if (contract) {
+      inputFee = BigInt(String(contract["usagePrice"] ?? contract["usage_price"] ?? 0));
+    }
+  }
+  const offeredComponent = toAtomicPaliAmount(input.computeRate) * params.millisecondsPerBlock;
+  return {
+    resultFee,
+    inputFee,
+    thresholdDecryptionFee: params.thresholdDecryptionFee,
+    offeredComponent,
+    minFee: resultFee + inputFee + params.thresholdDecryptionFee + offeredComponent
+  };
+}
+
+// src/compute/encryptedInference.ts
+import { edwardsToMontgomeryPub as edwardsToMontgomeryPub2 } from "@noble/curves/ed25519";
+
+// 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/compute/encryptedInference.ts
+async function encryptedInferenceSubscription(params, account) {
+  const computeStep = {
+    cipher: "Plaintext",
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: 0 },
+    feeFunction: null,
+    input: null,
+    program: { NativeExecute: "Inference" }
+  };
+  const contract = {
+    contractType: "Dormant",
+    guardians: params.guardians,
+    preCheck: null,
+    compute: computeStep,
+    postCheck: null,
+    resultCipher: "Plaintext"
+  };
+  return createAgreement(contract, account);
+}
+async function encryptedInferenceSubscriptionInvocation(params, encAccount, account) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("Api not initialized");
+  const inputBytes = typeof params.input === "string" ? new TextEncoder().encode(params.input) : params.input;
+  const { encoded: cyphtxt, ikm } = testCrypt(
+    params.guardianInfo.tauParams,
+    params.guardianInfo.aggKey
+  );
+  const sharedKey = gen_stretched_key(hexToUint8Array(ikm));
+  const { ciphertext, nonce } = encrypt2(inputBytes, sharedKey);
+  const cyphtxtBytes = hexToUint8Array(cyphtxt);
+  const groupPkBytes = hexToUint8Array(params.guardianInfo.groupPk);
+  const tauParamsBytes = hexToUint8Array(params.guardianInfo.tauParams);
+  const tx = api2.tx["dataAvailability"]["daccComputeRequest"](
+    edwardsToMontgomeryPub2(encAccount.publicKey),
+    nonce,
+    Array.from(ciphertext),
+    params.guardians[0],
+    Array.from(cyphtxtBytes),
+    Array.from(groupPkBytes),
+    Array.from(tauParamsBytes),
+    params.guardians
+  );
+  const idHex = params.agreementId.startsWith("0x") ? params.agreementId.slice(2) : params.agreementId;
+  const opts = {
+    compute: {
+      da_type: 4,
+      agreement: [Buffer.from(idHex, "hex")],
+      verification: 0,
+      compute: 1
+    }
+  };
+  return signAndSend(tx, account, opts);
+}
+async function encryptedInferenceCompute(params, encAccount, account) {
+  const subscription = await encryptedInferenceSubscription(
+    {
+      guardians: params.guardians,
+      fee: params.fee,
+      deadline: params.deadline
+    },
+    account
+  );
+  if (!subscription.agreementId) {
+    throw new Error("Subscription creation did not return an agreement ID");
+  }
+  const invocation = await encryptedInferenceSubscriptionInvocation(
+    {
+      agreementId: subscription.agreementId,
+      input: params.input,
+      guardians: params.guardians,
+      guardianInfo: params.guardianInfo
+    },
+    encAccount,
+    account
+  );
+  return { subscription, invocation };
+}
+
 // 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);
@@ -1737,7 +2245,7 @@ async function getGuardianParticipants() {
       upcomingGuardians
     };
   } finally {
-    api2.disconnect();
+    await disconnectApi();
   }
 }
 
@@ -1769,17 +2277,177 @@ async function simpleCompute(params, account) {
   return createAgreement(contract, account);
 }
 
-// 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+)."
-    );
+// src/compute/stored.ts
+async function storedCompute(params, account) {
+  assert(!!params.programContractId, "storedCompute requires a programContractId");
+  assert(!!params.inputContractId, "storedCompute requires an inputContractId");
+  const plaintextCipher = "Plaintext";
+  const computeStep = {
+    cipher: plaintextCipher,
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: params.trustIndex ?? 0 },
+    feeFunction: null,
+    input: { ContractId: { id: params.inputContractId } },
+    program: { ContractId: { id: params.programContractId } },
+    metadata: buildComputeMetadata(params.metadata)
+  };
+  const contract = {
+    contractType: "Active",
+    guardians: params.guardians,
+    preCheck: null,
+    compute: computeStep,
+    postCheck: null,
+    resultCipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
+}
+
+// src/costEstimation/client.ts
+var CostEstimationError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "CostEstimationError";
   }
-  cr.getRandomValues(bytes);
-  return bytes;
+};
+async function request(method, path2, body) {
+  const url = `${getCostEstimatorUrl()}${path2}`;
+  debugLog(`cost estimation service: ${method} ${url}`, body);
+  const res = await fetch(url, {
+    method,
+    headers: body !== void 0 ? { "Content-Type": "application/json" } : void 0,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  const text = await res.text();
+  const data = text ? JSON.parse(text) : void 0;
+  if (!res.ok) {
+    const message = data && typeof data === "object" && "error" in data ? String(data.error) : `cost estimation service returned ${res.status}`;
+    throw new CostEstimationError(message, res.status);
+  }
+  return data;
+}
+var costEstimationClient = {
+  get: (path2) => request("GET", path2),
+  post: (path2, body) => request("POST", path2, body)
+};
+
+// src/costEstimation/estimate.ts
+function toGuardianEntry(raw) {
+  return {
+    address: raw.address,
+    pubKey: raw.pubKey,
+    feeThreshold: BigInt(raw.feeThreshold)
+  };
+}
+function toEstimateResult(raw) {
+  return {
+    predictedDurationMs: raw.predictedDurationMs,
+    auctionedRate: BigInt(raw.auctionedRate),
+    estimatedCost: BigInt(raw.estimatedCost),
+    guardians: raw.guardians.map(toGuardianEntry)
+  };
+}
+function toEstimateStatusResponse(raw) {
+  if (raw.status === "completed") {
+    return { status: "completed", auctionId: raw.auctionId, result: toEstimateResult(raw.result) };
+  }
+  return raw;
+}
+async function startEstimate(params) {
+  return costEstimationClient.post("/estimate", params);
+}
+async function getEstimateResult(estimateId) {
+  const raw = await costEstimationClient.get(
+    `/estimates/${encodeURIComponent(estimateId)}`
+  );
+  return toEstimateStatusResponse(raw);
+}
+async function waitForEstimate(params, options = {}) {
+  const { intervalMs = 5e3, timeoutMs = 6e4 } = options;
+  const { estimateId } = await startEstimate(params);
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const status = await getEstimateResult(estimateId);
+    if (status.status !== "pending") {
+      return { estimateId, status };
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      throw new Error(
+        `waitForEstimate: estimate ${estimateId} still pending after ${timeoutMs}ms`
+      );
+    }
+    await sleep(Math.min(intervalMs, remaining));
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/costEstimation/auction.ts
+import { u8aToHex } from "@polkadot/util";
+function toAuctionWinner(raw) {
+  return { guardian: raw.guardian, rate: BigInt(raw.rate) };
+}
+async function listOpenAuctions() {
+  const { auctions } = await costEstimationClient.get("/auctions");
+  return auctions;
+}
+async function listGuardianAuctions(guardianAddress) {
+  const { auctions } = await costEstimationClient.get(
+    `/guardians/${encodeURIComponent(guardianAddress)}/auctions`
+  );
+  return auctions;
+}
+async function getAuction(auctionId) {
+  const raw = await costEstimationClient.get(
+    `/auctions/${encodeURIComponent(auctionId)}`
+  );
+  return {
+    auctionId: raw.auctionId,
+    contractId: raw.contractId,
+    guardians: raw.guardians,
+    deadline: raw.deadline,
+    resolved: raw.resolved,
+    winner: raw.winner ? toAuctionWinner(raw.winner) : void 0
+  };
+}
+async function listResolvedGuardianAuctions(guardianAddress) {
+  const { auctions } = await costEstimationClient.get(
+    `/guardians/${encodeURIComponent(guardianAddress)}/auctions?resolved=true`
+  );
+  return auctions.map((a) => ({
+    auctionId: a.auctionId,
+    contractId: a.contractId,
+    guardians: a.guardians,
+    deadline: a.deadline,
+    winner: toAuctionWinner(a.winner)
+  }));
+}
+async function submitAuctionBid(auctionId, rate, guardian) {
+  const signature = u8aToHex(guardian.sign(`${auctionId}:${rate}`));
+  await costEstimationClient.post(
+    `/auctions/${encodeURIComponent(auctionId)}/bid`,
+    { guardian: guardian.address, rate, signature }
+  );
+}
+
+// src/costEstimation/webhook.ts
+import { u8aToHex as u8aToHex2 } from "@polkadot/util";
+async function registerGuardianWebhook(url, guardian) {
+  const signature = u8aToHex2(guardian.sign(`webhook:${url}`));
+  await costEstimationClient.post(
+    `/guardians/${encodeURIComponent(guardian.address)}/webhook`,
+    { url, signature }
+  );
+}
+
+// src/costEstimation/health.ts
+async function healthCheck() {
+  const { status } = await costEstimationClient.get("/health");
+  return status === "ok";
 }
 
 // src/da/register.ts
@@ -1792,7 +2460,7 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
   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(
+  const request2 = api2.tx.dataAvailability.daccRegisterData(
     nameBytes,
     descriptionBytes,
     blobRef,
@@ -1801,7 +2469,7 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
     ownerBytes,
     groupId
   );
-  const hash = await signAndSend(request, account);
+  const hash = await signAndSend(request2, account);
   debugLog(`Metadata registration transaction sent with hash: ${hash.hash}`);
   return hash;
 }
@@ -1811,13 +2479,7 @@ async function registerDataAgreement(account, params) {
   );
   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)),
-    storeType: params.metadata.storeType,
-    groupId: params.metadata.groupId
-  } : null;
+  const computeMetadata = buildComputeMetadata(params.metadata);
   const computeStep = {
     cipher,
     computerIndices: params.guardians.map((_, i) => i),
@@ -1853,7 +2515,7 @@ async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes,
   const baseModelTuple = [baseModel.blockNumber, baseModel.index];
   const api2 = await getApi();
   assert(api2, "Failed to get API connection");
-  const request = api2.tx.dataAvailability.daccRunAgent(
+  const request2 = api2.tx.dataAvailability.daccRunAgent(
     agentRefTuple,
     Array.from(nonce),
     Array.from(ciphertext),
@@ -1873,7 +2535,7 @@ async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes,
       agreement: [agreementId]
     }
   };
-  const hash = await signAndSend(request, account, opts);
+  const hash = await signAndSend(request2, account, opts);
   debugLog(`Run agent transaction sent with hash: ${hash.hash}`);
   return hash;
 }
@@ -1905,8 +2567,8 @@ async function submitTEData(account, data, chosenGuardians, tau_params, agg_key,
   });
   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);
+  const request2 = await api2.tx.dataAvailability.submitData(modelSubmit);
+  const hash = await signAndSend(request2, account, DEFAULT_EMPTY_PAYLOAD);
   debugLog(`TE data availability transaction sent with hash: ${hash.hash}`);
   return hash;
 }
@@ -1919,8 +2581,8 @@ async function submitTEDataWithCipher(account, data, chosenGuardians, tau_params
   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);
+  const request2 = await api2.tx.dataAvailability.submitData(ciphertextHex);
+  const ref = await signAndSend(request2, account, DEFAULT_EMPTY_PAYLOAD);
   debugLog(`TE data availability transaction sent with hash: ${ref.hash}`);
   return {
     ref,
@@ -1955,7 +2617,7 @@ async function uploadData(options) {
   if (filePath) {
     throw new Error("uploadData: file path upload is not implemented");
   } else {
-    const storeType = type === "model" ? "Model" : type === "agent" ? "Agent" : "Dataset";
+    const storeType = type === "model" ? "Model" : type === "agent" ? "Agent" : type === "executable" ? "Executable" : "Dataset";
     const { ref: dataRef, cipher } = await submitTEDataWithCipher(
       account,
       ref || "",
@@ -2017,7 +2679,7 @@ async function uploadDataLegacy(options) {
       guardianGroupInfo.aggKey,
       guardianGroupInfo.groupPk
     );
-    const dtype = type === "model" ? 1 : type === "agent" ? 2 : 0;
+    const dtype = type === "model" ? 1 : type === "agent" ? 2 : type === "executable" ? 4 : 0;
     await writeMetadata(
       account,
       name,
@@ -2114,6 +2776,67 @@ async function withdrawStake(account) {
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
 }
 
+// src/storage/s3.ts
+var S3Provider = class {
+  constructor() {
+    this.id = "s3";
+  }
+  getDeterministicUrl(hash) {
+    return `https://${getAwsS3Bucket()}.s3.${getAwsRegion()}.amazonaws.com/Contracts/${hash}`;
+  }
+  async getUploadUrl(txHash, fileHash, blockNumber, expectedUrl) {
+    const response = await fetch(`${getAuthServiceUrl()}/api/s3/auth`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ txHash, fileHash, blockNumber, url: expectedUrl })
+    });
+    if (!response.ok) {
+      let errorMessage = response.statusText;
+      try {
+        const errData = await response.json();
+        if (errData.error) errorMessage = errData.error;
+      } catch {
+      }
+      throw new Error(`Auth Service failed: ${errorMessage}`);
+    }
+    const { presignedUrl } = await response.json();
+    if (!presignedUrl) {
+      throw new Error("No presignedUrl returned from Auth Service");
+    }
+    return presignedUrl;
+  }
+  async upload(url, data) {
+    const response = await fetch(url, {
+      method: "PUT",
+      body: data
+    });
+    if (!response.ok) {
+      throw new Error(`Storage Upload failed: ${response.statusText}`);
+    }
+  }
+};
+
+// src/storage/router.ts
+var StorageRouter = class {
+  constructor() {
+    this.providers = /* @__PURE__ */ new Map();
+    this.register(new S3Provider());
+    this.defaultProvider = "s3";
+  }
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  getProvider(id) {
+    const targetId = id || this.defaultProvider;
+    const provider = this.providers.get(targetId);
+    if (!provider) {
+      throw new Error(`Storage provider '${targetId}' not found`);
+    }
+    return provider;
+  }
+};
+var storageRouter = new StorageRouter();
+
 // src/token/fund.ts
 async function fundAccount(account, amountBaseUnits, address) {
   const addr = address ? address : account.address;
@@ -2160,15 +2883,499 @@ Setting identity for account: ${account.address} as ${display}`);
   debugLog(`Set identity transaction sent with hash: ${hash.hash}`);
 }
 
+// src/indexer/client.ts
+var DEFAULT_BASE_URL = "http://localhost:5020";
+var IndexerClient = class {
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "").replace(/\/api$/i, "");
+    this._fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Performs a GET request against the indexer and returns the parsed JSON body.
+   *
+   * @throws {IndexerHttpError} When the response indicates failure (`success: false`)
+   *         or the HTTP status is not 2xx.
+   */
+  async get(path2, params) {
+    const url = new URL(`${this.baseUrl}${path2}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const response = await this._fetch(url.toString(), {
+      method: "GET",
+      headers: { Accept: "application/json" }
+    });
+    const raw = await response.text();
+    let body;
+    try {
+      body = raw ? JSON.parse(raw) : null;
+    } catch {
+      if (!response.ok) {
+        throw new IndexerHttpError(
+          response.status,
+          raw || response.statusText
+        );
+      }
+      throw new IndexerHttpError(
+        response.status,
+        `Invalid JSON response from ${url.toString()}: ${raw.slice(0, 120)}`
+      );
+    }
+    if (!response.ok) {
+      const errBody = body;
+      throw new IndexerHttpError(
+        response.status,
+        errBody?.message ?? response.statusText
+      );
+    }
+    return body;
+  }
+};
+var IndexerHttpError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.name = "IndexerHttpError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/indexer/artefacts.ts
+async function getArtefacts(client, query) {
+  return client.get("/api/artefacts", query ? { ...query } : void 0);
+}
+async function getArtefactsByStoreType(client, storeType) {
+  const response = await getArtefacts(client);
+  return {
+    success: true,
+    data: response.data.filter((item) => item.storeType === storeType)
+  };
+}
+async function getDatasets(client) {
+  return getArtefactsByStoreType(client, "Dataset");
+}
+async function getModels(client) {
+  return getArtefactsByStoreType(client, "Model");
+}
+async function getAgents(client) {
+  return getArtefactsByStoreType(client, "Agent");
+}
+async function getExecutables(client) {
+  return getArtefactsByStoreType(client, "Executable");
+}
+async function getArtefact(client, id) {
+  return client.get(`/api/artefact/${encodeURIComponent(id)}`);
+}
+async function getArtefactAccess(client, id, query) {
+  return client.get(
+    `/api/artefact/${encodeURIComponent(id)}/access`,
+    query ? { ...query } : void 0
+  );
+}
+function nestedContractId(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && "id" in value) {
+    const id = value.id;
+    return typeof id === "string" ? id : void 0;
+  }
+  return void 0;
+}
+function isArtefactUsage(doc, artefactId) {
+  if (!doc || doc.contractId === artefactId) return false;
+  if (doc.inputContractId === artefactId) return true;
+  const compute = doc.compute;
+  const inputId = nestedContractId(compute?.input?.contractId);
+  const programId = nestedContractId(compute?.program?.contractId);
+  return inputId === artefactId || programId === artefactId;
+}
+async function getArtefactContracts(client, id, query) {
+  const response = await client.get(
+    `/api/artefact/${encodeURIComponent(id)}/contracts`,
+    query ? { ...query } : void 0
+  );
+  const list = Array.isArray(response.data) ? response.data : [];
+  const usages = list.filter((item) => isArtefactUsage(item, id));
+  if (usages.length > 0) {
+    return { ...response, data: usages };
+  }
+  const looksLikeSelfOnly = list.length > 0 && list.every((item) => item?.contractId === id);
+  if (!looksLikeSelfOnly) {
+    return {
+      ...response,
+      data: list.filter((item) => item?.contractId !== id)
+    };
+  }
+  const artefacts = await getArtefacts(client);
+  return {
+    success: true,
+    data: (artefacts.data || []).filter(
+      (item) => isArtefactUsage(item, id)
+    )
+  };
+}
+
+// src/indexer/contracts.ts
+async function getContracts(client, query) {
+  return client.get("/api/contracts", query ? { ...query } : void 0);
+}
+async function getContract(client, id) {
+  return client.get(`/api/contract/${encodeURIComponent(id)}`);
+}
+async function getCompute(client, id) {
+  return client.get(`/api/compute/${encodeURIComponent(id)}`);
+}
+async function getResults(client, query) {
+  return client.get("/api/results", { contractId: query.contractId });
+}
+async function getResult(client, id) {
+  return client.get(`/api/result/${encodeURIComponent(id)}`);
+}
+
+// src/indexer/blobs.ts
+async function getBlob(client, id) {
+  return client.get(`/api/blob/${encodeURIComponent(String(id))}`);
+}
+
+// src/indexer/flow.ts
+function computeTime(item) {
+  return item.indexer?.blockTime ?? 0;
+}
+function isComputeRequest(item) {
+  return Boolean(
+    item.jobId || item.orchestrator || item.resultTx || item.computeReward || item.decryptionFee
+  );
+}
+function normalizeComputes(compute) {
+  if (!compute) return [];
+  const list = Array.isArray(compute) ? compute : Array.isArray(compute.computes) ? compute.computes : [compute];
+  return [...list].filter(isComputeRequest).sort((a, b) => computeTime(a) - computeTime(b));
+}
+function resultToCompute(result) {
+  const indexer = result.indexer;
+  return {
+    ...result,
+    jobId: result.resultId,
+    contractId: result.contractId,
+    orchestrator: result.submitor,
+    resultTx: indexer ? {
+      blockHeight: indexer.blockHeight,
+      extrinsicIndex: indexer.extrinsicIndex,
+      blockHash: indexer.blockHash,
+      hash: indexer.blockHash
+    } : { hash: result.resultId },
+    computeReward: result.feeBreakdown?.submitorFee?.amount,
+    fee: result.feeBreakdown?.resultFee,
+    decryptionFee: result.feeBreakdown?.thresholdDecryptionFee,
+    indexer
+  };
+}
+function mergeComputes(fromResults, fromCompute) {
+  if (fromResults.length === 0) return fromCompute;
+  const ids = new Set(
+    fromResults.flatMap((item) => [item.jobId, item.contractId].filter(Boolean))
+  );
+  const extras = fromCompute.filter(
+    (item) => !ids.has(item.jobId ?? "") && !ids.has(item.contractId ?? "")
+  );
+  return normalizeComputes([...fromResults, ...extras]);
+}
+function withParties(agreement) {
+  if (agreement.parties?.length) return agreement;
+  const guardians = agreement.guardians;
+  if (Array.isArray(guardians) && guardians.length) {
+    return { ...agreement, parties: guardians };
+  }
+  return agreement;
+}
+function deriveContractStatus(agreement, compute) {
+  if (!agreement) return "\u2014";
+  const computes = normalizeComputes(compute);
+  if (computes.length === 0) {
+    return (agreement.responses?.length ?? 0) > 0 ? "ACCEPTED" : "PENDING";
+  }
+  if (computes.every((item) => !!item.resultTx)) return "COMPLETED";
+  return "PROCESSING";
+}
+function buildContractPhases(agreement, compute) {
+  const computes = normalizeComputes(compute);
+  const latest = computes[computes.length - 1] ?? null;
+  const settledCount = computes.filter((item) => !!item.resultTx).length;
+  const status = deriveContractStatus(agreement, computes);
+  const phase1Active = !!agreement;
+  const phase1Complete = status === "ACCEPTED" || status === "PROCESSING" || status === "COMPLETED";
+  const phase2Active = computes.length > 0;
+  const allSettled = computes.length > 0 && settledCount === computes.length;
+  const phase5Complete = status === "COMPLETED";
+  const requestsJson = computes.map((item) => {
+    const { _id: _ignored, ...rest } = item;
+    return rest;
+  });
+  return [
+    {
+      id: "phase-1",
+      title: "Phase 1: Contract Agreement",
+      status: agreement ? `RESPONSES (${agreement.responses?.length ?? 0})` : "\u2014",
+      description: "Established once and reused by every compute request in this session.",
+      json: agreement ? {
+        contractId: agreement.contractId,
+        creator: agreement.creator,
+        fee: agreement.fee,
+        creationTime: agreement.creationTime,
+        parties: agreement.parties,
+        responses: agreement.responses,
+        indexer: agreement.indexer,
+        computeTx: agreement.computeTx
+      } : {},
+      active: phase1Active,
+      complete: phase1Complete,
+      pending: phase1Active && !phase1Complete
+    },
+    {
+      id: "phase-2",
+      title: "Phase 2: Compute Request",
+      status: phase2Active ? `${computes.length} SUBMITTED` : "PENDING",
+      description: "Each iteration submits a compute request that is broadcast to all guardians.",
+      json: { requestCount: computes.length, requests: requestsJson },
+      active: phase2Active,
+      complete: phase2Active,
+      pending: phase1Complete && !phase2Active
+    },
+    {
+      id: "phase-3",
+      title: "Phase 3: Guardian Execution",
+      status: allSettled ? `${settledCount}/${computes.length} RESULT_SUBMITTED` : phase2Active ? `${settledCount}/${computes.length} PROCESSING` : "PENDING",
+      description: "One guardian claims each request, executes compute, and submits the result on-chain.",
+      json: latest?.resultTx ? {
+        jobId: latest.jobId,
+        contractId: latest.contractId,
+        orchestrator: latest.orchestrator,
+        resultTx: latest.resultTx,
+        settledCount,
+        requestCount: computes.length
+      } : { settledCount, requestCount: computes.length },
+      active: phase2Active,
+      complete: allSettled,
+      pending: phase2Active && !allSettled
+    },
+    {
+      id: "phase-4",
+      title: "Phase 4: Fee Distribution",
+      status: allSettled ? `${settledCount}/${computes.length} SETTLED` : phase2Active ? "PROCESSING" : "PENDING",
+      description: "Executor reward is paid per completed request. TD fee was locked once at agreement.",
+      json: allSettled ? {
+        requestCount: computes.length,
+        settledCount,
+        computeReward: latest?.computeReward,
+        decryptionFee: latest?.decryptionFee,
+        fee: latest?.fee
+      } : { requestCount: computes.length, settledCount },
+      active: allSettled,
+      complete: allSettled,
+      pending: phase2Active && !allSettled
+    },
+    {
+      id: "phase-5",
+      title: "Phase 5: Close Out",
+      status: phase5Complete ? "SETTLED" : phase1Complete ? "PENDING" : "\u2014",
+      description: "User sends closeout, guardians clean up, remaining funds are refunded.",
+      json: {
+        requestCount: computes.length,
+        settledCount,
+        finalStatus: phase5Complete ? "SETTLED" : status
+      },
+      active: phase5Complete,
+      complete: phase5Complete,
+      pending: phase1Complete && !phase5Complete
+    }
+  ];
+}
+async function getContractFlow(client, id) {
+  const [agreementResponse, compute, results] = await Promise.all([
+    getContract(client, id),
+    getCompute(client, id).then((response) => response.data).catch((err) => {
+      if (err instanceof IndexerHttpError && err.statusCode === 404) return null;
+      throw err;
+    }),
+    getResults(client, { contractId: id }).then((response) => response.data).catch((err) => {
+      if (err instanceof IndexerHttpError && err.statusCode === 404) return [];
+      throw err;
+    })
+  ]);
+  const agreement = withParties(agreementResponse.data);
+  const computes = mergeComputes(
+    (results ?? []).map(resultToCompute),
+    normalizeComputes(compute)
+  );
+  const latest = computes[computes.length - 1] ?? null;
+  return {
+    success: true,
+    data: {
+      agreement,
+      compute: latest,
+      computes,
+      results: results ?? [],
+      status: deriveContractStatus(agreement, computes),
+      phases: buildContractPhases(agreement, computes)
+    }
+  };
+}
+function blobHeightsFromArtefact(artefact) {
+  const refs = artefact.blobRefs;
+  if (!Array.isArray(refs)) return [];
+  const heights = [];
+  for (const ref of refs) {
+    const raw = Array.isArray(ref) ? ref[0] : ref;
+    const height = typeof raw === "number" ? raw : Number(raw);
+    if (Number.isFinite(height)) heights.push(height);
+  }
+  return heights;
+}
+async function getArtefactFlow(client, id, accessQuery) {
+  const artefactResponse = await getArtefact(client, id);
+  const artefact = artefactResponse.data;
+  let access = [];
+  try {
+    const accessResponse = await getArtefactAccess(client, id, accessQuery);
+    access = Array.isArray(accessResponse.data) ? accessResponse.data : [];
+  } catch (err) {
+    if (!(err instanceof IndexerHttpError && err.statusCode === 404)) throw err;
+  }
+  const blobs = [];
+  for (const height of blobHeightsFromArtefact(artefact)) {
+    try {
+      const blobResponse = await getBlob(client, height);
+      if (blobResponse.data) blobs.push(blobResponse.data);
+    } catch (err) {
+      if (err instanceof IndexerHttpError && err.statusCode === 404) continue;
+      throw err;
+    }
+  }
+  return {
+    success: true,
+    data: { artefact, access, blobs }
+  };
+}
+
+// src/indexer/blocks.ts
+async function getBlocks(client, query) {
+  return client.get("/api/blocks", query ? { ...query } : void 0);
+}
+
+// src/indexer/calls.ts
+async function getCall(client, query) {
+  return client.get("/api/call", { ...query });
+}
+async function getCallMetadata(client, query) {
+  return client.get("/api/call-metadata", { ...query });
+}
+async function getCallArgs(client, query) {
+  return client.get("/api/call-args", { ...query });
+}
+
+// src/indexer/transfers.ts
+async function getTransfers(client, query) {
+  return client.get("/api/transfers", query ? { ...query } : void 0);
+}
+
+// src/indexer/extrinsics.ts
+async function getExtrinsics(client, query) {
+  if (!query) {
+    return client.get("/api/extrinsics");
+  }
+  const { signed_only, ...rest } = query;
+  const params = { ...rest };
+  if (signed_only !== void 0) {
+    params.signed_only = signed_only === true || signed_only === "true" ? "true" : "false";
+  }
+  return client.get("/api/extrinsics", params);
+}
+async function getExtrinsic(client, indexOrHash) {
+  return client.get(`/api/extrinsic/${encodeURIComponent(indexOrHash)}`);
+}
+
+// src/indexer/addresses.ts
+async function getAddresses(client) {
+  return client.get("/api/addresses");
+}
+async function getAddress(client, address) {
+  return client.get(`/api/address/${encodeURIComponent(address)}`);
+}
+
+// src/indexer/guardians.ts
+function displayNameForAccount(groups, account) {
+  for (const group of groups) {
+    const addresses = group.guardians ?? [];
+    const names = group.guardianNames ?? [];
+    const index = addresses.indexOf(account);
+    if (index === -1) continue;
+    const rawName = names[index];
+    if (typeof rawName === "string" && rawName.length > 0) return rawName;
+  }
+  return null;
+}
+function uniqueGuardians(groups) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const addresses = group.guardians ?? [];
+    const names = group.guardianNames ?? [];
+    for (let i = 0; i < addresses.length; i++) {
+      const account = addresses[i];
+      if (!account || seen.has(account)) continue;
+      const rawName = names[i];
+      seen.set(account, typeof rawName === "string" && rawName.length > 0 ? rawName : null);
+    }
+  }
+  return Array.from(seen, ([account, displayName]) => ({ account, displayName }));
+}
+async function guardianGroupsOrEmpty(client, query) {
+  try {
+    const response = await getGuardianGroups(client, query);
+    return response.data ?? [];
+  } catch (err) {
+    if (err instanceof IndexerHttpError && err.statusCode === 404) {
+      return [];
+    }
+    throw err;
+  }
+}
+async function getGuardianGroups(client, query) {
+  return client.get("/api/guardian-groups", query ? { ...query } : void 0);
+}
+async function getGuardians(client) {
+  const groups = await guardianGroupsOrEmpty(client);
+  return { success: true, data: uniqueGuardians(groups) };
+}
+async function getGuardian(client, account) {
+  const groups = await guardianGroupsOrEmpty(client, { guardian: account });
+  return {
+    success: true,
+    data: {
+      account,
+      displayName: displayNameForAccount(groups, account)
+    }
+  };
+}
+async function getGuardianGroup(client, id) {
+  return client.get(`/api/guardian-group/${encodeURIComponent(id)}`);
+}
+
+// src/indexer/access.ts
+async function getAccess(client, query) {
+  return client.get("/api/access", query ? { ...query } : void 0);
+}
+
 // src/rotateKeys.ts
 import bs583 from "bs58";
 import assert3 from "assert";
 async function rotateAndSetKeys(account) {
   const api2 = await getApi();
   assert3(api2, "API not initialized");
-  debugLog(`Rotating session keys for ${account.meta.name} on ${provider.endpoint}`);
+  debugLog(`Rotating session keys for ${account.meta.name} on ${getProvider().endpoint}`);
   const newKeys = await api2.rpc.author.rotateKeys();
-  debugLog(`${account.meta.name} rotated keys on ${provider.endpoint}:`, newKeys?.toHex?.() ?? newKeys);
+  debugLog(`${account.meta.name} rotated keys on ${getProvider().endpoint}:`, newKeys?.toHex?.() ?? newKeys);
   const setKeysTx = api2.tx.session.setKeys(newKeys, []);
   const hash = await signAndSend(setKeysTx, account);
   debugLog(`Rotate session transaction sent with hash: ${hash.hash}`);
@@ -2196,7 +3403,7 @@ import { hexToU8a as hexToU8a2, isHex as isHex2, stringToU8a } from "@polkadot/u
 import { base64Decode, decodeAddress as decodeAddress2, ed25519PairFromSeed as ed25519FromSeed2, encodeAddress, ethereumEncode as ethereumEncode2, hdEthereum, keyExtractSuri, keyFromPath as keyFromPath2, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed2, sr25519PairFromSeed as sr25519FromSeed2 } from "@polkadot/util-crypto";
 
 // node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/index.js
-import { objectSpread as objectSpread2, u8aConcat as u8aConcat2, u8aEmpty, u8aEq as u8aEq2, u8aToHex, u8aToU8a } from "@polkadot/util";
+import { objectSpread as objectSpread2, u8aConcat as u8aConcat2, u8aEmpty, u8aEq as u8aEq2, u8aToHex as u8aToHex3, u8aToU8a } from "@polkadot/util";
 import { blake2AsU8a, ed25519PairFromSeed as ed25519FromSeed, ed25519Sign, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, secp256k1Compress, secp256k1Expand, secp256k1PairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify, sr25519PairFromSeed as sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify } from "@polkadot/util-crypto";
 
 // node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/decode.js
@@ -2366,7 +3573,7 @@ function createPair({ toSS58, type }, { publicKey, secretKey }, meta = {}, encod
       return u8aConcat2(options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE, TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey }));
     },
     toJson: (passphrase) => {
-      const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? u8aToHex(publicKey) : u8aToHex(secp256k1Compress(publicKey)) : encodeAddress3();
+      const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? u8aToHex3(publicKey) : u8aToHex3(secp256k1Compress(publicKey)) : encodeAddress3();
       return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
     },
     unlock: (passphrase) => {
@@ -2399,7 +3606,7 @@ function createPair({ toSS58, type }, { publicKey, secretKey }, meta = {}, encod
 var DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
 
 // node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pairs.js
-import { isHex, isU8a, u8aToHex as u8aToHex2, u8aToU8a as u8aToU8a2 } from "@polkadot/util";
+import { isHex, isU8a, u8aToHex as u8aToHex4, u8aToU8a as u8aToU8a2 } from "@polkadot/util";
 import { decodeAddress } from "@polkadot/util-crypto";
 var _map;
 var Pairs = class {
@@ -2416,7 +3623,7 @@ var Pairs = class {
   get(address) {
     const pair = __privateGet(this, _map)[decodeAddress(address).toString()];
     if (!pair) {
-      throw new Error(`Unable to retrieve keypair '${isU8a(address) || isHex(address) ? u8aToHex2(u8aToU8a2(address)) : address}'`);
+      throw new Error(`Unable to retrieve keypair '${isU8a(address) || isHex(address) ? u8aToHex4(u8aToU8a2(address)) : address}'`);
     }
     return pair;
   }
@@ -2651,28 +3858,33 @@ export {
   API_TYPES,
   AccountSourceType,
   ApiPromise2 as ApiPromise,
+  COMPUTE_TYPES,
+  CostEstimationError,
   CryptoType,
-  DEBUG,
   DEFAULT_COMPUTE_PAYLOAD,
   DEFAULT_EMPTY_PAYLOAD,
   FileFromMetadataRef,
   HttpProvider,
+  IndexerClient,
+  IndexerHttpError,
   Keyring3 as Keyring,
   MCryptFs,
   MCryptFsReader,
   MCryptFsWriter,
+  NO_GUARDIAN_GROUP,
   PALI_DECIMALS,
   PALI_SYMBOL,
-  PALLIORA_RPC_URL,
-  PALLIORA_WS,
-  TX_WAIT_FINALIZATION,
+  S3Provider,
+  StorageRouter,
   WsProvider3 as WsProvider,
   addStake,
   base64ToUint8Array,
+  buildComputeMetadata,
+  buildContractPhases,
   buildFee,
   clearTokenCache,
-  configure,
   createAccount,
+  createAccountFromMagicLink,
   createAgreement,
   createGuardianGroup,
   createGuardianGroupAndWatch,
@@ -2683,11 +3895,18 @@ export {
   decodeField,
   decodePowersOfTau,
   decrypt,
+  deriveContractStatus,
+  disconnectApi,
   encrypt as ecncryptTest,
   encodeCiphertext,
   encrypt2 as encrypt,
+  encryptedInferenceCompute,
+  encryptedInferenceSubscription,
+  encryptedInferenceSubscriptionInvocation,
+  estimateMinFee,
   fetchAndDecodeExtrinsic,
   fetchTokenProperties,
+  findEvent,
   formatBalanceWithTokenProperties,
   formatPaliAmount,
   fromAtomicPaliAmount,
@@ -2695,28 +3914,88 @@ export {
   gen_shared_key,
   gen_stretched_key,
   generateRandomBytes,
+  getAccess,
+  getAccountInfo,
+  getActiveGuardians,
+  getAddress,
+  getAddresses,
+  getAgents,
   getAgreementCreatedRequestId,
   getApi,
+  getArtefact,
+  getArtefactAccess,
+  getArtefactContracts,
+  getArtefactFlow,
+  getArtefacts,
+  getArtefactsByStoreType,
+  getAuction,
+  getAuthServiceUrl,
+  getAwsRegion,
+  getAwsS3Bucket,
+  getBalance,
+  getBlob,
+  getBlocks,
   getCachedTokenProperties,
+  getCall,
+  getCallArgs,
+  getCallMetadata,
+  getCompute,
+  getContract,
+  getContractFlow,
+  getContractInfo,
+  getContracts,
+  getCostEstimatorUrl,
+  getDatasets,
   getEncKeyring,
+  getEstimateResult,
+  getExecutables,
+  getExtrinsic,
+  getExtrinsics,
+  getFeeParams,
   getFileMetadataCall,
+  getGuardian,
   getGuardianAddress,
+  getGuardianGroup,
+  getGuardianGroupInfo,
+  getGuardianGroups,
   getGuardianList,
   getGuardianNwParams,
   getGuardianParticipants,
+  getGuardians,
   getKeyring,
+  getLatestBlocks,
+  getModels,
+  getPallioraRpcUrl,
+  getPallioraWs,
+  getProvider,
+  getResult,
+  getResults,
+  getTransfers,
+  healthCheck,
   hexToUint8Array,
   inferenceCompute,
+  init,
+  invokeAgreement,
+  isArtefactUsage,
+  isDebug,
+  isInitialized,
   joinGuardian,
   joinIdleStaker,
   joinValidator,
+  listGuardianAuctions,
+  listOpenAuctions,
+  listResolvedGuardianAuctions,
   newStake,
+  normalizeComputes,
   pairFromPrivateKeyHex,
   payoutStake,
-  provider,
   reduceStake,
   registerDataAgreement,
+  registerGuardianWebhook,
   removeStake,
+  resetConfig,
+  resultToCompute,
+  retrySignAndSend,
   rotateAndSetKeys,
   runAgent,
   scanForBlockEvent,
@@ -2724,6 +4003,10 @@ export {
   setWorker,
   signAndSend,
   simpleCompute,
+  startEstimate,
+  storageRouter,
+  storedCompute,
+  submitAuctionBid,
   submitData,
   submitTEData,
   submitTEDataWithCipher,
@@ -2735,6 +4018,9 @@ export {
   uploadData,
   uploadDataLegacy,
   utilCrypto,
+  waitForEstimate,
+  waitForNextBlock,
+  waitsForFinalization,
   wasmCrypto,
   watchForSubmissionReceipt,
   withdrawStake,