@palliora.org/chainsdk 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -220,12 +220,144 @@ var API_TYPES = {
     extra: "CheckAppIdExtra",
     types: "CheckAppIdTypes"
   },
+  FeePayload: {
+    compute: "u128",
+    guardian: "u128",
+    verifier: "u128"
+  },
+  SilentThresholdParams: {
+    td_params: "Vec<u8>",
+    pk_bytes: "Vec<u8>",
+    tau_params: "Vec<u8>"
+  },
+  ThresholdAlgos: {
+    _enum: {
+      SilentThreshold: "SilentThresholdParams"
+    }
+  },
+  ChaCha20Poly1305Params: {
+    nonce: "[u8; 12]"
+  },
+  Aes256GcmParams: {
+    nonce: "[u8; 12]"
+  },
+  SymmetricAlgos: {
+    _enum: {
+      ChaCha20Poly1305: "ChaCha20Poly1305Params",
+      Aes256Gcm: "Aes256GcmParams"
+    }
+  },
+  CipherSuiteEncrypted: {
+    threshold: "ThresholdAlgos",
+    symmetric: "SymmetricAlgos"
+  },
+  CipherSuite: {
+    _enum: {
+      Plaintext: "Null",
+      Encrypted: "CipherSuiteEncrypted"
+    }
+  },
+  ConfidentialityLevel: {
+    _enum: ["Trusted", "TEE", "FHE", "SMPC"]
+  },
+  NativeExecuteDA: {
+    _enum: ["Inference"]
+  },
+  NativeDataDA: {
+    _enum: ["DaFalse", "DaTrue"]
+  },
+  DAInputInline: {
+    data: "Vec<u8>"
+  },
+  DAInputChainTransaction: {
+    block_number: "u64",
+    extrinsic_index: "u32"
+  },
+  DAInputIpfs: {
+    cid: "Vec<u8>",
+    size: "u64"
+  },
+  DAInputUrl: {
+    url: "Vec<u8>",
+    size: "u64",
+    hash: "Option<Vec<u8>>"
+  },
+  DAInput: {
+    _enum: {
+      Inline: "DAInputInline",
+      ChainTransaction: "DAInputChainTransaction",
+      Ipfs: "DAInputIpfs",
+      Url: "DAInputUrl",
+      NativeExecute: "NativeExecuteDA",
+      NativeData: "NativeDataDA"
+    }
+  },
+  ContractType: {
+    _enum: {
+      Dormant: "Dormant",
+      Active: "Active"
+    }
+  },
+  StoreType: {
+    _enum: {
+      Dataset: "Dataset",
+      Model: "Model",
+      Agent: "Agent",
+      Other: "Other"
+    }
+  },
+  ComputeMetadata: {
+    name: "Vec<u8>",
+    description: "Vec<u8>",
+    store_type: "StoreType",
+    group_id: "H256"
+  },
+  ComputeInfo: {
+    cipher: "CipherSuite",
+    computer_indices: "Vec<u32>",
+    fees: "u128",
+    deadline: "u64",
+    confidentiality: "ConfidentialityLevel",
+    fee_function: "Option<u8>",
+    program_env: "Option<Vec<u8>>",
+    input: "DAInput",
+    program: "DAInput",
+    metadata: "Option<ComputeMetadata>"
+  },
+  Contract: {
+    contract_type: "ContractType",
+    guardians: "Vec<AccountId>",
+    pre_check: "Option<ComputeInfo>",
+    compute: "ComputeInfo",
+    post_check: "Option<ComputeInfo>",
+    result_cipher: "CipherSuite"
+  },
+  AgreementInfo: {
+    status: "AgreementStatus",
+    creator: "AccountId",
+    index: "u32"
+  },
   ComputePayload: {
     da_type: "u8",
     agreement: "Option<BoundedVec<[u8; 32], 10>>",
     verification: "u8",
     compute: "u8"
   },
