@palliora.org/chainsdk 0.3.3 → 0.5.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
@@ -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 = _util.hexToU8a.call(void 0, 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
 
-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 (0, _api2.WsProvider)(PALLIORA_WS, 1e4);
-function configure(opts) {
-  if (opts.pallioraWs !== void 0) PALLIORA_WS = exports.PALLIORA_WS = opts.pallioraWs;
-  if (opts.pallioraRpcUrl !== void 0) PALLIORA_RPC_URL = exports.PALLIORA_RPC_URL = opts.pallioraRpcUrl;
-  if (opts.debug !== void 0) DEBUG = exports.DEBUG = opts.debug;
-  if (opts.txWaitFinalization !== void 0) TX_WAIT_FINALIZATION = exports.TX_WAIT_FINALIZATION = opts.txWaitFinalization;
-  provider = exports.provider = new (0, _api2.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 = () => _nullishCoalesce(_optionalChain([config, 'optionalAccess', _29 => _29.debug]), () => ( false));
+var waitsForFinalization = () => _nullishCoalesce(_optionalChain([config, 'optionalAccess', _30 => _30.txWaitFinalization]), () => ( false));
+function getProvider() {
+  const url = getPallioraWs();
+  if (!cachedProvider || cachedProviderUrl !== url) {
+    cachedProvider = new (0, _api2.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);
   }
 };
@@ -914,11 +977,11 @@ async function fetchTokenProperties() {
     return tokenCache;
   }
   try {
-    const systemProperties = await _asyncOptionalChain([(await await _asyncOptionalChain([(await getApi()), 'optionalAccess', async _29 => _29.rpc, 'access', async _30 => _30.system, 'access', async _31 => _31.properties, 'call', async _32 => _32()])), 'optionalAccess', async _33 => _33.toHuman, 'call', async _34 => _34()]);
+    const systemProperties = await _asyncOptionalChain([(await await _asyncOptionalChain([(await getApi()), 'optionalAccess', async _31 => _31.rpc, 'access', async _32 => _32.system, 'access', async _33 => _33.properties, 'call', async _34 => _34()])), 'optionalAccess', async _35 => _35.toHuman, 'call', async _36 => _36()]);
     assert(systemProperties, "Failed to fetch system properties from RPC");
     const tokenProperties = {
-      symbol: (_optionalChain([systemProperties, 'optionalAccess', _35 => _35.tokenSymbol]) || [PALI_SYMBOL])[0],
-      decimals: Number((_optionalChain([systemProperties, 'optionalAccess', _36 => _36.tokenDecimals]) || [String(PALI_DECIMALS)])[0])
+      symbol: (_optionalChain([systemProperties, 'optionalAccess', _37 => _37.tokenSymbol]) || [PALI_SYMBOL])[0],
+      decimals: Number((_optionalChain([systemProperties, 'optionalAccess', _38 => _38.tokenDecimals]) || [String(PALI_DECIMALS)])[0])
     };
     tokenCache = tokenProperties;
     return tokenProperties;
@@ -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,15 +1023,15 @@ async function getApi(cb) {
   }
   if (!api) {
     api = await _api2.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" && _optionalChain([process, 'access', _37 => _37.env, 'optionalAccess', _38 => _38.NODE_ENV]) === "test";
+  const isTest = typeof process !== "undefined" && _optionalChain([process, 'access', _39 => _39.env, 'optionalAccess', _40 => _40.NODE_ENV]) === "test";
   if (isNode && !isTest && api && !apiListenersAttached) {
     apiListenersAttached = true;
     api.on("error", (err) => {
@@ -977,7 +1040,7 @@ async function getApi(cb) {
       apiListenersAttached = false;
       const currentApi = api;
       api = null;
-      void _optionalChain([currentApi, 'optionalAccess', _39 => _39.disconnect, 'call', _40 => _40(), 'access', _41 => _41.catch, 'call', _42 => _42((disconnectErr) => {
+      void _optionalChain([currentApi, 'optionalAccess', _41 => _41.disconnect, 'call', _42 => _42(), 'access', _43 => _43.catch, 'call', _44 => _44((disconnectErr) => {
         apiTeardownInProgress = false;
         console.error("api disconnect after error failed:", disconnectErr);
       })]);
@@ -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 _wasmcrypto.waitReady.call(void 0, );
@@ -1014,6 +1087,7 @@ var _bs58 = require('bs58'); var _bs582 = _interopRequireDefault(_bs58);
 
 // src/guardian/active.ts
 
+
 var getGuardianList = async () => {
   const api2 = await getApi();
   if (!api2) throw new Error("API not initialized");
@@ -1021,12 +1095,32 @@ var getGuardianList = async () => {
   const section = "guardian";
   const method = "guardianList";
   assert(
-    _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _43 => _43[section], 'optionalAccess', _44 => _44[method]])),
+    _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _45 => _45[section], 'optionalAccess', _46 => _46[method]])),
     `api.rpc.${section}.${method} does not exist`
   );
   const list = (await rpc[section]["guardianList"]()).map((item) => [item.toString()]).flat(1);
   return list;
 };
+async function getActiveGuardians(apiInstance) {
+  await _wasmcrypto.waitReady.call(void 0, );
+  const api2 = await _asyncNullishCoalesce(apiInstance, async () => ( await getApi()));
+  if (!api2) throw new Error("API not initialized");
+  const guardians = await api2.query.guardian.guardians();
+  const accounts = _optionalChain([guardians, 'optionalAccess', _47 => _47.toJSON, 'call', _48 => _48()]) || [];
+  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: _nullishCoalesce(_optionalChain([prefs, 'optionalAccess', _49 => _49.toHuman, 'optionalCall', _50 => _50()]), () => ( null)),
+        stakersOverview: _nullishCoalesce(_optionalChain([ledger, 'optionalAccess', _51 => _51.toHuman, 'optionalCall', _52 => _52()]), () => ( null))
+      };
+    })
+  );
+}
 
 // src/guardian/group.ts
 var createGuardianGroup = async (account, selectedGuardians) => {
@@ -1058,7 +1152,7 @@ var createGuardianGroupAndWatch = async (account, guardians, maxBlocks = 20) =>
   assert(api2, "Failed to initialize API");
   debugLog(`Submitting guardian group creation...`);
   const creationResult = await createGuardianGroup(account, guardians);
-  const startBlock = (_nullishCoalesce(_optionalChain([creationResult, 'optionalAccess', _45 => _45.blockNumber]), () => ( 0))) + 1;
+  const startBlock = (_nullishCoalesce(_optionalChain([creationResult, 'optionalAccess', _53 => _53.blockNumber]), () => ( 0))) + 1;
   debugLog(`Group creation tx confirmed at block ${startBlock - 1}. Listening for DaccGuardianGroup event from block ${startBlock}...`);
   const match = await scanForBlockEvent(
     api2,
@@ -1067,7 +1161,7 @@ var createGuardianGroupAndWatch = async (account, guardians, maxBlocks = 20) =>
         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 _optionalChain([ext2, 'optionalAccess', _46 => _46.method, 'optionalAccess', _47 => _47.section, 'optionalAccess', _48 => _48.toLowerCase, 'call', _49 => _49()]) === "dataavailability" && _optionalChain([ext2, 'optionalAccess', _50 => _50.method, 'optionalAccess', _51 => _51.method, 'optionalAccess', _52 => _52.toLowerCase, 'call', _53 => _53()]) === "daccguardiangroupinfo";
+        return _optionalChain([ext2, 'optionalAccess', _54 => _54.method, 'optionalAccess', _55 => _55.section, 'optionalAccess', _56 => _56.toLowerCase, 'call', _57 => _57()]) === "dataavailability" && _optionalChain([ext2, 'optionalAccess', _58 => _58.method, 'optionalAccess', _59 => _59.method, 'optionalAccess', _60 => _60.toLowerCase, 'call', _61 => _61()]) === "daccguardiangroupinfo";
       }
     },
     startBlock,
@@ -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 (_optionalChain([ext, 'optionalAccess', _62 => _62.method, 'optionalAccess', _63 => _63.section, 'optionalAccess', _64 => _64.toLowerCase, 'call', _65 => _65()]) === "dataavailability" && _optionalChain([ext, 'optionalAccess', _66 => _66.method, 'optionalAccess', _67 => _67.method, 'optionalAccess', _68 => _68.toLowerCase, 'call', _69 => _69()]) === "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(
+    _optionalChain([creationExt, 'optionalAccess', _70 => _70.method, 'optionalAccess', _71 => _71.section, 'optionalAccess', _72 => _72.toLowerCase, 'call', _73 => _73()]) === "dataavailability" && _optionalChain([creationExt, 'optionalAccess', _74 => _74.method, 'optionalAccess', _75 => _75.method, 'optionalAccess', _76 => _76.toLowerCase, 'call', _77 => _77()]) === "daccguardiangroup",
+    `Extrinsic at block ${creationRef.blockNumber}, index ${creationRef.index} is not a daccGuardianGroup call (found ${_optionalChain([creationExt, 'optionalAccess', _78 => _78.method, 'optionalAccess', _79 => _79.section])}.${_optionalChain([creationExt, 'optionalAccess', _80 => _80.method, 'optionalAccess', _81 => _81.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 = await _asyncNullishCoalesce(resultRef, async () => ( 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(
+    _optionalChain([resultExt, 'optionalAccess', _82 => _82.method, 'optionalAccess', _83 => _83.section, 'optionalAccess', _84 => _84.toLowerCase, 'call', _85 => _85()]) === "dataavailability" && _optionalChain([resultExt, 'optionalAccess', _86 => _86.method, 'optionalAccess', _87 => _87.method, 'optionalAccess', _88 => _88.toLowerCase, 'call', _89 => _89()]) === "daccguardiangroupinfo",
+    `Extrinsic at block ${resolvedResultRef.blockNumber}, index ${resolvedResultRef.index} is not a daccGuardianGroupInfo call (found ${_optionalChain([resultExt, 'optionalAccess', _90 => _90.method, 'optionalAccess', _91 => _91.section])}.${_optionalChain([resultExt, 'optionalAccess', _92 => _92.method, 'optionalAccess', _93 => _93.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 = _optionalChain([prefs, 'access', _54 => _54.compute, 'optionalAccess', _55 => _55.split, 'call', _56 => _56(","), 'access', _57 => _57.map, 'call', _58 => _58((s) => s.trim()), 'access', _59 => _59.filter, 'call', _60 => _60((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: _optionalChain([computeOpts, 'optionalAccess', _61 => _61.includes, 'call', _62 => _62("trusted")]) || false,
-      tee: _optionalChain([computeOpts, 'optionalAccess', _63 => _63.includes, 'call', _64 => _64("tee")]) || false,
-      mpc: _optionalChain([computeOpts, 'optionalAccess', _65 => _65.includes, 'call', _66 => _66("mpc")]) || false,
-      fhe: _optionalChain([computeOpts, 'optionalAccess', _67 => _67.includes, 'call', _68 => _68("fhe")]) || false,
-      zkp: _optionalChain([computeOpts, 'optionalAccess', _69 => _69.includes, 'call', _70 => _70("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);
@@ -1144,12 +1332,27 @@ 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: _nullishCoalesce(_optionalChain([tx_result, 'access', _71 => _71.blockNumber, 'optionalAccess', _72 => _72.toNumber, 'call', _73 => _73()]), () => ( 0)),
+    blockNumber: _nullishCoalesce(_optionalChain([tx_result, 'access', _94 => _94.blockNumber, 'optionalAccess', _95 => _95.toNumber, 'call', _96 => _96()]), () => ( 0)),
     index: _nullishCoalesce(tx_result.txIndex, () => ( 0)),
     hash: tx_result.txHash.toHex(),
     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]];
@@ -1163,7 +1366,7 @@ var getGuardianAddress = async () => {
   const api2 = await getApi();
   if (!api2) throw new Error("API not initialized");
   assert(
-    _util.isFunction.call(void 0, _optionalChain([api2, 'access', _74 => _74.query, 'access', _75 => _75["guardian"], 'optionalAccess', _76 => _76["workerByKey"]])),
+    _util.isFunction.call(void 0, _optionalChain([api2, 'access', _97 => _97.query, 'access', _98 => _98["guardian"], 'optionalAccess', _99 => _99["workerByKey"]])),
     `api.query.guardian.workerByKey does not exist`
   );
   const list = await getGuardianList();
@@ -1183,7 +1386,7 @@ var getGuardianNwParams = async () => {
     const section = "guardian";
     const method = "guardianNwParams";
     assert(
-      _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _77 => _77[section], 'optionalAccess', _78 => _78[method]])),
+      _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _100 => _100[section], 'optionalAccess', _101 => _101[method]])),
       `api.rpc.${section}.guardianNwParams does not exist`
     );
     const guardianNwParams = await rpc[section][method]();
@@ -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(
+    _util.isFunction.call(void 0, _optionalChain([api2, 'access', _102 => _102.query, 'access', _103 => _103["compute"], 'optionalAccess', _104 => _104["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;
+      _optionalChain([unsubFn, 'optionalCall', _105 => _105()]);
+      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");
@@ -1265,7 +1515,7 @@ async function watchForSubmissionReceipt(requestId, timeoutMs = 10 * 60 * 1e3) {
     const cleanup = (settleFn) => {
       if (settled) return;
       settled = true;
-      _optionalChain([unsubFn, 'optionalCall', _79 => _79()]);
+      _optionalChain([unsubFn, 'optionalCall', _106 => _106()]);
       settleFn();
     };
     const timer = setTimeout(
@@ -1282,10 +1532,10 @@ async function watchForSubmissionReceipt(requestId, timeoutMs = 10 * 60 * 1e3) {
         for (let i = 0; i < extrinsics.length; i++) {
           const ext = extrinsics[i];
           const decoded = ext.toHuman();
-          const method = _optionalChain([decoded, 'optionalAccess', _80 => _80.method]);
-          if (String(_nullishCoalesce(_optionalChain([method, 'optionalAccess', _81 => _81.section]), () => ( ""))).toLowerCase() === "compute" && String(_nullishCoalesce(_optionalChain([method, 'optionalAccess', _82 => _82.method]), () => ( ""))).toLowerCase() === "result") {
-            const args = _optionalChain([method, 'optionalAccess', _83 => _83.args]);
-            const onChainId = String(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([args, 'optionalAccess', _84 => _84.request_id]), () => ( _optionalChain([args, 'optionalAccess', _85 => _85.requestId]))), () => ( _optionalChain([args, 'optionalAccess', _86 => _86[0]]))), () => ( "")));
+          const method = _optionalChain([decoded, 'optionalAccess', _107 => _107.method]);
+          if (String(_nullishCoalesce(_optionalChain([method, 'optionalAccess', _108 => _108.section]), () => ( ""))).toLowerCase() === "compute" && String(_nullishCoalesce(_optionalChain([method, 'optionalAccess', _109 => _109.method]), () => ( ""))).toLowerCase() === "result") {
+            const args = _optionalChain([method, 'optionalAccess', _110 => _110.args]);
+            const onChainId = String(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([args, 'optionalAccess', _111 => _111.request_id]), () => ( _optionalChain([args, 'optionalAccess', _112 => _112.requestId]))), () => ( _optionalChain([args, 'optionalAccess', _113 => _113[0]]))), () => ( "")));
             if (onChainId === requestId) {
               clearTimeout(timer);
               cleanup(
@@ -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(_nullishCoalesce(event.section, () => ( ""))).toLowerCase() !== "compute" || String(_nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(dataHuman["requestId"], () => ( dataHuman["request_id"])), () => ( dataHuman["id"]));
+    if (id != null) return String(id);
   }
   return null;
 }
@@ -1437,15 +1683,15 @@ 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: _nullishCoalesce(_optionalChain([result, 'access', _87 => _87.blockNumber, 'optionalAccess', _88 => _88.toNumber, 'call', _89 => _89()]), () => ( 0)),
+            blockNumber: _nullishCoalesce(_optionalChain([result, 'access', _114 => _114.blockNumber, 'optionalAccess', _115 => _115.toNumber, 'call', _116 => _116()]), () => ( 0)),
             index: _nullishCoalesce(result.txIndex, () => ( 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,17 +1802,113 @@ var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
   return new MCryptFs(mcryptApi, metadataRef, metadata);
 };
 
+// src/chain/blocks.ts
+
+async function getLatestBlocks(count, page = 0, apiInstance) {
+  await _wasmcrypto.waitReady.call(void 0, );
+  const api2 = await _asyncNullishCoalesce(apiInstance, async () => ( 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: _nullishCoalesce(_optionalChain([derived, 'optionalAccess', _117 => _117.author, 'optionalAccess', _118 => _118.toString, 'optionalCall', _119 => _119()]), () => ( "")),
+        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(_optionalChain([identityHuman, 'optionalAccess', _120 => _120.info, 'optionalAccess', _121 => _121.display]))
+  };
+}
+
 // src/compute/agreement.ts
 function buildFee(fee) {
   return {
-    fees: toAtomicPaliAmount(_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _90 => _90.amount]), () => ( "0"))),
-    computeRate: toAtomicPaliAmount(_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _91 => _91.computeRate]), () => ( "0")))
+    fees: toAtomicPaliAmount(_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _122 => _122.amount]), () => ( "0"))),
+    computeRate: toAtomicPaliAmount(_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _123 => _123.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: _nullishCoalesce(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, _nullishCoalesce(oracle_quore_id, () => ( null)));
+  const onChainContract = { currencyId: "Native", ...contract };
+  const tx = api2.tx["compute"]["agreement"](onChainContract, _nullishCoalesce(oracle_quore_id, () => ( null)));
   const opts = {
     compute: {
       daType: 1,
@@ -1580,18 +1922,14 @@ 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 {
         blockNumber,
         index: _nullishCoalesce(index, () => ( 0)),
         hash,
-        agreementId: _nullishCoalesce(_optionalChain([agreementCreatedEvent, 'access', _92 => _92.event, 'access', _93 => _93.data, 'access', _94 => _94[0], 'optionalAccess', _95 => _95.toHex, 'optionalCall', _96 => _96()]), () => ( agreementCreatedEvent.event.data.toString()))
+        agreementId: _nullishCoalesce(_optionalChain([agreementCreatedEvent, 'access', _124 => _124.event, 'access', _125 => _125.data, 'access', _126 => _126[0], 'optionalAccess', _127 => _127.toHex, 'optionalCall', _128 => _128()]), () => ( agreementCreatedEvent.event.data.toString()))
       };
     } else {
       debugLog("AgreementCreated event not found");
@@ -1599,6 +1937,17 @@ async function createAgreement(contract, account, oracle_quore_id = void 0) {
   }
   return { blockNumber, index: _nullishCoalesce(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: _nullishCoalesce(params.deadline, () => ( 0)),
     confidentiality: { Trusted: _nullishCoalesce(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 = _optionalChain([api2, 'access', _129 => _129.consts, 'access', _130 => _130.babe, 'optionalAccess', _131 => _131.expectedBlockTime]);
+  if (expectedBlockTime) {
+    return BigInt(expectedBlockTime.toString());
+  }
+  const minimumPeriod = _optionalChain([api2, 'access', _132 => _132.consts, 'access', _133 => _133.timestamp, 'optionalAccess', _134 => _134.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(
+    _optionalChain([api2, 'access', _135 => _135.query, 'access', _136 => _136.compute, 'optionalAccess', _137 => _137.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(_nullishCoalesce(_nullishCoalesce(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
+
+
+// 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: _nullishCoalesce(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"](
+    _ed25519.edwardsToMontgomeryPub.call(void 0, 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);
@@ -1692,8 +2200,8 @@ async function getGuardianParticipants() {
     const _peerid = _bs582.default.decode((peerid || "").toString());
     const account = await api2.query.guardian.workerByKey(_peerid.slice(6, 38));
     const nextIndex = currentIndex ? Number(currentIndex) + 1 : 1;
-    const guardiansList = _optionalChain([guardians, 'optionalAccess', _97 => _97.toJSON, 'call', _98 => _98()]) || [];
-    const nextGuardiansList = _optionalChain([nextGuardians, 'optionalAccess', _99 => _99.toJSON, 'call', _100 => _100()]) || [];
+    const guardiansList = _optionalChain([guardians, 'optionalAccess', _138 => _138.toJSON, 'call', _139 => _139()]) || [];
+    const nextGuardiansList = _optionalChain([nextGuardians, 'optionalAccess', _140 => _140.toJSON, 'call', _141 => _141()]) || [];
     const buildDetails = async (list) => {
       return Promise.all(
         list.map(async (guardian) => {
@@ -1702,21 +2210,21 @@ async function getGuardianParticipants() {
           const bonded = await api2.query.staking.bonded(guardian);
           const payee = await api2.query.staking.payee(guardian);
           const stakersOverview = await api2.query.staking.erasStakersOverview(
-            _optionalChain([currentEra, 'optionalAccess', _101 => _101.toPrimitive, 'call', _102 => _102()]),
+            _optionalChain([currentEra, 'optionalAccess', _142 => _142.toPrimitive, 'call', _143 => _143()]),
             guardian
           );
           const guardianErasPrefs = await api2.query.staking.erasGuardianPrefs(
-            _optionalChain([currentEra, 'optionalAccess', _103 => _103.toPrimitive, 'call', _104 => _104()]),
+            _optionalChain([currentEra, 'optionalAccess', _144 => _144.toPrimitive, 'call', _145 => _145()]),
             guardian
           );
           return {
             guardian,
-            rewardDestination: _optionalChain([payee, 'optionalAccess', _105 => _105.toHuman]) ? payee.toHuman() : null,
-            currentPreferences: _optionalChain([guardianErasPrefs, 'optionalAccess', _106 => _106.toHuman]) ? guardianErasPrefs.toHuman() : null,
-            upcomingPreferences: _optionalChain([guardianPrefs, 'optionalAccess', _107 => _107.toHuman]) ? guardianPrefs.toHuman() : null,
-            stash: _optionalChain([bonded, 'optionalAccess', _108 => _108.toHuman]) ? bonded.toHuman() : null,
-            currentStakeOverview: _optionalChain([stakersOverview, 'optionalAccess', _109 => _109.toHuman]) ? stakersOverview.toHuman() : null,
-            upcomingStakeOverview: _optionalChain([ledger, 'optionalAccess', _110 => _110.toHuman]) ? ledger.toHuman() : null
+            rewardDestination: _optionalChain([payee, 'optionalAccess', _146 => _146.toHuman]) ? payee.toHuman() : null,
+            currentPreferences: _optionalChain([guardianErasPrefs, 'optionalAccess', _147 => _147.toHuman]) ? guardianErasPrefs.toHuman() : null,
+            upcomingPreferences: _optionalChain([guardianPrefs, 'optionalAccess', _148 => _148.toHuman]) ? guardianPrefs.toHuman() : null,
+            stash: _optionalChain([bonded, 'optionalAccess', _149 => _149.toHuman]) ? bonded.toHuman() : null,
+            currentStakeOverview: _optionalChain([stakersOverview, 'optionalAccess', _150 => _150.toHuman]) ? stakersOverview.toHuman() : null,
+            upcomingStakeOverview: _optionalChain([ledger, 'optionalAccess', _151 => _151.toHuman]) ? ledger.toHuman() : null
           };
         })
       );
@@ -1725,19 +2233,19 @@ async function getGuardianParticipants() {
     const upcomingGuardians = await buildDetails(nextGuardiansList);
     return {
       nwState: {
-        localPeerId: _optionalChain([peerid, 'optionalAccess', _111 => _111.toString, 'call', _112 => _112()]),
-        worker: _optionalChain([account, 'optionalAccess', _113 => _113.toHuman]) ? account.toHuman() : null,
-        currentEra: _optionalChain([currentEra, 'optionalAccess', _114 => _114.toHuman]) ? currentEra.toHuman() : null,
-        guardians: JSON.stringify(_optionalChain([guardians, 'optionalAccess', _115 => _115.toHuman]) ? guardians.toHuman() : null, null, 2),
-        nextGuardians: JSON.stringify(_optionalChain([nextGuardians, 'optionalAccess', _116 => _116.toHuman]) ? nextGuardians.toHuman() : null, null, 2),
-        currentIndex: _optionalChain([currentIndex, 'optionalAccess', _117 => _117.toHuman]) ? currentIndex.toHuman() : null,
+        localPeerId: _optionalChain([peerid, 'optionalAccess', _152 => _152.toString, 'call', _153 => _153()]),
+        worker: _optionalChain([account, 'optionalAccess', _154 => _154.toHuman]) ? account.toHuman() : null,
+        currentEra: _optionalChain([currentEra, 'optionalAccess', _155 => _155.toHuman]) ? currentEra.toHuman() : null,
+        guardians: JSON.stringify(_optionalChain([guardians, 'optionalAccess', _156 => _156.toHuman]) ? guardians.toHuman() : null, null, 2),
+        nextGuardians: JSON.stringify(_optionalChain([nextGuardians, 'optionalAccess', _157 => _157.toHuman]) ? nextGuardians.toHuman() : null, null, 2),
+        currentIndex: _optionalChain([currentIndex, 'optionalAccess', _158 => _158.toHuman]) ? currentIndex.toHuman() : null,
         nextIndex
       },
       currentGuardians,
       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: _nullishCoalesce(params.deadline, () => ( 0)),
+    confidentiality: { Trusted: _nullishCoalesce(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
+
+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 = _util.u8aToHex.call(void 0, guardian.sign(`${auctionId}:${rate}`));
+  await costEstimationClient.post(
+    `/auctions/${encodeURIComponent(auctionId)}/bid`,
+    { guardian: guardian.address, rate, signature }
+  );
+}
+
+// src/costEstimation/webhook.ts
+
+async function registerGuardianWebhook(url, guardian) {
+  const signature = _util.u8aToHex.call(void 0, 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 = _nullishCoalesce(params.cipher, () => ( "Plaintext"));
   const resultCipher = _nullishCoalesce(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,
@@ -2097,9 +2759,9 @@ async function removeStake(account) {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
-  const stakeAmount = await _asyncOptionalChain([(await api2.query.staking.ledger(account.address)), 'optionalAccess', async _118 => _118.toPrimitive, 'call', async _119 => _119()]);
-  debugLog("Removing entire stake amount:", formatPaliAmount(_optionalChain([stakeAmount, 'optionalAccess', _120 => _120.active]) || 0n));
-  const unstakeTx = api2.tx.staking.unbond(_optionalChain([stakeAmount, 'optionalAccess', _121 => _121.active]) || 0n);
+  const stakeAmount = await _asyncOptionalChain([(await api2.query.staking.ledger(account.address)), 'optionalAccess', async _159 => _159.toPrimitive, 'call', async _160 => _160()]);
+  debugLog("Removing entire stake amount:", formatPaliAmount(_optionalChain([stakeAmount, 'optionalAccess', _161 => _161.active]) || 0n));
+  const unstakeTx = api2.tx.staking.unbond(_optionalChain([stakeAmount, 'optionalAccess', _162 => _162.active]) || 0n);
   const hash = await signAndSend(unstakeTx, account);
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
 }
@@ -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 (e) {
+      }
+      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 = (_nullishCoalesce(options.baseUrl, () => ( DEFAULT_BASE_URL))).replace(/\/+$/, "").replace(/\/api$/i, "");
+    this._fetch = _nullishCoalesce(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 (e2) {
+      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,
+        _nullishCoalesce(_optionalChain([errBody, 'optionalAccess', _163 => _163.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(_optionalChain([compute, 'optionalAccess', _164 => _164.input, 'optionalAccess', _165 => _165.contractId]));
+  const programId = nestedContractId(_optionalChain([compute, 'optionalAccess', _166 => _166.program, 'optionalAccess', _167 => _167.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) => _optionalChain([item, 'optionalAccess', _168 => _168.contractId]) === id);
+  if (!looksLikeSelfOnly) {
+    return {
+      ...response,
+      data: list.filter((item) => _optionalChain([item, 'optionalAccess', _169 => _169.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 _nullishCoalesce(_optionalChain([item, 'access', _170 => _170.indexer, 'optionalAccess', _171 => _171.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: _optionalChain([result, 'access', _172 => _172.feeBreakdown, 'optionalAccess', _173 => _173.submitorFee, 'optionalAccess', _174 => _174.amount]),
+    fee: _optionalChain([result, 'access', _175 => _175.feeBreakdown, 'optionalAccess', _176 => _176.resultFee]),
+    decryptionFee: _optionalChain([result, 'access', _177 => _177.feeBreakdown, 'optionalAccess', _178 => _178.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(_nullishCoalesce(item.jobId, () => ( ""))) && !ids.has(_nullishCoalesce(item.contractId, () => ( "")))
+  );
+  return normalizeComputes([...fromResults, ...extras]);
+}
+function withParties(agreement) {
+  if (_optionalChain([agreement, 'access', _179 => _179.parties, 'optionalAccess', _180 => _180.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 (_nullishCoalesce(_optionalChain([agreement, 'access', _181 => _181.responses, 'optionalAccess', _182 => _182.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 = _nullishCoalesce(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 (${_nullishCoalesce(_optionalChain([agreement, 'access', _183 => _183.responses, 'optionalAccess', _184 => _184.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: _optionalChain([latest, 'optionalAccess', _185 => _185.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: _optionalChain([latest, 'optionalAccess', _186 => _186.computeReward]),
+        decryptionFee: _optionalChain([latest, 'optionalAccess', _187 => _187.decryptionFee]),
+        fee: _optionalChain([latest, 'optionalAccess', _188 => _188.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(
+    (_nullishCoalesce(results, () => ( []))).map(resultToCompute),
+    normalizeComputes(compute)
+  );
+  const latest = _nullishCoalesce(computes[computes.length - 1], () => ( null));
+  return {
+    success: true,
+    data: {
+      agreement,
+      compute: latest,
+      computes,
+      results: _nullishCoalesce(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 = _nullishCoalesce(group.guardians, () => ( []));
+    const names = _nullishCoalesce(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 = _nullishCoalesce(group.guardians, () => ( []));
+    const names = _nullishCoalesce(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 _nullishCoalesce(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
 
 
 async function rotateAndSetKeys(account) {
   const api2 = await getApi();
   _assert2.default.call(void 0, api2, "API not initialized");
-  debugLog(`Rotating session keys for ${account.meta.name} on ${provider.endpoint}`);
+  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}:`, _nullishCoalesce(_optionalChain([newKeys, 'optionalAccess', _122 => _122.toHex, 'optionalCall', _123 => _123()]), () => ( newKeys)));
+  debugLog(`${account.meta.name} rotated keys on ${getProvider().endpoint}:`, _nullishCoalesce(_optionalChain([newKeys, 'optionalAccess', _189 => _189.toHex, 'optionalCall', _190 => _190()]), () => ( newKeys)));
   const setKeysTx = api2.tx.session.setKeys(newKeys, []);
   const hash = await signAndSend(setKeysTx, account);
   debugLog(`Rotate session transaction sent with hash: ${hash.hash}`);
@@ -2739,5 +3946,84 @@ _ss58 = new WeakMap();
 
 
 
-exports.API_EXTENSIONS = API_EXTENSIONS; exports.API_RPC = API_RPC; exports.API_TYPES = API_TYPES; exports.AccountSourceType = AccountSourceType; exports.ApiPromise = _api2.ApiPromise; exports.CryptoType = CryptoType; exports.DEBUG = DEBUG; exports.DEFAULT_COMPUTE_PAYLOAD = DEFAULT_COMPUTE_PAYLOAD; exports.DEFAULT_EMPTY_PAYLOAD = DEFAULT_EMPTY_PAYLOAD; exports.FileFromMetadataRef = FileFromMetadataRef; exports.HttpProvider = _api2.HttpProvider; exports.Keyring = Keyring3; exports.MCryptFs = MCryptFs; exports.MCryptFsReader = MCryptFsReader; exports.MCryptFsWriter = MCryptFsWriter; exports.PALI_DECIMALS = PALI_DECIMALS; exports.PALI_SYMBOL = PALI_SYMBOL; exports.PALLIORA_RPC_URL = PALLIORA_RPC_URL; exports.PALLIORA_WS = PALLIORA_WS; exports.TX_WAIT_FINALIZATION = TX_WAIT_FINALIZATION; exports.WsProvider = _api2.WsProvider; exports.addStake = addStake; exports.base64ToUint8Array = base64ToUint8Array; exports.buildFee = buildFee; exports.clearTokenCache = clearTokenCache; exports.configure = configure; exports.createAccount = createAccount; exports.createAgreement = createAgreement; exports.createGuardianGroup = createGuardianGroup; exports.createGuardianGroupAndWatch = createGuardianGroupAndWatch; exports.createSimpleAgreement = createSimpleAgreement; exports.dataContract = dataContract; exports.debugLog = debugLog; exports.decodeAggregateKey = decodeAggregateKey; exports.decodeField = decodeField; exports.decodePowersOfTau = decodePowersOfTau; exports.decrypt = decrypt; exports.ecncryptTest = encrypt; exports.encodeCiphertext = encodeCiphertext; exports.encrypt = encrypt2; exports.fetchAndDecodeExtrinsic = fetchAndDecodeExtrinsic; exports.fetchTokenProperties = fetchTokenProperties; exports.formatBalanceWithTokenProperties = formatBalanceWithTokenProperties; exports.formatPaliAmount = formatPaliAmount; exports.fromAtomicPaliAmount = fromAtomicPaliAmount; exports.fundAccount = fundAccount; exports.gen_shared_key = gen_shared_key; exports.gen_stretched_key = gen_stretched_key; exports.generateRandomBytes = generateRandomBytes; exports.getAgreementCreatedRequestId = getAgreementCreatedRequestId; exports.getApi = getApi; exports.getCachedTokenProperties = getCachedTokenProperties; exports.getEncKeyring = getEncKeyring; exports.getFileMetadataCall = getFileMetadataCall; exports.getGuardianAddress = getGuardianAddress; exports.getGuardianList = getGuardianList; exports.getGuardianNwParams = getGuardianNwParams; exports.getGuardianParticipants = getGuardianParticipants; exports.getKeyring = getKeyring; exports.hexToUint8Array = hexToUint8Array; exports.inferenceCompute = inferenceCompute; exports.joinGuardian = joinGuardian; exports.joinIdleStaker = joinIdleStaker; exports.joinValidator = joinValidator; exports.newStake = newStake; exports.pairFromPrivateKeyHex = pairFromPrivateKeyHex; exports.payoutStake = payoutStake; exports.provider = provider; exports.reduceStake = reduceStake; exports.registerDataAgreement = registerDataAgreement; exports.removeStake = removeStake; exports.rotateAndSetKeys = rotateAndSetKeys; exports.runAgent = runAgent; exports.scanForBlockEvent = scanForBlockEvent; exports.setIdentity = setIdentity; exports.setWorker = setWorker; exports.signAndSend = signAndSend; exports.simpleCompute = simpleCompute; exports.submitData = submitData; exports.submitTEData = submitTEData; exports.submitTEDataWithCipher = submitTEDataWithCipher; exports.testCrypt = testCrypt; exports.toAtomicPaliAmount = toAtomicPaliAmount; exports.tokenToBigint = tokenToBigint; exports.transfer = transfer; exports.uint8ArrayToBase64 = uint8ArrayToBase64; exports.uploadData = uploadData; exports.uploadDataLegacy = uploadDataLegacy; exports.utilCrypto = utilCrypto; exports.wasmCrypto = wasmCrypto; exports.watchForSubmissionReceipt = watchForSubmissionReceipt; exports.withdrawStake = withdrawStake; exports.writeMetadata = writeMetadata;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.API_EXTENSIONS = API_EXTENSIONS; exports.API_RPC = API_RPC; exports.API_TYPES = API_TYPES; exports.AccountSourceType = AccountSourceType; exports.ApiPromise = _api2.ApiPromise; exports.COMPUTE_TYPES = COMPUTE_TYPES; exports.CostEstimationError = CostEstimationError; exports.CryptoType = CryptoType; exports.DEFAULT_COMPUTE_PAYLOAD = DEFAULT_COMPUTE_PAYLOAD; exports.DEFAULT_EMPTY_PAYLOAD = DEFAULT_EMPTY_PAYLOAD; exports.FileFromMetadataRef = FileFromMetadataRef; exports.HttpProvider = _api2.HttpProvider; exports.IndexerClient = IndexerClient; exports.IndexerHttpError = IndexerHttpError; exports.Keyring = Keyring3; exports.MCryptFs = MCryptFs; exports.MCryptFsReader = MCryptFsReader; exports.MCryptFsWriter = MCryptFsWriter; exports.NO_GUARDIAN_GROUP = NO_GUARDIAN_GROUP; exports.PALI_DECIMALS = PALI_DECIMALS; exports.PALI_SYMBOL = PALI_SYMBOL; exports.S3Provider = S3Provider; exports.StorageRouter = StorageRouter; exports.WsProvider = _api2.WsProvider; exports.addStake = addStake; exports.base64ToUint8Array = base64ToUint8Array; exports.buildComputeMetadata = buildComputeMetadata; exports.buildContractPhases = buildContractPhases; exports.buildFee = buildFee; exports.clearTokenCache = clearTokenCache; exports.createAccount = createAccount; exports.createAccountFromMagicLink = createAccountFromMagicLink; exports.createAgreement = createAgreement; exports.createGuardianGroup = createGuardianGroup; exports.createGuardianGroupAndWatch = createGuardianGroupAndWatch; exports.createSimpleAgreement = createSimpleAgreement; exports.dataContract = dataContract; exports.debugLog = debugLog; exports.decodeAggregateKey = decodeAggregateKey; exports.decodeField = decodeField; exports.decodePowersOfTau = decodePowersOfTau; exports.decrypt = decrypt; exports.deriveContractStatus = deriveContractStatus; exports.disconnectApi = disconnectApi; exports.ecncryptTest = encrypt; exports.encodeCiphertext = encodeCiphertext; exports.encrypt = encrypt2; exports.encryptedInferenceCompute = encryptedInferenceCompute; exports.encryptedInferenceSubscription = encryptedInferenceSubscription; exports.encryptedInferenceSubscriptionInvocation = encryptedInferenceSubscriptionInvocation; exports.estimateMinFee = estimateMinFee; exports.fetchAndDecodeExtrinsic = fetchAndDecodeExtrinsic; exports.fetchTokenProperties = fetchTokenProperties; exports.findEvent = findEvent; exports.formatBalanceWithTokenProperties = formatBalanceWithTokenProperties; exports.formatPaliAmount = formatPaliAmount; exports.fromAtomicPaliAmount = fromAtomicPaliAmount; exports.fundAccount = fundAccount; exports.gen_shared_key = gen_shared_key; exports.gen_stretched_key = gen_stretched_key; exports.generateRandomBytes = generateRandomBytes; exports.getAccess = getAccess; exports.getAccountInfo = getAccountInfo; exports.getActiveGuardians = getActiveGuardians; exports.getAddress = getAddress; exports.getAddresses = getAddresses; exports.getAgents = getAgents; exports.getAgreementCreatedRequestId = getAgreementCreatedRequestId; exports.getApi = getApi; exports.getArtefact = getArtefact; exports.getArtefactAccess = getArtefactAccess; exports.getArtefactContracts = getArtefactContracts; exports.getArtefactFlow = getArtefactFlow; exports.getArtefacts = getArtefacts; exports.getArtefactsByStoreType = getArtefactsByStoreType; exports.getAuction = getAuction; exports.getAuthServiceUrl = getAuthServiceUrl; exports.getAwsRegion = getAwsRegion; exports.getAwsS3Bucket = getAwsS3Bucket; exports.getBalance = getBalance; exports.getBlob = getBlob; exports.getBlocks = getBlocks; exports.getCachedTokenProperties = getCachedTokenProperties; exports.getCall = getCall; exports.getCallArgs = getCallArgs; exports.getCallMetadata = getCallMetadata; exports.getCompute = getCompute; exports.getContract = getContract; exports.getContractFlow = getContractFlow; exports.getContractInfo = getContractInfo; exports.getContracts = getContracts; exports.getCostEstimatorUrl = getCostEstimatorUrl; exports.getDatasets = getDatasets; exports.getEncKeyring = getEncKeyring; exports.getEstimateResult = getEstimateResult; exports.getExecutables = getExecutables; exports.getExtrinsic = getExtrinsic; exports.getExtrinsics = getExtrinsics; exports.getFeeParams = getFeeParams; exports.getFileMetadataCall = getFileMetadataCall; exports.getGuardian = getGuardian; exports.getGuardianAddress = getGuardianAddress; exports.getGuardianGroup = getGuardianGroup; exports.getGuardianGroupInfo = getGuardianGroupInfo; exports.getGuardianGroups = getGuardianGroups; exports.getGuardianList = getGuardianList; exports.getGuardianNwParams = getGuardianNwParams; exports.getGuardianParticipants = getGuardianParticipants; exports.getGuardians = getGuardians; exports.getKeyring = getKeyring; exports.getLatestBlocks = getLatestBlocks; exports.getModels = getModels; exports.getPallioraRpcUrl = getPallioraRpcUrl; exports.getPallioraWs = getPallioraWs; exports.getProvider = getProvider; exports.getResult = getResult; exports.getResults = getResults; exports.getTransfers = getTransfers; exports.healthCheck = healthCheck; exports.hexToUint8Array = hexToUint8Array; exports.inferenceCompute = inferenceCompute; exports.init = init; exports.invokeAgreement = invokeAgreement; exports.isArtefactUsage = isArtefactUsage; exports.isDebug = isDebug; exports.isInitialized = isInitialized; exports.joinGuardian = joinGuardian; exports.joinIdleStaker = joinIdleStaker; exports.joinValidator = joinValidator; exports.listGuardianAuctions = listGuardianAuctions; exports.listOpenAuctions = listOpenAuctions; exports.listResolvedGuardianAuctions = listResolvedGuardianAuctions; exports.newStake = newStake; exports.normalizeComputes = normalizeComputes; exports.pairFromPrivateKeyHex = pairFromPrivateKeyHex; exports.payoutStake = payoutStake; exports.reduceStake = reduceStake; exports.registerDataAgreement = registerDataAgreement; exports.registerGuardianWebhook = registerGuardianWebhook; exports.removeStake = removeStake; exports.resetConfig = resetConfig; exports.resultToCompute = resultToCompute; exports.retrySignAndSend = retrySignAndSend; exports.rotateAndSetKeys = rotateAndSetKeys; exports.runAgent = runAgent; exports.scanForBlockEvent = scanForBlockEvent; exports.setIdentity = setIdentity; exports.setWorker = setWorker; exports.signAndSend = signAndSend; exports.simpleCompute = simpleCompute; exports.startEstimate = startEstimate; exports.storageRouter = storageRouter; exports.storedCompute = storedCompute; exports.submitAuctionBid = submitAuctionBid; exports.submitData = submitData; exports.submitTEData = submitTEData; exports.submitTEDataWithCipher = submitTEDataWithCipher; exports.testCrypt = testCrypt; exports.toAtomicPaliAmount = toAtomicPaliAmount; exports.tokenToBigint = tokenToBigint; exports.transfer = transfer; exports.uint8ArrayToBase64 = uint8ArrayToBase64; exports.uploadData = uploadData; exports.uploadDataLegacy = uploadDataLegacy; exports.utilCrypto = utilCrypto; exports.waitForEstimate = waitForEstimate; exports.waitForNextBlock = waitForNextBlock; exports.waitsForFinalization = waitsForFinalization; exports.wasmCrypto = wasmCrypto; exports.watchForSubmissionReceipt = watchForSubmissionReceipt; exports.withdrawStake = withdrawStake; exports.writeMetadata = writeMetadata;
 //# sourceMappingURL=index.cjs.map