@palliora.org/chainsdk 0.3.2 → 0.4.0

package/dist/index.js

@@ -201,9 +201,16 @@ var API_TYPES = {
     active: "u32",
     maximum: "u32"
   },
+  CurrencyId: {
+    _enum: {
+      Native: "Null",
+      USDC: "Null",
+      ForeignAsset: "u32"
+    }
+  },
   GuardianNwParams: {
     kzg: "Vec<u8>",
-    agg_key: "Vec<u8>"
+    aggKey: "Vec<u8>"
   },
   AppId: "Compact<u32>",
   DataLookupItem: {
@@ -254,9 +261,9 @@ var API_TYPES = {
     verifier: "u128"
   },
   SilentThresholdParams: {
-    td_params: "Vec<u8>",
-    pk_bytes: "Vec<u8>",
-    tau_params: "Vec<u8>"
+    tdParams: "Vec<u8>",
+    pkBytes: "Vec<u8>",
+    tauParams: "Vec<u8>"
   },
   ThresholdParams: {
     _enum: {
@@ -282,16 +289,16 @@ var API_TYPES = {
     }
   },
   Secp256k1Params: {
-    recipient_public_key: "Vec<u8>",
-    ephemeral_public_key: "Option<Vec<u8>>",
+    recipientPublicKey: "Vec<u8>",
+    ephemeralPublicKey: "Option<Vec<u8>>",
     compressed: "bool",
     kdf: "KdfParams",
     salt: "Option<Vec<u8>>",
     info: "Option<Vec<u8>>"
   },
   Ed25519Params: {
-    recipient_public_key: "Vec<u8>",
-    ephemeral_public_key: "Option<Vec<u8>>",
+    recipientPublicKey: "Vec<u8>",
+    ephemeralPublicKey: "Option<Vec<u8>>",
     kdf: "KdfParams",
     salt: "Option<Vec<u8>>",
     info: "Option<Vec<u8>>"
@@ -303,12 +310,12 @@ var API_TYPES = {
     }
   },
   ThresholdHybridParams: {
-    threshold_params: "ThresholdParams",
-    symmetric_params: "SymmetricParams"
+    thresholdParams: "ThresholdParams",
+    symmetricParams: "SymmetricParams"
   },
   AsymmetricHybridParams: {
-    asymmetric_params: "AsymmetricParams",
-    symmetric_params: "SymmetricParams"
+    asymmetricParams: "AsymmetricParams",
+    symmetricParams: "SymmetricParams"
   },
   CipherSuite: {
     _enum: {
@@ -326,7 +333,7 @@ var API_TYPES = {
     }
   },
   NativeExecuteDA: {
-    _enum: ["Inference"]
+    _enum: ["Inference", "ContractAccess"]
   },
   NativeDataDA: {
     _enum: ["DaFalse", "DaTrue"]
@@ -335,8 +342,11 @@ var API_TYPES = {
     data: "Vec<u8>"
   },
   DAInputChainTransaction: {
-    block_number: "u64",
-    extrinsic_index: "u32"
+    blockNumber: "u64",
+    extrinsicIndex: "u32"
+  },
+  DAInputContractId: {
+    id: "[u8; 32]"
   },
   DAInputIpfs: {
     cid: "Vec<u8>",
@@ -352,6 +362,7 @@ var API_TYPES = {
       Null: "Null",
       Inline: "DAInputInline",
       ChainTransaction: "DAInputChainTransaction",
+      ContractId: "DAInputContractId",
       Ipfs: "DAInputIpfs",
       Url: "DAInputUrl",
       NativeExecute: "NativeExecuteDA",
@@ -361,7 +372,8 @@ var API_TYPES = {
   ContractType: {
     _enum: {
       Dormant: "Null",
-      Active: "Null"
+      Active: "Null",
+      Subscription: "Null"
     }
   },
   StoreType: {
@@ -375,28 +387,30 @@ var API_TYPES = {
   ComputeMetadata: {
     name: "Vec<u8>",
     description: "Vec<u8>",
-    store_type: "StoreType",
-    group_id: "H256"
+    storeType: "StoreType",
+    groupId: "H256"
   },
   ComputeInfo: {
     cipher: "CipherSuite",
-    computer_indices: "Vec<u32>",
+    computerIndices: "Vec<u32>",
     fees: "u128",
+    computeRate: "u128",
     deadline: "u64",
     confidentiality: "ConfidentialityLevel",
-    fee_function: "Option<u8>",
-    program_env: "Option<Vec<u8>>",
+    feeFunction: "Option<u8>",
+    programEnv: "Option<Vec<u8>>",
     input: "DAInput",
     program: "DAInput",
     metadata: "Option<ComputeMetadata>"
   },
   Contract: {
-    contract_type: "ContractType",
+    contractType: "ContractType",
     guardians: "Vec<AccountId>",
-    pre_check: "Option<ComputeInfo>",
+    preCheck: "Option<ComputeInfo>",
     compute: "ComputeInfo",
-    post_check: "Option<ComputeInfo>",
-    result_cipher: "CipherSuite"
+    postCheck: "Option<ComputeInfo>",
+    resultCipher: "CipherSuite",
+    currencyId: "CurrencyId"
   },
   AgreementInfo: {
     status: "AgreementStatus",
@@ -404,7 +418,7 @@ var API_TYPES = {
     index: "u32"
   },
   ComputePayload: {
-    da_type: "u8",
+    daType: "u8",
     agreement: "Option<BoundedVec<[u8; 32], 10>>",
     verification: "u8",
     compute: "u8"
@@ -480,10 +494,46 @@ var API_TYPES = {
   GRawScalar: "U256",
   GProof: "[u8; 48]",
   GRow: "Vec<GRawScalar>",
-  GDataProof: "(GRawScalar, GProof)"
+  GDataProof: "(GRawScalar, GProof)",
+  AgreementStatus: {
+    _enum: ["NotFound", "Pending", "Accepted", "Rejected", "Settled"]
+  },
+  AcceptedSubStatus: {
+    _enum: ["Running", "AwaitingTopUp", "TopUpReceived", "RejectedInsufficientBudget", "RejectedRateMismatch"]
+  },
+  RejectedSubStatus: {
+    _enum: ["InsufficientBudget", "RateMismatch"]
+  },
+  SettlementReason: {
+    _enum: ["ResultReceived", "DeadlineReached", "BudgetExhausted"]
+  },
+  ExecutionOutcome: {
+    _enum: ["FullSettlement", "PartialSettlement", "Success", "Failed", "Terminated", "TopUpTimeout"]
+  },
+  ContractInfo: {
+    status: "AgreementStatus",
+    owner: "AccountId",
+    originBlock: "u32",
+    invocationBlock: "u32",
+    index: "u32",
+    usagePrice: "u128",
+    contractType: "ContractType"
+  },
+  SettlementInfo: {
+    computeRate: "u128",
+    inputContractId: "Option<[u8; 32]>",
+    guardians: "Vec<AccountId>"
+  },
+  AppKeyInfo: {
+    owner: "AccountId",
+    id: "AppId"
+  },
+  DataType: {
+    _enum: ["Dataset", "Model", "Agent"]
+  }
 };
-var DEFAULT_COMPUTE_PAYLOAD = { compute: { da_type: 0, verification: 0, compute: 0 } };
-var DEFAULT_EMPTY_PAYLOAD = { compute: { da_type: 0, verification: 0, compute: 0, agreement: [] } };
+var DEFAULT_COMPUTE_PAYLOAD = { compute: { daType: 0, verification: 0, compute: 0 } };
+var DEFAULT_EMPTY_PAYLOAD = { compute: { daType: 0, verification: 0, compute: 0, agreement: [] } };
 var API_EXTENSIONS = {
   CheckAppId: {
     extrinsic: {
@@ -496,6 +546,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: {}
   }
 };
 
@@ -1079,8 +1141,9 @@ async function joinGuardian(account, prefs) {
 
 // src/chain/utils.ts
 var signAndSend = async (request, account, opts = DEFAULT_COMPUTE_PAYLOAD) => {
+  const signOpts = { currencyId: null, ...opts };
   const tx_result = await new Promise((res, err) => {
-    request.signAndSend(account, opts, (result) => {
+    request.signAndSend(account, signOpts, (result) => {
       if (result.isFinalized) {
         res(result);
       }
@@ -1400,7 +1463,7 @@ var MCryptFsWriter = class {
     );
     console.log("account: ", this._account);
     return new Promise((resolve) => {
-      request.signAndSend(this._account, { app_id: 1 }, (result) => {
+      request.signAndSend(this._account, { app_id: 1, currencyId: null }, (result) => {
         if (result.isInBlock || result.isFinalized || result.isError) {
           resolve({
             blockNumber: result.blockNumber?.toNumber() ?? 0,
@@ -1515,15 +1578,22 @@ var FileFromMetadataRef = async (mcryptApi, metadataRef) => {
 };
 
 // src/compute/agreement.ts
-async function createAgreement(contract, account) {
+function buildFee(fee) {
+  return {
+    fees: toAtomicPaliAmount(fee?.amount ?? "0"),
+    computeRate: toAtomicPaliAmount(fee?.computeRate ?? "0")
+  };
+}
+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);
+  const onChainContract = { currencyId: "Native", ...contract };
+  const tx = api2.tx["compute"]["agreement"](onChainContract, oracle_quore_id ?? null);
   const opts = {
     compute: {
-      da_type: 1,
+      daType: 1,
       verification: 0,
-      compute: contract.contract_type === "Active" ? 1 : 0
+      compute: contract.contractType === "Active" ? 1 : 0
     }
   };
   const { tx_result, blockNumber, index, hash } = await signAndSend(
@@ -1555,22 +1625,22 @@ async function createSimpleAgreement() {
   const guardianIds = (await getGuardianAddress()).slice(0, 3).map((g) => g.address);
   assert(guardianIds.length === 3, "Not enough guardians to create agreement");
   const contract = {
-    contract_type: "Dormant",
+    contractType: "Dormant",
     guardians: guardianIds,
-    pre_check: null,
+    preCheck: null,
     compute: {
       cipher: "Plaintext",
-      computer_indices: [0, 1, 2],
-      fees: toAtomicPaliAmount("0.01"),
+      computerIndices: [0, 1, 2],
+      ...buildFee({ amount: "0", computeRate: "0" }),
       deadline: 0,
       confidentiality: { Trusted: 0 },
-      fee_function: null,
+      feeFunction: null,
       input: null,
       program: { NativeData: "DaFalse" },
       metadata: null
     },
-    post_check: null,
-    result_cipher: "Plaintext"
+    postCheck: null,
+    resultCipher: "Plaintext"
   };
   const keyring2 = await getKeyring();
   const account = keyring2.getPairs()[0];
@@ -1580,14 +1650,13 @@ async function createSimpleAgreement() {
 // src/compute/data.ts
 async function dataContract(params, account) {
   const plaintextCipher = "Plaintext";
-  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
   const computeStep = {
     cipher: plaintextCipher,
-    computer_indices: params.guardians.map((_, i) => i),
-    fees: atomicFees,
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
     deadline: params.deadline ?? 0,
     confidentiality: { Trusted: params.trustIndex ?? 0 },
-    fee_function: null,
+    feeFunction: null,
     input: {
       Url: {
         url: Array.from(new TextEncoder().encode(params.url))
@@ -1598,36 +1667,132 @@ async function dataContract(params, account) {
     }
   };
   const contract = {
-    contract_type: "Dormant",
+    contractType: "Dormant",
     guardians: params.guardians,
-    pre_check: null,
+    preCheck: null,
     compute: computeStep,
-    post_check: null,
-    result_cipher: plaintextCipher
+    postCheck: null,
+    resultCipher: plaintextCipher
   };
   return createAgreement(contract, account);
 }
 
+// src/compute/encryptedInference.ts
+import { edwardsToMontgomeryPub as edwardsToMontgomeryPub2 } from "@noble/curves/ed25519";
+
+// src/crypto/random.ts
+function generateRandomBytes(length = 32) {
+  const bytes = new Uint8Array(length);
+  const cr = globalThis.crypto;
+  if (!cr || typeof cr.getRandomValues !== "function") {
+    throw new Error(
+      "crypto.getRandomValues is not available. Ensure you're running in a supported environment (browser or Node.js 18+)."
+    );
+  }
+  cr.getRandomValues(bytes);
+  return bytes;
+}
+
+// src/compute/encryptedInference.ts
+async function encryptedInferenceSubscription(params, account) {
+  const computeStep = {
+    cipher: "Plaintext",
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
+    deadline: params.deadline ?? 0,
+    confidentiality: { Trusted: 0 },
+    feeFunction: null,
+    input: null,
+    program: { NativeExecute: "Inference" }
+  };
+  const contract = {
+    contractType: "Dormant",
+    guardians: params.guardians,
+    preCheck: null,
+    compute: computeStep,
+    postCheck: null,
+    resultCipher: "Plaintext"
+  };
+  return createAgreement(contract, account);
+}
+async function encryptedInferenceSubscriptionInvocation(params, encAccount, account) {
+  const api2 = await getApi();
+  if (!api2) throw new Error("Api not initialized");
+  const inputBytes = typeof params.input === "string" ? new TextEncoder().encode(params.input) : params.input;
+  const { encoded: cyphtxt, ikm } = testCrypt(
+    params.guardianInfo.tauParams,
+    params.guardianInfo.aggKey
+  );
+  const sharedKey = gen_stretched_key(hexToUint8Array(ikm));
+  const { ciphertext, nonce } = encrypt2(inputBytes, sharedKey);
+  const cyphtxtBytes = hexToUint8Array(cyphtxt);
+  const groupPkBytes = hexToUint8Array(params.guardianInfo.groupPk);
+  const tauParamsBytes = hexToUint8Array(params.guardianInfo.tauParams);
+  const tx = api2.tx["dataAvailability"]["daccComputeRequest"](
+    edwardsToMontgomeryPub2(encAccount.publicKey),
+    nonce,
+    Array.from(ciphertext),
+    params.guardians[0],
+    Array.from(cyphtxtBytes),
+    Array.from(groupPkBytes),
+    Array.from(tauParamsBytes),
+    params.guardians
+  );
+  const idHex = params.agreementId.startsWith("0x") ? params.agreementId.slice(2) : params.agreementId;
+  const opts = {
+    compute: {
+      da_type: 4,
+      agreement: [Buffer.from(idHex, "hex")],
+      verification: 0,
+      compute: 1
+    }
+  };
+  return signAndSend(tx, account, opts);
+}
+async function encryptedInferenceCompute(params, encAccount, account) {
+  const subscription = await encryptedInferenceSubscription(
+    {
+      guardians: params.guardians,
+      fee: params.fee,
+      deadline: params.deadline
+    },
+    account
+  );
+  if (!subscription.agreementId) {
+    throw new Error("Subscription creation did not return an agreement ID");
+  }
+  const invocation = await encryptedInferenceSubscriptionInvocation(
+    {
+      agreementId: subscription.agreementId,
+      input: params.input,
+      guardians: params.guardians,
+      guardianInfo: params.guardianInfo
+    },
+    encAccount,
+    account
+  );
+  return { subscription, invocation };
+}
+
 // src/compute/inference.ts
 async function inferenceCompute(params, account) {
   const inputData = typeof params.input === "string" ? Array.from(new TextEncoder().encode(params.input)) : Array.from(params.input);
-  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
   const plaintextCipher = "Plaintext";
   const computeStep = {
     cipher: plaintextCipher,
-    computer_indices: params.guardians.map((_, i) => i),
-    fees: atomicFees,
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
     deadline: params.deadline ?? 0,
     confidentiality: { Trusted: 0 },
-    fee_function: null,
+    feeFunction: null,
     input: { Inline: { data: inputData } },
     program: { NativeExecute: "Inference" }
   };
   const contract = {
-    contract_type: "Active",
+    contractType: "Active",
     guardians: params.guardians,
     compute: computeStep,
-    result_cipher: plaintextCipher
+    resultCipher: plaintextCipher
   };
   return createAgreement(contract, account);
 }
@@ -1698,14 +1863,13 @@ async function getGuardianParticipants() {
 // src/compute/simple.ts
 async function simpleCompute(params, account) {
   const plaintextCipher = "Plaintext";
-  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
   const computeStep = {
     cipher: plaintextCipher,
-    computer_indices: params.guardians.map((_, i) => i),
-    fees: atomicFees,
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
     deadline: params.deadline ?? 0,
     confidentiality: { Trusted: params.trustIndex ?? 0 },
-    fee_function: null,
+    feeFunction: null,
     input: null,
     program: {
       Url: {
@@ -1714,29 +1878,16 @@ async function simpleCompute(params, account) {
     }
   };
   const contract = {
-    contract_type: "Active",
+    contractType: "Active",
     guardians: params.guardians,
-    pre_check: null,
+    preCheck: null,
     compute: computeStep,
-    post_check: null,
-    result_cipher: plaintextCipher
+    postCheck: null,
+    resultCipher: plaintextCipher
   };
   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+)."
-    );
-  }
-  cr.getRandomValues(bytes);
-  return bytes;
-}
-
 // src/da/register.ts
 async function writeMetadata(account, name, description, ref, price, dataType, l2Owner, groupId) {
   const blobRef = [ref.blockNumber, ref.index];
@@ -1762,7 +1913,7 @@ async function writeMetadata(account, name, description, ref, price, dataType, l
 }
 async function registerDataAgreement(account, params) {
   debugLog(
-    `Registering data agreement for DA ref ${params.ref.blockNumber}-${params.ref.index} at ${formatPaliAmount(params.fees)}`
+    `Registering data agreement for DA ref ${params.ref.blockNumber}-${params.ref.index} at ${formatPaliAmount(toAtomicPaliAmount(params.fee.amount ?? "0"))}`
   );
   const cipher = params.cipher ?? "Plaintext";
   const resultCipher = params.resultCipher ?? "Plaintext";
@@ -1770,20 +1921,20 @@ async function registerDataAgreement(account, params) {
   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
+    storeType: params.metadata.storeType,
+    groupId: params.metadata.groupId
   } : null;
   const computeStep = {
     cipher,
-    computer_indices: params.guardians.map((_, i) => i),
-    fees: params.fees,
+    computerIndices: params.guardians.map((_, i) => i),
+    ...buildFee(params.fee),
     deadline: params.deadline ?? 0,
     confidentiality: { Trusted: params.trustIndex ?? 0 },
-    fee_function: null,
+    feeFunction: null,
     input: {
       ChainTransaction: {
-        block_number: params.ref.blockNumber,
-        extrinsic_index: params.ref.index
+        blockNumber: params.ref.blockNumber,
+        extrinsicIndex: params.ref.index
       }
     },
     program: {
@@ -1792,12 +1943,12 @@ async function registerDataAgreement(account, params) {
     metadata: computeMetadata
   };
   const contract = {
-    contract_type: "Dormant",
+    contractType: "Dormant",
     guardians: params.guardians,
-    pre_check: null,
+    preCheck: null,
     compute: computeStep,
-    post_check: null,
-    result_cipher: resultCipher
+    postCheck: null,
+    resultCipher
   };
   return createAgreement(contract, account);
 }
@@ -1822,7 +1973,7 @@ async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes,
   );
   const opts = {
     compute: {
-      da_type: 4,
+      daType: 4,
       verification: 0,
       compute: 1,
       agreement: [agreementId]
@@ -1881,14 +2032,14 @@ async function submitTEDataWithCipher(account, data, chosenGuardians, tau_params
     ref,
     cipher: {
       ThresholdHybrid: {
-        threshold_params: {
+        thresholdParams: {
           SilentThreshold: {
-            td_params: Array.from(hexToUint8Array(encryptedKey)),
-            pk_bytes: Array.from(hexToUint8Array(group_pk)),
-            tau_params: Array.from(hexToUint8Array(tau_params))
+            tdParams: Array.from(hexToUint8Array(encryptedKey)),
+            pkBytes: Array.from(hexToUint8Array(group_pk)),
+            tauParams: Array.from(hexToUint8Array(tau_params))
           }
         },
-        symmetric_params: {
+        symmetricParams: {
           ChaCha20Poly1305: { nonce: Array.from(nonce) }
         }
       }
@@ -1907,7 +2058,6 @@ async function uploadData(options) {
   );
   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 {
@@ -1923,7 +2073,7 @@ async function uploadData(options) {
     await registerDataAgreement(account, {
       ref: dataRef,
       guardians: guardianGroupInfo.guardians,
-      fees: atomicPrice,
+      fee: { amount: price },
       cipher,
       metadata: {
         name,
@@ -2625,6 +2775,7 @@ export {
   WsProvider3 as WsProvider,
   addStake,
   base64ToUint8Array,
+  buildFee,
   clearTokenCache,
   configure,
   createAccount,
@@ -2641,6 +2792,9 @@ export {
   encrypt as ecncryptTest,
   encodeCiphertext,
   encrypt2 as encrypt,
+  encryptedInferenceCompute,
+  encryptedInferenceSubscription,
+  encryptedInferenceSubscriptionInvocation,
   fetchAndDecodeExtrinsic,
   fetchTokenProperties,
   formatBalanceWithTokenProperties,