+  ComputePrefs: {
+    trusted: "bool",
+    tee: "bool",
+    mpc: "bool",
+    fhe: "bool",
+    zkp: "bool"
+  },
+  GuardianPrefs: {
+    pubKey: "[u8; 32]",
+    guardian: "bool",
+    verifier: "bool",
+    compute: "bool",
+    computePrefs: "Option<ComputePrefs>",
+    feeThreshold: "u128"
+  },
   BlockLengthColumns: "Compact<u32>",
   BlockLengthRows: "Compact<u32>",
   BlockLength: {
@@ -398,7 +530,7 @@ var isValidHex = (hex) => {
   return /^[0-9A-Fa-f]*$/.test(hex) && hex.length % 2 === 0;
 };
 var decodeAggregateKey = (input) => {
-  const buffer = new Uint8Array(_optionalChain([input, 'access', _ => _.match, 'call', _2 => _2(/.{1,2}/g), 'optionalAccess', _3 => _3.map, 'call', _4 => _4((byte) => parseInt(byte, 16))]) || []);
+  const buffer = new Uint8Array(_optionalChain([input, 'access', _2 => _2.match, 'call', _3 => _3(/.{1,2}/g), 'optionalAccess', _4 => _4.map, 'call', _5 => _5((byte) => parseInt(byte, 16))]) || []);
   let offset = 0;
   const view = new DataView(buffer.buffer);
   const readBigUInt64LE = () => {
@@ -472,16 +604,16 @@ var decodeAggregateKey = (input) => {
 var encodeCiphertext = (input) => {
   const writeProjPointTypeFp = (point) => {
     const hex = point.toHex(true);
-    return new Uint8Array(_optionalChain([hex, 'access', _5 => _5.match, 'call', _6 => _6(/.{1,2}/g), 'optionalAccess', _7 => _7.map, 'call', _8 => _8((byte) => parseInt(byte, 16))]) || []);
+    return new Uint8Array(_optionalChain([hex, 'access', _6 => _6.match, 'call', _7 => _7(/.{1,2}/g), 'optionalAccess', _8 => _8.map, 'call', _9 => _9((byte) => parseInt(byte, 16))]) || []);
   };
   const writeProjPointTypeFp2 = (point) => {
     const hex = point.toHex(true);
-    return new Uint8Array(_optionalChain([hex, 'access', _9 => _9.match, 'call', _10 => _10(/.{1,2}/g), 'optionalAccess', _11 => _11.map, 'call', _12 => _12((byte) => parseInt(byte, 16))]) || []);
+    return new Uint8Array(_optionalChain([hex, 'access', _10 => _10.match, 'call', _11 => _11(/.{1,2}/g), 'optionalAccess', _12 => _12.map, 'call', _13 => _13((byte) => parseInt(byte, 16))]) || []);
   };
   const gamma_g2Buffer = writeProjPointTypeFp2(input.gamma_g2);
   const sa1Buffer = new Uint8Array(input.sa1.flatMap((p) => Array.from(writeProjPointTypeFp(p))));
   const sa2Buffer = new Uint8Array(input.sa2.flatMap((p) => Array.from(writeProjPointTypeFp2(p))));
-  const enc_keyBuffer = new Uint8Array(_optionalChain([fp12ToHex, 'call', _13 => _13(input.enc_key), 'access', _14 => _14.match, 'call', _15 => _15(/.{1,2}/g), 'optionalAccess', _16 => _16.map, 'call', _17 => _17((byte) => parseInt(byte, 16))]) || []);
+  const enc_keyBuffer = new Uint8Array(_optionalChain([fp12ToHex, 'call', _14 => _14(input.enc_key), 'access', _15 => _15.match, 'call', _16 => _16(/.{1,2}/g), 'optionalAccess', _17 => _17.map, 'call', _18 => _18((byte) => parseInt(byte, 16))]) || []);
   const tBuffer = new Uint8Array(8);
   new DataView(tBuffer.buffer).setBigUint64(0, BigInt(input.t), true);
   const totalLength = gamma_g2Buffer.length + sa1Buffer.length + sa2Buffer.length + enc_keyBuffer.length + tBuffer.length;
@@ -538,7 +670,7 @@ function bigintToBigEndianHex(value, length) {
     throw new Error("BigInt value is too large to fit in the specified length");
   }
   hex = hex.padStart(length * 2, "0");
-  const byteArray = _optionalChain([hex, 'access', _18 => _18.match, 'call', _19 => _19(/.{1,2}/g), 'optionalAccess', _20 => _20.map, 'call', _21 => _21((byte) => parseInt(byte, 16))]) || [];
+  const byteArray = _optionalChain([hex, 'access', _19 => _19.match, 'call', _20 => _20(/.{1,2}/g), 'optionalAccess', _21 => _21.map, 'call', _22 => _22((byte) => parseInt(byte, 16))]) || [];
   const reversedByteArray = byteArray.reverse();
   const bigEndianHex = reversedByteArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
   return bigEndianHex;
@@ -547,7 +679,7 @@ function reverseEndianess(hex) {
   if (hex.length % 2 !== 0) {
     throw new Error("Hex string must have an even length");
   }
-  return _optionalChain([hex, 'access', _22 => _22.match, 'call', _23 => _23(/.{1,2}/g), 'optionalAccess', _24 => _24.reverse, 'call', _25 => _25(), 'access', _26 => _26.join, 'call', _27 => _27("")]) || "";
+  return _optionalChain([hex, 'access', _23 => _23.match, 'call', _24 => _24(/.{1,2}/g), 'optionalAccess', _25 => _25.reverse, 'call', _26 => _26(), 'access', _27 => _27.join, 'call', _28 => _28("")]) || "";
 }
 
 // src/crypto/cipher.ts
@@ -599,10 +731,6 @@ function configure(opts) {
 }
 
 // src/utils/helper.ts
-var tokenToBigint = (arg) => {
-  const val = typeof arg === "bigint" ? arg : BigInt(arg);
-  return val * 10n ** 15n;
-};
 function hexToUint8Array(hex) {
   if (hex.length % 2 !== 0) {
     throw new Error("Invalid hex string");
@@ -653,23 +781,37 @@ var debugLog = (message, ...optionalParams) => {
 };
 
 // src/utils/token.ts
-
+var _viem = require('viem');
+var PALI_SYMBOL = "PALI";
+var PALI_DECIMALS = 18;
 var tokenCache = null;
+var toAtomicPaliAmount = (amount) => {
+  const normalizedAmount = String(amount).trim();
+  if (!normalizedAmount) {
+    throw new Error("Token amount cannot be empty");
+  }
+  return _viem.parseUnits.call(void 0, normalizedAmount, PALI_DECIMALS);
+};
+var fromAtomicPaliAmount = (amount) => {
+  return _viem.formatUnits.call(void 0, amount, PALI_DECIMALS);
+};
+var formatPaliAmount = (amount, symbol = PALI_SYMBOL) => {
+  return `${fromAtomicPaliAmount(amount)} ${symbol}`;
+};
 async function fetchTokenProperties() {
   if (tokenCache) {
     return tokenCache;
   }
   try {
-    const systemProperties = await _asyncOptionalChain([(await await _asyncOptionalChain([(await getApi()), 'optionalAccess', async _28 => _28.rpc, 'access', async _29 => _29.system, 'access', async _30 => _30.properties, 'call', async _31 => _31()])), 'optionalAccess', async _32 => _32.toHuman, 'call', async _33 => _33()]);
+    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()]);
     assert(systemProperties, "Failed to fetch system properties from RPC");
     const tokenProperties = {
-      symbol: (_optionalChain([systemProperties, 'optionalAccess', _34 => _34.tokenSymbol]) || ["UNIT"])[0],
-      decimals: Number((_optionalChain([systemProperties, 'optionalAccess', _35 => _35.tokenDecimals]) || ["18"])[0])
+      symbol: (_optionalChain([systemProperties, 'optionalAccess', _35 => _35.tokenSymbol]) || [PALI_SYMBOL])[0],
+      decimals: Number((_optionalChain([systemProperties, 'optionalAccess', _36 => _36.tokenDecimals]) || [String(PALI_DECIMALS)])[0])
     };
     tokenCache = tokenProperties;
     return tokenProperties;
   } catch (error) {
-    console.error("Failed to fetch token properties:", error);
     throw error;
   }
 }
@@ -681,17 +823,9 @@ function clearTokenCache() {
 }
 async function formatBalanceWithTokenProperties(balance) {
   const tokenProperties = await fetchTokenProperties();
-  if (!tokenProperties) {
-    throw new Error(
-      "Token properties not yet cached. Call fetchTokenProperties first."
-    );
-  }
-  return _util.formatBalance.call(void 0, balance, {
-    decimals: tokenProperties.decimals,
-    withSi: true,
-    withUnit: tokenProperties.symbol
-  });
+  return `${_viem.formatUnits.call(void 0, typeof balance === "bigint" ? balance : BigInt(balance), tokenProperties.decimals)} ${tokenProperties.symbol}`;
 }
+var tokenToBigint = toAtomicPaliAmount;
 
 // src/chain/singleton.ts
 
@@ -702,128 +836,13 @@ var provider = new (0, _api2.WsProvider)(PALLIORA_WS, 1e4);
 
 // src/chain/singleton.ts
 
-var wsProvider = null;
 var api = null;
 var keyring = null;
 var encKeyring = null;
-var RpcApi = class {
-  constructor() {
-    this.isConnected = false;
-    this.isConnecting = false;
-    this.error = null;
-  }
-  /**
-   * Establishes a connection to a node at `endpoint` and returns the singleton
-   * API and Keyring instances.
-   *
-   * @param endpoint - WebSocket endpoint URL to connect to (e.g. "wss://...").
-   * @returns A promise resolving to an object containing the singleton {@link ApiPromise}
-   *          instance and the singleton {@link Keyring} instance.
-   *
-   * @remarks
-   * - If a connection already exists (`isConnected === true`) the method returns
-   *   the already-initialized instances without recreating them.
-   * - The method sets `isConnecting` to true while establishing the connection and
-   *   clears it in a `finally` block.
-   * - Provider and API event listeners update the instance `error` and `isConnected`
-   *   fields on runtime errors and disconnects.
-   * - The Keyring created here uses `sr25519` keys. If the standalone `getKeyring`
-   *   helper is used elsewhere, it will additionally add a default development
-   *   account derived from the well-known dev URI `//Bob` (named "Bob default").
-   *
-   * @throws Will re-throw underlying errors encountered while creating the provider
-   *         or API. In that case `error` will contain the textual error message.
-   */
-  async connect(endpoint) {
-    try {
-      if (this.isConnected) {
-        return { api, keyring };
-      }
-      this.isConnecting = true;
-      this.error = null;
-      if (!wsProvider) {
-        wsProvider = new (0, _api2.WsProvider)(endpoint);
-        wsProvider.on("error", (err) => {
-          console.error("WsProvider error:", err);
-          this.error = "WebSocket connection error";
-          this.isConnected = false;
-        });
-        wsProvider.on("disconnected", () => {
-          console.log("WsProvider disconnected");
-          this.isConnected = false;
-        });
-      }
-      if (!api) {
-        api = await _api2.ApiPromise.create({
-          provider: wsProvider,
-          rpc: API_RPC,
-          types: API_TYPES,
-          signedExtensions: API_EXTENSIONS
-        });
-        api.on("error", (err) => {
-          console.error("API error:", err);
-          this.error = "API error occurred";
-        });
-        api.on("disconnected", () => {
-          this.isConnected = false;
-        });
-      }
-      if (!keyring) {
-        keyring = new (0, _api2.Keyring)({ type: "sr25519" });
-      }
-      if (!encKeyring) {
-        encKeyring = new (0, _api2.Keyring)({ type: "ed25519" });
-      }
-      await api.isReady;
-      this.isConnected = true;
-      return { api, keyring };
-    } catch (err) {
-      console.error("Failed to connect to Polkadot:", err);
-      this.error = err instanceof Error ? err.message : "Failed to connect to Polkadot";
-      throw err;
-    } finally {
-      this.isConnecting = false;
-    }
-  }
-  /**
-   * Gracefully disconnects and nullifies the singleton API, provider and keyring
-   * instances managed by this RpcApi instance.
-   *
-   * @remarks
-   * - The method calls `api.disconnect()` and `wsProvider.disconnect()` if they
-   *   exist, then sets the internal singletons to `null` and `isConnected` to false.
-   * - Any error during disconnect is captured in `error`.
-   */
-  async disconnect() {
-    try {
-      if (api) {
-        await api.disconnect();
-        api = null;
-      }
-      if (wsProvider) {
-        await wsProvider.disconnect();
-        wsProvider = null;
-      }
-      keyring = null;
-      this.isConnected = false;
-    } catch (err) {
-      console.error("Error disconnecting:", err);
-      this.error = err instanceof Error ? err.message : "Failed to disconnect";
-    }
-  }
-  getApi() {
-    return api;
-  }
-  getKeyring() {
-    return keyring;
-  }
-  getEncKeyring() {
-    return encKeyring;
-  }
-};
-async function getApi() {
+var apiListenersAttached = false;
+var apiTeardownInProgress = false;
+async function getApi(cb) {
   if (!provider) return;
-  console.debug(provider.endpoint);
   if (!api) {
     api = await _api2.ApiPromise.create({
       provider,
@@ -833,15 +852,25 @@ async function getApi() {
     });
   }
   const isNode = typeof process !== "undefined" && typeof process.exit === "function";
-  const isTest = typeof process !== "undefined" && _optionalChain([process, 'access', _36 => _36.env, 'optionalAccess', _37 => _37.NODE_ENV]) === "test";
-  if (isNode && !isTest) {
+  const isTest = typeof process !== "undefined" && _optionalChain([process, 'access', _37 => _37.env, 'optionalAccess', _38 => _38.NODE_ENV]) === "test";
+  if (isNode && !isTest && api && !apiListenersAttached) {
+    apiListenersAttached = true;
     api.on("error", (err) => {
-      console.error("api error, will restart:", err);
-      process.exit(0);
+      if (apiTeardownInProgress) return;
+      apiTeardownInProgress = true;
+      apiListenersAttached = false;
+      const currentApi = api;
+      api = null;
+      void _optionalChain([currentApi, 'optionalAccess', _39 => _39.disconnect, 'call', _40 => _40(), 'access', _41 => _41.catch, 'call', _42 => _42((disconnectErr) => {
+        apiTeardownInProgress = false;
+        console.error("api disconnect after error failed:", disconnectErr);
+      })]);
     });
     api.on("disconnected", () => {
-      console.error("api disconnected, will restart.");
-      process.exit(0);
+      api = null;
+      apiListenersAttached = false;
+      apiTeardownInProgress = false;
+      if (cb) cb();
     });
   }
   return api;
@@ -862,13 +891,6 @@ async function getEncKeyring() {
   }
   return encKeyring;
 }
-var apiInstance = null;
-function getRpcApi() {
-  if (!apiInstance) {
-    apiInstance = new RpcApi();
-  }
-  return apiInstance;
-}
 
 // src/chain/utils.ts
 
@@ -883,7 +905,7 @@ var getGuardianList = async () => {
   const section = "guardian";
   const method = "guardianList";
   assert(
-    _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _38 => _38[section], 'optionalAccess', _39 => _39[method]])),
+    _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _43 => _43[section], 'optionalAccess', _44 => _44[method]])),
     `api.rpc.${section}.${method} does not exist`
   );
   const list = (await rpc[section]["guardianList"]()).map((item) => [item.toString()]).flat(1);
@@ -918,24 +940,26 @@ async function joinGuardian(account, prefs) {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
-  const computeOpts = _optionalChain([prefs, 'access', _40 => _40.compute, 'optionalAccess', _41 => _41.split, 'call', _42 => _42(","), 'access', _43 => _43.map, 'call', _44 => _44((s) => s.trim()), 'access', _45 => _45.filter, 'call', _46 => _46((s) => s.length > 0)]) || void 0;
+  const computeOpts = _optionalChain([prefs, 'access', _45 => _45.compute, 'optionalAccess', _46 => _46.split, 'call', _47 => _47(","), 'access', _48 => _48.map, 'call', _49 => _49((s) => s.trim()), 'access', _50 => _50.filter, 'call', _51 => _51((s) => s.length > 0)]) || void 0;
+  const feeThreshold = typeof prefs.fee === "bigint" ? prefs.fee : BigInt(prefs.fee || "0");
   const guardianPrefs = {
     pubKey: account.publicKey,
     guardian: prefs.standard,
     verifier: prefs.verifier,
     compute: prefs.compute ? true : false,
     computePrefs: {
-      trusted: _optionalChain([computeOpts, 'optionalAccess', _47 => _47.includes, 'call', _48 => _48("trusted")]) || false,
-      tee: _optionalChain([computeOpts, 'optionalAccess', _49 => _49.includes, 'call', _50 => _50("tee")]) || false,
-      mpc: _optionalChain([computeOpts, 'optionalAccess', _51 => _51.includes, 'call', _52 => _52("mpc")]) || false,
-      fhe: _optionalChain([computeOpts, 'optionalAccess', _53 => _53.includes, 'call', _54 => _54("fhe")]) || false,
-      zkp: _optionalChain([computeOpts, 'optionalAccess', _55 => _55.includes, 'call', _56 => _56("zkp")]) || false
-    }
+      trusted: _optionalChain([computeOpts, 'optionalAccess', _52 => _52.includes, 'call', _53 => _53("trusted")]) || false,
+      tee: _optionalChain([computeOpts, 'optionalAccess', _54 => _54.includes, 'call', _55 => _55("tee")]) || false,
+      mpc: _optionalChain([computeOpts, 'optionalAccess', _56 => _56.includes, 'call', _57 => _57("mpc")]) || false,
+      fhe: _optionalChain([computeOpts, 'optionalAccess', _58 => _58.includes, 'call', _59 => _59("fhe")]) || false,
+      zkp: _optionalChain([computeOpts, 'optionalAccess', _60 => _60.includes, 'call', _61 => _61("zkp")]) || false
+    },
+    feeThreshold
   };
   debugLog(
     account.address,
     "joining as guardian with preferences:",
-    guardianPrefs
+    { ...guardianPrefs, feeThreshold: formatPaliAmount(feeThreshold) }
   );
   const guardTx = api2.tx.staking.guard(guardianPrefs);
   const hash = await signAndSend(guardTx, account);
@@ -967,8 +991,8 @@ var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
     `Transaction ${tx_result.txHash.toHex()} included in timepoint ${tx_result.blockNumber}-${tx_result.txIndex}`
   );
   return {
-    blockNumber: _optionalChain([tx_result, 'optionalAccess', _57 => _57.blockNumber, 'optionalAccess', _58 => _58.toNumber, 'call', _59 => _59()]),
-    index: _optionalChain([tx_result, 'optionalAccess', _60 => _60.txIndex]),
+    blockNumber: _optionalChain([tx_result, 'optionalAccess', _62 => _62.blockNumber, 'optionalAccess', _63 => _63.toNumber, 'call', _64 => _64()]),
+    index: _optionalChain([tx_result, 'optionalAccess', _65 => _65.txIndex]),
     hash: tx_result.txHash.toHex(),
     tx_result
   };
@@ -986,7 +1010,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', _61 => _61.query, 'access', _62 => _62["guardian"], 'optionalAccess', _63 => _63["worker"]])),
+    _util.isFunction.call(void 0, _optionalChain([api2, 'access', _66 => _66.query, 'access', _67 => _67["guardian"], 'optionalAccess', _68 => _68["worker"]])),
     `api.query.guardian.worker does not exist`
   );
   const list = await getGuardianList();
@@ -1006,7 +1030,7 @@ var getGuardianNwParams = async () => {
     const section = "guardian";
     const method = "guardianNwParams";
     assert(
-      _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _64 => _64[section], 'optionalAccess', _65 => _65[method]])),
+      _util.isFunction.call(void 0, _optionalChain([rpc, 'access', _69 => _69[section], 'optionalAccess', _70 => _70[method]])),
       `api.rpc.${section}.guardianNwParams does not exist`
     );
     const guardianNwParams = await rpc[section][method]();
@@ -1127,7 +1151,7 @@ var MCryptFsWriter = class {
       request.signAndSend(this._account, { app_id: 1 }, (result) => {
         if (result.isInBlock || result.isFinalized || result.isError) {
           resolve({
-            blockNumber: _optionalChain([result, 'access', _66 => _66.blockNumber, 'optionalAccess', _67 => _67.toNumber, 'call', _68 => _68()]),
+            blockNumber: _optionalChain([result, 'access', _71 => _71.blockNumber, 'optionalAccess', _72 => _72.toNumber, 'call', _73 => _73()]),
             index: result.txIndex
           });
         }
@@ -1237,18 +1261,29 @@ var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
 
 // src/compute/agreement.ts
 
-async function createAgreement() {
+async function createAgreement(contract, account) {
   const api2 = await getApi();
   if (!api2) throw new Error("Api not initialized");
-  const tx = api2.tx.compute.agreement();
-  const guardians = await getGuardianList();
-  const agreement = guardians.slice(0, 3).map((g) => _bs582.default.decode(g).subarray(6));
-  assert(agreement.length === 3, "Not enough guardians to create agreement");
-  const keyring2 = await getKeyring();
-  const account = keyring2.getPairs()[0];
-  const { tx_result } = await signAndSend(tx, account, {
-    compute: { da_type: 1, agreement, verification: 0, compute: 1 }
-  });
+  const guardians = contract.guardians;
+  const agreement = guardians.map((g) => _bs582.default.decode(g.peerid).subarray(6));
+  const txContract = {
+    ...contract,
+    guardians: guardians.map((g) => g.address)
+  };
+  const tx = api2.tx.compute.agreement(txContract);
+  const opts = {
+    compute: {
+      da_type: 1,
+      agreement,
+      verification: 0,
+      compute: contract.contract_type === "Active" ? 1 : 0
+    }
+  };
+  const { tx_result, blockNumber, index, hash } = await signAndSend(
+    tx,
+    account,
+    opts
+  );
   if (!tx_result.isError) {
     const agreementCreatedEvent = tx_result.events.find((event) => {
       return event.event.section === "compute" && event.event.method === "AgreementCreated";
@@ -1258,10 +1293,105 @@ async function createAgreement() {
         "Agreement data:",
         agreementCreatedEvent.event.data.toString()
       );
+      return {
+        blockNumber,
+        index,
+        hash,
+        agreementId: _nullishCoalesce(_optionalChain([agreementCreatedEvent, 'access', _74 => _74.event, 'access', _75 => _75.data, 'access', _76 => _76[0], 'optionalAccess', _77 => _77.toHex, 'optionalCall', _78 => _78()]), () => ( agreementCreatedEvent.event.data.toString()))
+      };
     } else {
       debugLog("AgreementCreated event not found");
     }
   }
+  return { blockNumber, index, hash };
+}
+async function createSimpleAgreement() {
+  const guardianIds = (await getGuardianAddress()).slice(0, 3);
+  assert(guardianIds.length === 3, "Not enough guardians to create agreement");
+  const contract = {
+    contract_type: "Dormant",
+    guardians: guardianIds,
+    pre_check: null,
+    compute: {
+      cipher: "Plaintext",
+      computer_indices: [0, 1, 2],
+      fees: 0n,
+      deadline: 0,
+      confidentiality: { Trusted: { trust_index: 0 } },
+      fee_function: null,
+      input: null,
+      program: { NativeData: "DaFalse" },
+      metadata: null
+    },
+    post_check: null,
+    result_cipher: "Plaintext"
+  };
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  return createAgreement(contract, account);
+}
+
+// src/compute/data.ts
+async function dataContract(params) {
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  const plaintextCipher = "Plaintext";
+  const atomicFees = toAtomicPaliAmount(_nullishCoalesce(params.fees, () => ( "0")));
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: _nullishCoalesce(params.deadline, () => ( 0)),
+    confidentiality: {
+      Trusted: {
+        trust_index: _nullishCoalesce(params.trustIndex, () => ( 0))
+      }
+    },
+    fee_function: null,
+    input: {
+      Url: {
+        url: Array.from(new TextEncoder().encode(params.url))
+      }
+    },
+    program: {
+      NativeData: "DaFalse"
+    }
+  };
+  const contract = {
+    contract_type: "Dormant",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
+}
+
+// src/compute/inference.ts
+async function inferenceCompute(params) {
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  const inputData = typeof params.input === "string" ? Array.from(new TextEncoder().encode(params.input)) : Array.from(params.input);
+  const atomicFees = toAtomicPaliAmount(_nullishCoalesce(params.fees, () => ( "0")));
+  const plaintextCipher = "Plaintext";
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: _nullishCoalesce(params.deadline, () => ( 0)),
+    confidentiality: { Trusted: { trust_index: 0 } },
+    fee_function: null,
+    input: { Inline: { data: inputData } },
+    program: { NativeExecute: "Inference" }
+  };
+  const contract = {
+    contract_type: "Active",
+    guardians: params.guardians,
+    compute: computeStep,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
 }
 
 // src/compute/participants.ts
@@ -1278,8 +1408,8 @@ async function getGuardianParticipants() {
     const _peerid = _bs582.default.decode((peerid || "").toString());
     const account = await api2.query.guardian.worker(_peerid.slice(0, 32));
     const nextIndex = currentIndex ? Number(currentIndex) + 1 : 1;
-    const guardiansList = _optionalChain([guardians, 'optionalAccess', _69 => _69.toJSON, 'call', _70 => _70()]) || [];
-    const nextGuardiansList = _optionalChain([nextGuardians, 'optionalAccess', _71 => _71.toJSON, 'call', _72 => _72()]) || [];
+    const guardiansList = _optionalChain([guardians, 'optionalAccess', _79 => _79.toJSON, 'call', _80 => _80()]) || [];
+    const nextGuardiansList = _optionalChain([nextGuardians, 'optionalAccess', _81 => _81.toJSON, 'call', _82 => _82()]) || [];
     const buildDetails = async (list) => {
       return Promise.all(
         list.map(async (guardian) => {
@@ -1288,21 +1418,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', _73 => _73.toPrimitive, 'call', _74 => _74()]),
+            _optionalChain([currentEra, 'optionalAccess', _83 => _83.toPrimitive, 'call', _84 => _84()]),
             guardian
           );
           const guardianErasPrefs = await api2.query.staking.erasGuardianPrefs(
-            _optionalChain([currentEra, 'optionalAccess', _75 => _75.toPrimitive, 'call', _76 => _76()]),
+            _optionalChain([currentEra, 'optionalAccess', _85 => _85.toPrimitive, 'call', _86 => _86()]),
             guardian
           );
           return {
             guardian,
-            rewardDestination: _optionalChain([payee, 'optionalAccess', _77 => _77.toHuman]) ? payee.toHuman() : null,
-            currentPreferences: _optionalChain([guardianErasPrefs, 'optionalAccess', _78 => _78.toHuman]) ? guardianErasPrefs.toHuman() : null,
-            upcomingPreferences: _optionalChain([guardianPrefs, 'optionalAccess', _79 => _79.toHuman]) ? guardianPrefs.toHuman() : null,
-            stash: _optionalChain([bonded, 'optionalAccess', _80 => _80.toHuman]) ? bonded.toHuman() : null,
-            currentStakeOverview: _optionalChain([stakersOverview, 'optionalAccess', _81 => _81.toHuman]) ? stakersOverview.toHuman() : null,
-            upcomingStakeOverview: _optionalChain([ledger, 'optionalAccess', _82 => _82.toHuman]) ? ledger.toHuman() : null
+            rewardDestination: _optionalChain([payee, 'optionalAccess', _87 => _87.toHuman]) ? payee.toHuman() : null,
+            currentPreferences: _optionalChain([guardianErasPrefs, 'optionalAccess', _88 => _88.toHuman]) ? guardianErasPrefs.toHuman() : null,
+            upcomingPreferences: _optionalChain([guardianPrefs, 'optionalAccess', _89 => _89.toHuman]) ? guardianPrefs.toHuman() : null,
+            stash: _optionalChain([bonded, 'optionalAccess', _90 => _90.toHuman]) ? bonded.toHuman() : null,
+            currentStakeOverview: _optionalChain([stakersOverview, 'optionalAccess', _91 => _91.toHuman]) ? stakersOverview.toHuman() : null,
+            upcomingStakeOverview: _optionalChain([ledger, 'optionalAccess', _92 => _92.toHuman]) ? ledger.toHuman() : null
           };
         })
       );
@@ -1311,12 +1441,12 @@ async function getGuardianParticipants() {
     const upcomingGuardians = await buildDetails(nextGuardiansList);
     return {
       nwState: {
-        localPeerId: _optionalChain([peerid, 'optionalAccess', _83 => _83.toString, 'call', _84 => _84()]),
-        worker: _optionalChain([account, 'optionalAccess', _85 => _85.toHuman]) ? account.toHuman() : null,
-        currentEra: _optionalChain([currentEra, 'optionalAccess', _86 => _86.toHuman]) ? currentEra.toHuman() : null,
-        guardians: JSON.stringify(_optionalChain([guardians, 'optionalAccess', _87 => _87.toHuman]) ? guardians.toHuman() : null, null, 2),
-        nextGuardians: JSON.stringify(_optionalChain([nextGuardians, 'optionalAccess', _88 => _88.toHuman]) ? nextGuardians.toHuman() : null, null, 2),
-        currentIndex: _optionalChain([currentIndex, 'optionalAccess', _89 => _89.toHuman]) ? currentIndex.toHuman() : null,
+        localPeerId: _optionalChain([peerid, 'optionalAccess', _93 => _93.toString, 'call', _94 => _94()]),
+        worker: _optionalChain([account, 'optionalAccess', _95 => _95.toHuman]) ? account.toHuman() : null,
+        currentEra: _optionalChain([currentEra, 'optionalAccess', _96 => _96.toHuman]) ? currentEra.toHuman() : null,
+        guardians: JSON.stringify(_optionalChain([guardians, 'optionalAccess', _97 => _97.toHuman]) ? guardians.toHuman() : null, null, 2),
+        nextGuardians: JSON.stringify(_optionalChain([nextGuardians, 'optionalAccess', _98 => _98.toHuman]) ? nextGuardians.toHuman() : null, null, 2),
+        currentIndex: _optionalChain([currentIndex, 'optionalAccess', _99 => _99.toHuman]) ? currentIndex.toHuman() : null,
         nextIndex
       },
       currentGuardians,
@@ -1327,6 +1457,46 @@ async function getGuardianParticipants() {
   }
 }
 
+// src/compute/simple.ts
+async function simpleCompute(params) {
+  const keyring2 = await getKeyring();
+  const account = keyring2.getPairs()[0];
+  const plaintextCipher = "Plaintext";
+  const atomicFees = toAtomicPaliAmount(_nullishCoalesce(params.fees, () => ( "0")));
+  const computeStep = {
+    cipher: plaintextCipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: atomicFees,
+    deadline: _nullishCoalesce(params.deadline, () => ( 0)),
+    confidentiality: {
+      Trusted: {
+        trust_index: _nullishCoalesce(params.trustIndex, () => ( 0))
+      }
+    },
+    fee_function: null,
+    input: {
+      ChainTransaction: {
+        block_number: params.inputBlockNumber,
+        extrinsic_index: params.inputExtrinsicIndex
+      }
+    },
+    program: {
+      Url: {
+        url: Array.from(new TextEncoder().encode(params.programUrl))
+      }
+    }
+  };
+  const contract = {
+    contract_type: "Active",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: plaintextCipher
+  };
+  return createAgreement(contract, account);
+}
+
 // src/crypto/random.ts
 function generateRandomBytes(length = 32) {
   const bytes = new Uint8Array(length);
@@ -1349,6 +1519,7 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
   const ownerBytes = Array.from(encoder.encode(l2Owner));
   const api2 = await getApi();
   assert(api2, "Failed to get API connection");
+  debugLog(`Registering metadata for ${name} at ${formatPaliAmount(price)}`);
   const request = api2.tx.dataAvailability.daccRegisterData(
     nameBytes,
     descriptionBytes,
@@ -1362,6 +1533,82 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
   debugLog(`Metadata registration transaction sent with hash: ${hash.hash}`);
   return hash;
 }
+async function registerDataAgreement(account, params) {
+  debugLog(
+    `Registering data agreement for DA ref ${params.ref.blockNumber}-${params.ref.index} at ${formatPaliAmount(params.fees)}`
+  );
+  const cipher = _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)),
+    store_type: params.metadata.storeType,
+    group_id: params.metadata.groupId
+  } : null;
+  const computeStep = {
+    cipher,
+    computer_indices: params.guardians.map((_, i) => i),
+    fees: params.fees,
+    deadline: _nullishCoalesce(params.deadline, () => ( 0)),
+    confidentiality: {
+      Trusted: {
+        trust_index: _nullishCoalesce(params.trustIndex, () => ( 0))
+      }
+    },
+    fee_function: null,
+    input: {
+      ChainTransaction: {
+        block_number: params.ref.blockNumber,
+        extrinsic_index: params.ref.index
+      }
+    },
+    program: {
+      NativeData: "DaFalse"
+    },
+    metadata: computeMetadata
+  };
+  const contract = {
+    contract_type: "Dormant",
+    guardians: params.guardians,
+    pre_check: null,
+    compute: computeStep,
+    post_check: null,
+    result_cipher: resultCipher
+  };
+  return createAgreement(contract, account);
+}
+
+// src/da/runAgent.ts
+async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes, tauParams, baseModel, publicKey, guardians, guardian, agreementId) {
+  const agentRefTuple = [agentRef.blockNumber, agentRef.index];
+  const baseModelTuple = [baseModel.blockNumber, baseModel.index];
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = api2.tx.dataAvailability.daccRunAgent(
+    agentRefTuple,
+    Array.from(nonce),
+    Array.from(ciphertext),
+    guardian ? Array.from(guardian) : null,
+    Array.from(tdParams),
+    Array.from(pkBytes),
+    Array.from(tauParams),
+    baseModelTuple,
+    Array.from(publicKey),
+    guardians.map((g) => Array.from(g))
+  );
+  const opts = {
+    compute: {
+      da_type: 4,
+      verification: 0,
+      compute: 1,
+      agreement: [agreementId]
+    }
+  };
+  const hash = await signAndSend(request, account, opts);
+  debugLog(`Run agent transaction sent with hash: ${hash.hash}`);
+  return hash;
+}
 
 // src/da/submit.ts
 async function submitData(account, data) {
@@ -1395,11 +1642,76 @@ async function submitTEData(account, data, chosenGuardians, tau_params, agg_key,
   debugLog(`TE data availability transaction sent with hash: ${hash.hash}`);
   return hash;
 }
+async function submitTEDataWithCipher(account, data, chosenGuardians, tau_params, agg_key, group_pk) {
+  const { encoded: encryptedKey, ikm } = testCrypt(tau_params, agg_key);
+  const shared_key = gen_stretched_key(hexToUint8Array(ikm));
+  const encoder = new TextEncoder();
+  const dataUint8Array = encoder.encode(data);
+  const { ciphertext, nonce } = encrypt2(dataUint8Array, shared_key);
+  const ciphertextHex = "0x" + Array.from(ciphertext).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const api2 = await getApi();
+  assert(api2, "Failed to get API connection");
+  const request = await api2.tx.dataAvailability.submitData(ciphertextHex);
+  const ref = await signAndSend(request, account, DEFAULT_EMPTY_PAYLOAD);
+  debugLog(`TE data availability transaction sent with hash: ${ref.hash}`);
+  return {
+    ref,
+    cipher: {
+      Encrypted: {
+        threshold: {
+          SilentThreshold: {
+            td_params: Array.from(hexToUint8Array(encryptedKey)),
+            pk_bytes: Array.from(hexToUint8Array(group_pk)),
+            tau_params: Array.from(hexToUint8Array(tau_params))
+          }
+        },
+        symmetric: {
+          ChaCha20Poly1305: { nonce: Array.from(nonce) }
+        }
+      }
+    }
+  };
+}
 
 // src/da/upload.ts
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 async function uploadData(options) {
+  const { name, description, price, type, guardianGroupInfo, ref, filePath } = options;
+  assert(
+    guardianGroupInfo.guardians && guardianGroupInfo.tauParams && guardianGroupInfo.aggKey && guardianGroupInfo.groupPk,
+    "Guardian group info is missing required properties"
+  );
+  console.log("Guardian group info:", guardianGroupInfo);
+  const account = (await getKeyring()).pairs[0];
+  const atomicPrice = toAtomicPaliAmount(price);
+  if (filePath) {
+    throw new Error("uploadData: file path upload is not implemented");
+  } else {
+    const storeType = type === "model" ? "Model" : type === "agent" ? "Agent" : "Dataset";
+    const { ref: dataRef, cipher } = await submitTEDataWithCipher(
+      account,
+      ref || "",
+      guardianGroupInfo.guardians,
+      guardianGroupInfo.tauParams,
+      guardianGroupInfo.aggKey,
+      guardianGroupInfo.groupPk
+    );
+    await registerDataAgreement(account, {
+      ref: dataRef,
+      guardians: guardianGroupInfo.guardians,
+      fees: atomicPrice,
+      cipher,
+      metadata: {
+        name,
+        description,
+        storeType,
+        groupId: guardianGroupInfo.groupId
+      }
+    });
+  }
+}
+async function uploadDataLegacy(options) {
   const { name, description, price, type, guardianGroupInfo, ref, filePath } = options;
   assert(
     guardianGroupInfo.guardians && guardianGroupInfo.tauParams && guardianGroupInfo.aggKey && guardianGroupInfo.groupPk,
@@ -1407,6 +1719,7 @@ async function uploadData(options) {
   );
   const account = (await getKeyring()).pairs[0];
   const ethAddress = "";
+  const atomicPrice = toAtomicPaliAmount(price);
   if (type === "dataset" && filePath) {
     const fileContent = _fs2.default.readFileSync(filePath);
     const selectedFile = new File([fileContent], _path2.default.basename(filePath), {
@@ -1419,7 +1732,7 @@ async function uploadData(options) {
         fileName: selectedFile.name,
         filePath: "",
         description,
-        baseCost: BigInt(Number(price) * 10 ** 18),
+        baseCost: atomicPrice,
         ownerL2Address: ethAddress,
         guardianInfo: guardianGroupInfo
       },
@@ -1452,12 +1765,12 @@ async function uploadData(options) {
 }
 
 // src/stake/add.ts
-async function addStake(account, amount) {
+async function addStake(account, amountBaseUnits) {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
-  debugLog("Using account:", account.address);
-  const stakeTx = api2.tx.staking.bondExtra(amount);
+  debugLog("Using account:", account.address, "adding:", formatPaliAmount(amountBaseUnits));
+  const stakeTx = api2.tx.staking.bondExtra(amountBaseUnits);
   const hash = await signAndSend(stakeTx, account);
   debugLog(`Stake transaction sent with hash: ${hash.hash}`);
 }
@@ -1473,14 +1786,14 @@ async function joinIdleStaker(account) {
 }
 
 // src/stake/new.ts
-async function newStake(account, amount, rewardDestination = "Staked") {
+async function newStake(account, amountBaseUnits, rewardDestination = "Staked") {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
   debugLog(
-    `Staking amount: ${amount} for account: ${account.address} with reward destination: ${rewardDestination}`
+    `Staking amount: ${formatPaliAmount(amountBaseUnits)} for account: ${account.address} with reward destination: ${rewardDestination}`
   );
-  const stakeTx = api2.tx.staking.bond(amount, rewardDestination);
+  const stakeTx = api2.tx.staking.bond(amountBaseUnits, rewardDestination);
   const hash = await signAndSend(stakeTx, account);
   debugLog(`Stake transaction sent with hash: ${hash.hash}`);
 }
@@ -1502,12 +1815,12 @@ async function payoutStake(account, eras, address) {
 }
 
 // src/stake/reduce.ts
-async function reduceStake(account, amount) {
+async function reduceStake(account, amountBaseUnits) {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   assert(account, "Account not initialized");
-  debugLog("Using account:", account.address);
-  const unstakeTx = api2.tx.staking.unbond(amount);
+  debugLog("Using account:", account.address, "reducing:", formatPaliAmount(amountBaseUnits));
+  const unstakeTx = api2.tx.staking.unbond(amountBaseUnits);
   const hash = await signAndSend(unstakeTx, account);
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
 }
@@ -1517,9 +1830,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 _90 => _90.toPrimitive, 'call', async _91 => _91()]);
-  debugLog("Removing entire stake amount:", _optionalChain([stakeAmount, 'optionalAccess', _92 => _92.active]) || 0n);
-  const unstakeTx = api2.tx.staking.unbond(_optionalChain([stakeAmount, 'optionalAccess', _93 => _93.active]) || 0n);
+  const stakeAmount = await _asyncOptionalChain([(await api2.query.staking.ledger(account.address)), 'optionalAccess', async _100 => _100.toPrimitive, 'call', async _101 => _101()]);
+  debugLog("Removing entire stake amount:", formatPaliAmount(_optionalChain([stakeAmount, 'optionalAccess', _102 => _102.active]) || 0n));
+  const unstakeTx = api2.tx.staking.unbond(_optionalChain([stakeAmount, 'optionalAccess', _103 => _103.active]) || 0n);
   const hash = await signAndSend(unstakeTx, account);
   debugLog(`Unstake transaction sent with hash: ${hash.hash}`);
 }
@@ -1535,25 +1848,25 @@ async function withdrawStake(account) {
 }
 
 // src/token/fund.ts
-async function fundAccount(account, amount, address) {
+async function fundAccount(account, amountBaseUnits, address) {
   const addr = address ? address : account.address;
   const keyring2 = await getKeyring();
   const api2 = await getApi();
   assert(api2, "API not initialized");
   debugLog(`
-Funding account: ${addr} with amount: ${amount}`);
-  const tx = api2.tx.balances.transferKeepAlive(addr, amount);
+Funding account: ${addr} with amount: ${formatPaliAmount(amountBaseUnits)}`);
+  const tx = api2.tx.balances.transferKeepAlive(addr, amountBaseUnits);
   const hash = await signAndSend(tx, keyring2.getPairs()[0]);
   debugLog(`Fund transaction sent with hash: ${hash.hash}`);
 }
 
 // src/token/transfer.ts
-async function transfer(account, amount, address) {
+async function transfer(account, amountBaseUnits, address) {
   const api2 = await getApi();
   assert(api2, "API not initialized");
   debugLog(`
-Transferring funds to account: ${address} with amount: ${amount}`);
-  const tx = api2.tx.balances.transferKeepAlive(address, amount);
+Transferring funds to account: ${address} with amount: ${formatPaliAmount(amountBaseUnits)}`);
+  const tx = api2.tx.balances.transferKeepAlive(address, amountBaseUnits);
   const hash = await signAndSend(tx, account);
   debugLog(`Transfer transaction sent with hash: ${hash.hash}`);
 }
@@ -1588,7 +1901,7 @@ async function rotateAndSetKeys(account) {
   _assert2.default.call(void 0, api2, "API not initialized");
   debugLog(`Rotating session keys for ${account.meta.name} on ${provider.endpoint}`);
   const newKeys = await api2.rpc.author.rotateKeys();
-  debugLog(`${account.meta.name} rotated keys on ${provider.endpoint}:`, _nullishCoalesce(_optionalChain([newKeys, 'optionalAccess', _94 => _94.toHex, 'optionalCall', _95 => _95()]), () => ( newKeys)));
+  debugLog(`${account.meta.name} rotated keys on ${provider.endpoint}:`, _nullishCoalesce(_optionalChain([newKeys, 'optionalAccess', _104 => _104.toHex, 'optionalCall', _105 => _105()]), () => ( newKeys)));
   const setKeysTx = api2.tx.session.setKeys(newKeys, []);
   const hash = await signAndSend(setKeysTx, account);
   debugLog(`Rotate session transaction sent with hash: ${hash.hash}`);
@@ -1683,5 +1996,16 @@ async function setWorker(account) {
 
 
 
-exports.API_EXTENSIONS = API_EXTENSIONS; exports.API_RPC = API_RPC; exports.API_TYPES = API_TYPES; exports.AccountSourceType = AccountSourceType; exports.ApiPromise = _api2.ApiPromise; exports.CryptoType = CryptoType; exports.DEBUG = DEBUG; exports.DEFAULT_COMPUTE_PAYLOAD = DEFAULT_COMPUTE_PAYLOAD; exports.DEFAULT_EMPTY_PAYLOAD = DEFAULT_EMPTY_PAYLOAD; exports.FileFromMetadataRef = FileFromMetadataRef; exports.HttpProvider = _api2.HttpProvider; exports.MCryptFs = MCryptFs; exports.MCryptFsReader = MCryptFsReader; exports.MCryptFsWriter = MCryptFsWriter; exports.PALLIORA_RPC_URL = PALLIORA_RPC_URL; exports.PALLIORA_WS = PALLIORA_WS; exports.RpcApi = RpcApi; exports.TX_WAIT_FINALIZATION = TX_WAIT_FINALIZATION; exports.WsProvider = _api2.WsProvider; exports.addStake = addStake; exports.base64ToUint8Array = base64ToUint8Array; exports.clearTokenCache = clearTokenCache; exports.configure = configure; exports.createAccount = createAccount; exports.createAgreement = createAgreement; exports.createGuardianGroup = createGuardianGroup; exports.debugLog = debugLog; exports.decodeAggregateKey = decodeAggregateKey; exports.decodeField = decodeField; exports.decodePowersOfTau = decodePowersOfTau; exports.decrypt = decrypt; exports.ecncryptTest = encrypt; exports.encodeCiphertext = encodeCiphertext; exports.encrypt = encrypt2; exports.fetchTokenProperties = fetchTokenProperties; exports.formatBalanceWithTokenProperties = formatBalanceWithTokenProperties; exports.fundAccount = fundAccount; exports.gen_shared_key = gen_shared_key; exports.gen_stretched_key = gen_stretched_key; exports.generateRandomBytes = generateRandomBytes; exports.getApi = getApi; exports.getCachedTokenProperties = getCachedTokenProperties; exports.getEncKeyring = getEncKeyring; exports.getFileMetadataCall = getFileMetadataCall; exports.getGuardianAddress = getGuardianAddress; exports.getGuardianList = getGuardianList; exports.getGuardianNwParams = getGuardianNwParams; exports.getGuardianParticipants = getGuardianParticipants; exports.getKeyring = getKeyring; exports.getRpcApi = getRpcApi; exports.hexToUint8Array = hexToUint8Array; exports.joinGuardian = joinGuardian; exports.joinIdleStaker = joinIdleStaker; exports.joinValidator = joinValidator; exports.newStake = newStake; exports.pairFromPrivateKeyHex = pairFromPrivateKeyHex; exports.payoutStake = payoutStake; exports.provider = provider; exports.reduceStake = reduceStake; exports.removeStake = removeStake; exports.rotateAndSetKeys = rotateAndSetKeys; exports.setIdentity = setIdentity; exports.setWorker = setWorker; exports.signAndSend = signAndSend; exports.submitData = submitData; exports.submitTEData = submitTEData; exports.testCrypt = testCrypt; exports.tokenToBigint = tokenToBigint; exports.transfer = transfer; exports.uint8ArrayToBase64 = uint8ArrayToBase64; exports.uploadData = uploadData; exports.utilCrypto = utilCrypto; exports.wasmCrypto = wasmCrypto; exports.withdrawStake = withdrawStake; exports.writeMetadata = writeMetadata;
+
+
+
+
+
+
+
+
+
+
+
+exports.API_EXTENSIONS = API_EXTENSIONS; exports.API_RPC = API_RPC; exports.API_TYPES = API_TYPES; exports.AccountSourceType = AccountSourceType; exports.ApiPromise = _api2.ApiPromise; exports.CryptoType = CryptoType; exports.DEBUG = DEBUG; exports.DEFAULT_COMPUTE_PAYLOAD = DEFAULT_COMPUTE_PAYLOAD; exports.DEFAULT_EMPTY_PAYLOAD = DEFAULT_EMPTY_PAYLOAD; exports.FileFromMetadataRef = FileFromMetadataRef; exports.HttpProvider = _api2.HttpProvider; exports.MCryptFs = MCryptFs; exports.MCryptFsReader = MCryptFsReader; exports.MCryptFsWriter = MCryptFsWriter; exports.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.clearTokenCache = clearTokenCache; exports.configure = configure; exports.createAccount = createAccount; exports.createAgreement = createAgreement; exports.createGuardianGroup = createGuardianGroup; 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.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.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.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.withdrawStake = withdrawStake; exports.writeMetadata = writeMetadata;
 //# sourceMappingURL=index.cjs.map