@palliora.org/chainsdk 0.3.1 → 0.3.3

package/dist/index.js

@@ -1,3 +1,14 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
 // src/account/account.ts
 import { waitReady } from "@polkadot/wasm-crypto";
 
@@ -21,7 +32,9 @@ var AccountSourceType = /* @__PURE__ */ ((AccountSourceType2) => {
 import { Keyring } from "@polkadot/api";
 import { hexToU8a } from "@polkadot/util";
 import { ed25519PairFromSecret, secp256k1PairFromSeed } from "@polkadot/util-crypto";
-async function createAccount(input, type, name = "default", cryptoType = "sr25519" /* SR25519 */) {
+import { keccak256 } from "viem";
+import { poseidon1, poseidon2 } from "poseidon-lite";
+async function createAccount(input, type, name = "default", cryptoType = "sr25519" /* SR25519 */, signedMsg = "sign") {
   await waitReady();
   const keyring2 = new Keyring({ type: cryptoType });
   switch (type) {
@@ -48,6 +61,12 @@ async function createAccount(input, type, name = "default", cryptoType = "sr2551
         cryptoType
       );
       return account;
+    case "derived" /* DERIVED */:
+      if (!input.startsWith("0x")) {
+        throw new Error("Invalid signature format for derived account. Expected hex string starting with 0x.");
+      }
+      const signKeyBytes = sigToSeed(signedMsg, input);
+      return createAccount(signKeyBytes, "seed" /* SEED */, name, cryptoType);
     default:
       throw new Error("Invalid input type");
   }
@@ -83,6 +102,15 @@ function pairFromPrivateKeyHex(privateKeyHex, cryptoType) {
       throw new Error(`Unsupported crypto type: ${cryptoType}`);
   }
 }
+function sigToSeed(msg, sign) {
+  const seed = BigInt(keccak256(sign));
+  const encoder = new TextEncoder();
+  const signBytes = encoder.encode(msg);
+  const signHex = Array.from(signBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const SALT_SIGN = poseidon1([BigInt(`0x${signHex}`)]);
+  const signKeyBytes = poseidon2([seed.toString(), SALT_SIGN]).toString(16).slice(0, 64);
+  return signKeyBytes;
+}
 
 // src/chain/spec.ts
 var API_RPC = {
@@ -175,7 +203,7 @@ var API_TYPES = {
   },
   GuardianNwParams: {
     kzg: "Vec<u8>",
-    agg_key: "Vec<u8>"
+    aggKey: "Vec<u8>"
   },
   AppId: "Compact<u32>",
   DataLookupItem: {
@@ -226,9 +254,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: {
@@ -254,16 +282,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>>"
@@ -275,12 +303,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: {
@@ -298,7 +326,7 @@ var API_TYPES = {
     }
   },
   NativeExecuteDA: {
-    _enum: ["Inference"]
+    _enum: ["Inference", "ContractAccess"]
   },
   NativeDataDA: {
     _enum: ["DaFalse", "DaTrue"]
@@ -307,8 +335,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>",
@@ -324,6 +355,7 @@ var API_TYPES = {
       Null: "Null",
       Inline: "DAInputInline",
       ChainTransaction: "DAInputChainTransaction",
+      ContractId: "DAInputContractId",
       Ipfs: "DAInputIpfs",
       Url: "DAInputUrl",
       NativeExecute: "NativeExecuteDA",
@@ -333,7 +365,8 @@ var API_TYPES = {
   ContractType: {
     _enum: {
       Dormant: "Null",
-      Active: "Null"
+      Active: "Null",
+      Subscription: "Null"
     }
   },
   StoreType: {
@@ -347,28 +380,29 @@ 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"
   },
   AgreementInfo: {
     status: "AgreementStatus",
@@ -376,7 +410,7 @@ var API_TYPES = {
     index: "u32"
   },
   ComputePayload: {
-    da_type: "u8",
+    daType: "u8",
     agreement: "Option<BoundedVec<[u8; 32], 10>>",
     verification: "u8",
     compute: "u8"
@@ -452,10 +486,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: {
@@ -1487,15 +1557,21 @@ 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 tx = api2.tx["compute"]["agreement"](contract, 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(
@@ -1527,22 +1603,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];
@@ -1552,14 +1628,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))
@@ -1570,12 +1645,12 @@ 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);
 }
@@ -1583,23 +1658,22 @@ async function dataContract(params, account) {
 // src/compute/inference.ts
 async function inferenceCompute(params, account) {
   const inputData = typeof params.input === "string" ? Array.from(new TextEncoder().encode(params.input)) : Array.from(params.input);
-  const atomicFees = toAtomicPaliAmount(params.fees ?? "0");
   const plaintextCipher = "Plaintext";
   const computeStep = {
     cipher: plaintextCipher,
-    computer_indices: params.guardians.map((_, i) => i),
-    fees: atomicFees,
+    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);
 }
@@ -1670,14 +1744,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: {
@@ -1686,12 +1759,12 @@ 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);
 }
@@ -1734,7 +1807,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";
@@ -1742,20 +1815,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: {
@@ -1764,12 +1837,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);
 }
@@ -1794,7 +1867,7 @@ async function runAgent(account, agentRef, nonce, ciphertext, tdParams, pkBytes,
   );
   const opts = {
     compute: {
-      da_type: 4,
+      daType: 4,
       verification: 0,
       compute: 1,
       agreement: [agreementId]
@@ -1853,14 +1926,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) }
         }
       }
@@ -1879,7 +1952,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 {
@@ -1895,7 +1967,7 @@ async function uploadData(options) {
     await registerDataAgreement(account, {
       ref: dataRef,
       guardians: guardianGroupInfo.guardians,
-      fees: atomicPrice,
+      fee: { amount: price },
       cipher,
       metadata: {
         name,
@@ -2115,6 +2187,464 @@ export * from "@polkadot/util";
 import * as utilCrypto from "@polkadot/util-crypto";
 import * as wasmCrypto from "@polkadot/wasm-crypto";
 import { ApiPromise as ApiPromise2, WsProvider as WsProvider3, HttpProvider } from "@polkadot/api";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/bundle.js
+import { decodeAddress as decodeAddress3, encodeAddress as encodeAddress2, setSS58Format } from "@polkadot/util-crypto";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/keyring.js
+import { hexToU8a as hexToU8a2, isHex as isHex2, stringToU8a } from "@polkadot/util";
+import { base64Decode, decodeAddress as decodeAddress2, ed25519PairFromSeed as ed25519FromSeed2, encodeAddress, ethereumEncode as ethereumEncode2, hdEthereum, keyExtractSuri, keyFromPath as keyFromPath2, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed2, sr25519PairFromSeed as sr25519FromSeed2 } from "@polkadot/util-crypto";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/index.js
+import { objectSpread as objectSpread2, u8aConcat as u8aConcat2, u8aEmpty, u8aEq as u8aEq2, u8aToHex, u8aToU8a } from "@polkadot/util";
+import { blake2AsU8a, ed25519PairFromSeed as ed25519FromSeed, ed25519Sign, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, secp256k1Compress, secp256k1Expand, secp256k1PairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify, sr25519PairFromSeed as sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify } from "@polkadot/util-crypto";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/decode.js
+import { u8aEq } from "@polkadot/util";
+import { jsonDecryptData } from "@polkadot/util-crypto";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/defaults.js
+var PAIR_DIV = new Uint8Array([161, 35, 3, 33, 0]);
+var PAIR_HDR = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
+var PUB_LENGTH = 32;
+var SEC_LENGTH = 64;
+var SEED_LENGTH = 32;
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/decode.js
+var SEED_OFFSET = PAIR_HDR.length;
+function decodePair(passphrase, encrypted, _encType) {
+  const encType = Array.isArray(_encType) || _encType === void 0 ? _encType : [_encType];
+  const decrypted = jsonDecryptData(encrypted, passphrase, encType);
+  const header = decrypted.subarray(0, PAIR_HDR.length);
+  if (!u8aEq(header, PAIR_HDR)) {
+    throw new Error("Invalid encoding header found in body");
+  }
+  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
+  let divOffset = SEED_OFFSET + SEC_LENGTH;
+  let divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
+  if (!u8aEq(divider, PAIR_DIV)) {
+    divOffset = SEED_OFFSET + SEED_LENGTH;
+    secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
+    divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
+    if (!u8aEq(divider, PAIR_DIV)) {
+      throw new Error("Invalid encoding divider found in body");
+    }
+  }
+  const pubOffset = divOffset + PAIR_DIV.length;
+  const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
+  return {
+    publicKey,
+    secretKey
+  };
+}
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/encode.js
+import { u8aConcat } from "@polkadot/util";
+import { naclEncrypt, scryptEncode, scryptToU8a } from "@polkadot/util-crypto";
+function encodePair({ publicKey, secretKey }, passphrase) {
+  if (!secretKey) {
+    throw new Error("Expected a valid secretKey to be passed to encode");
+  }
+  const encoded = u8aConcat(PAIR_HDR, secretKey, PAIR_DIV, publicKey);
+  if (!passphrase) {
+    return encoded;
+  }
+  const { params, password, salt } = scryptEncode(passphrase);
+  const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+  return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+}
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/toJson.js
+import { objectSpread } from "@polkadot/util";
+import { jsonEncryptFormat } from "@polkadot/util-crypto";
+function pairToJson(type, { address, meta }, encoded, isEncrypted) {
+  return objectSpread(jsonEncryptFormat(encoded, ["pkcs8", type], isEncrypted), {
+    address,
+    meta
+  });
+}
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pair/index.js
+var SIG_TYPE_NONE = new Uint8Array();
+var TYPE_FROM_SEED = {
+  ecdsa: secp256k1FromSeed,
+  ed25519: ed25519FromSeed,
+  ethereum: secp256k1FromSeed,
+  sr25519: sr25519FromSeed
+};
+var TYPE_PREFIX = {
+  ecdsa: new Uint8Array([2]),
+  ed25519: new Uint8Array([0]),
+  ethereum: new Uint8Array([2]),
+  sr25519: new Uint8Array([1])
+};
+var TYPE_SIGNATURE = {
+  ecdsa: (m, p) => secp256k1Sign(m, p, "blake2"),
+  ed25519: ed25519Sign,
+  ethereum: (m, p) => secp256k1Sign(m, p, "keccak"),
+  sr25519: sr25519Sign
+};
+var TYPE_ADDRESS = {
+  ecdsa: (p) => p.length > 32 ? blake2AsU8a(p) : p,
+  ed25519: (p) => p,
+  ethereum: (p) => p.length === 20 ? p : keccakAsU8a(secp256k1Expand(p)),
+  sr25519: (p) => p
+};
+function isLocked(secretKey) {
+  return !secretKey || u8aEmpty(secretKey);
+}
+function vrfHash(proof, context, extra) {
+  return blake2AsU8a(u8aConcat2(context || "", extra || "", proof));
+}
+function createPair({ toSS58, type }, { publicKey, secretKey }, meta = {}, encoded = null, encTypes) {
+  const decodePkcs8 = (passphrase, userEncoded) => {
+    const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
+    if (decoded.secretKey.length === 64) {
+      publicKey = decoded.publicKey;
+      secretKey = decoded.secretKey;
+    } else {
+      const pair = TYPE_FROM_SEED[type](decoded.secretKey);
+      publicKey = pair.publicKey;
+      secretKey = pair.secretKey;
+    }
+  };
+  const recode = (passphrase) => {
+    isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
+    encoded = encodePair({ publicKey, secretKey }, passphrase);
+    encTypes = void 0;
+    return encoded;
+  };
+  const encodeAddress3 = () => {
+    const raw = TYPE_ADDRESS[type](publicKey);
+    return type === "ethereum" ? ethereumEncode(raw) : toSS58(raw);
+  };
+  return {
+    get address() {
+      return encodeAddress3();
+    },
+    get addressRaw() {
+      const raw = TYPE_ADDRESS[type](publicKey);
+      return type === "ethereum" ? raw.slice(-20) : raw;
+    },
+    get isLocked() {
+      return isLocked(secretKey);
+    },
+    get meta() {
+      return meta;
+    },
+    get publicKey() {
+      return publicKey;
+    },
+    get type() {
+      return type;
+    },
+    // eslint-disable-next-line sort-keys
+    decodePkcs8,
+    derive: (suri, meta2) => {
+      if (type === "ethereum") {
+        throw new Error("Unable to derive on this keypair");
+      } else if (isLocked(secretKey)) {
+        throw new Error("Cannot derive on a locked keypair");
+      }
+      const { path: path2 } = keyExtractPath(suri);
+      const derived = keyFromPath({ publicKey, secretKey }, path2, type);
+      return createPair({ toSS58, type }, derived, meta2, null);
+    },
+    encodePkcs8: (passphrase) => {
+      return recode(passphrase);
+    },
+    lock: () => {
+      secretKey = new Uint8Array();
+    },
+    setMeta: (additional) => {
+      meta = objectSpread2({}, meta, additional);
+    },
+    sign: (message, options = {}) => {
+      if (isLocked(secretKey)) {
+        throw new Error("Cannot sign with a locked key pair");
+      }
+      return u8aConcat2(options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE, TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey }));
+    },
+    toJson: (passphrase) => {
+      const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? u8aToHex(publicKey) : u8aToHex(secp256k1Compress(publicKey)) : encodeAddress3();
+      return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
+    },
+    unlock: (passphrase) => {
+      return decodePkcs8(passphrase);
+    },
+    verify: (message, signature, signerPublic) => {
+      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
+    },
+    vrfSign: (message, context, extra) => {
+      if (isLocked(secretKey)) {
+        throw new Error("Cannot sign with a locked key pair");
+      }
+      if (type === "sr25519") {
+        return sr25519VrfSign(message, { secretKey }, context, extra);
+      }
+      const proof = TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey });
+      return u8aConcat2(vrfHash(proof, context, extra), proof);
+    },
+    vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
+      if (type === "sr25519") {
+        return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
+      }
+      const result = signatureVerify(message, u8aConcat2(TYPE_PREFIX[type], vrfResult.subarray(32)), TYPE_ADDRESS[type](u8aToU8a(signerPublic)));
+      return result.isValid && u8aEq2(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra));
+    }
+  };
+}
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/defaults.js
+var DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/pairs.js
+import { isHex, isU8a, u8aToHex as u8aToHex2, u8aToU8a as u8aToU8a2 } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+var _map;
+var Pairs = class {
+  constructor() {
+    __privateAdd(this, _map, {});
+  }
+  add(pair) {
+    __privateGet(this, _map)[decodeAddress(pair.address).toString()] = pair;
+    return pair;
+  }
+  all() {
+    return Object.values(__privateGet(this, _map));
+  }
+  get(address) {
+    const pair = __privateGet(this, _map)[decodeAddress(address).toString()];
+    if (!pair) {
+      throw new Error(`Unable to retrieve keypair '${isU8a(address) || isHex(address) ? u8aToHex2(u8aToU8a2(address)) : address}'`);
+    }
+    return pair;
+  }
+  remove(address) {
+    delete __privateGet(this, _map)[decodeAddress(address).toString()];
+  }
+};
+_map = new WeakMap();
+
+// node_modules/.pnpm/@polkadot+keyring@13.5.9_@polkadot+util-crypto@13.5.9_@polkadot+util@13.5.9__@polkadot+util@13.5.9/node_modules/@polkadot/keyring/keyring.js
+var PairFromSeed = {
+  ecdsa: (seed) => secp256k1FromSeed2(seed),
+  ed25519: (seed) => ed25519FromSeed2(seed),
+  ethereum: (seed) => secp256k1FromSeed2(seed),
+  sr25519: (seed) => sr25519FromSeed2(seed)
+};
+function pairToPublic({ publicKey }) {
+  return publicKey;
+}
+var _pairs, _type, _ss58;
+var Keyring3 = class {
+  constructor(options = {}) {
+    __privateAdd(this, _pairs);
+    __privateAdd(this, _type);
+    __privateAdd(this, _ss58);
+    __publicField(this, "decodeAddress", decodeAddress2);
+    /**
+     * @name encodeAddress
+     * @description Encodes the input into an ss58 representation
+     */
+    __publicField(this, "encodeAddress", (address, ss58Format) => {
+      return this.type === "ethereum" ? ethereumEncode2(address) : encodeAddress(address, ss58Format ?? __privateGet(this, _ss58));
+    });
+    options.type = options.type || "ed25519";
+    if (!["ecdsa", "ethereum", "ed25519", "sr25519"].includes(options.type || "undefined")) {
+      throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || "unknown"}`);
+    }
+    __privateSet(this, _pairs, new Pairs());
+    __privateSet(this, _ss58, options.ss58Format);
+    __privateSet(this, _type, options.type);
+  }
+  /**
+   * @description retrieve the pairs (alias for getPairs)
+   */
+  get pairs() {
+    return this.getPairs();
+  }
+  /**
+   * @description retrieve the publicKeys (alias for getPublicKeys)
+   */
+  get publicKeys() {
+    return this.getPublicKeys();
+  }
+  /**
+   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
+   */
+  get type() {
+    return __privateGet(this, _type);
+  }
+  /**
+   * @name addPair
+   * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   */
+  addPair(pair) {
+    return __privateGet(this, _pairs).add(pair);
+  }
+  /**
+   * @name addFromAddress
+   * @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
+   * the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from them that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromAddress(address, meta = {}, encoded = null, type = this.type, ignoreChecksum, encType) {
+    const publicKey = this.decodeAddress(address, ignoreChecksum);
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded, encType));
+  }
+  /**
+   * @name addFromJson
+   * @summary Stores an account, given JSON data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to provide a json object argument that contains account information (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from it that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromJson(json, ignoreChecksum) {
+    return this.addPair(this.createFromJson(json, ignoreChecksum));
+  }
+  /**
+   * @name addFromMnemonic
+   * @summary Stores an account, given a mnemonic, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Allows user to provide a mnemonic (seed phrase that is provided when account is originally created)
+   * argument and a metadata argument that contains account information (that may be obtained from the json file
+   * of an account backup), and then generates a keyring pair from it that it passes to
+   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromMnemonic(mnemonic, meta = {}, type = this.type, wordlist) {
+    return this.addFromUri(mnemonic, meta, type, wordlist);
+  }
+  /**
+   * @name addFromPair
+   * @summary Stores an account created from an explicit publicKey/secreteKey combination
+   */
+  addFromPair(pair, meta = {}, type = this.type) {
+    return this.addPair(this.createFromPair(pair, meta, type));
+  }
+  /**
+   * @name addFromSeed
+   * @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+   * @description Stores in a keyring pair dictionary the public key of the pair as a key and the pair as the associated value.
+   * Allows user to provide the account seed as an argument, and then generates a keyring pair from it that it passes to
+   * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+   */
+  addFromSeed(seed, meta = {}, type = this.type) {
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, PairFromSeed[type](seed), meta, null));
+  }
+  /**
+   * @name addFromUri
+   * @summary Creates an account via an suri
+   * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed). The secret can be a hex string, mnemonic phrase or a string (to be padded)
+   */
+  addFromUri(suri, meta = {}, type = this.type, wordlist) {
+    return this.addPair(this.createFromUri(suri, meta, type, wordlist));
+  }
+  /**
+   * @name createFromJson
+   * @description Creates a pair from a JSON keyfile
+   */
+  createFromJson({ address, encoded, encoding: { content, type, version }, meta }, ignoreChecksum) {
+    if (version === "3" && content[0] !== "pkcs8") {
+      throw new Error(`Unable to decode non-pkcs8 type, [${content.join(",")}] found}`);
+    }
+    const cryptoType = version === "0" || !Array.isArray(content) ? this.type : content[1];
+    const encType = !Array.isArray(type) ? [type] : type;
+    if (!["ed25519", "sr25519", "ecdsa", "ethereum"].includes(cryptoType)) {
+      throw new Error(`Unknown crypto type ${cryptoType}`);
+    }
+    const publicKey = isHex2(address) ? hexToU8a2(address) : this.decodeAddress(address, ignoreChecksum);
+    const decoded = isHex2(encoded) ? hexToU8a2(encoded) : base64Decode(encoded);
+    return createPair({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
+  }
+  /**
+   * @name createFromPair
+   * @summary Creates a pair from an explicit publicKey/secreteKey combination
+   */
+  createFromPair(pair, meta = {}, type = this.type) {
+    return createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
+  }
+  /**
+   * @name createFromUri
+   * @summary Creates a Keypair from an suri
+   * @description This creates a pair from the suri, but does not add it to the keyring
+   */
+  createFromUri(_suri, meta = {}, type = this.type, wordlist) {
+    const suri = _suri.startsWith("//") ? `${DEV_PHRASE}${_suri}` : _suri;
+    const { derivePath, password, path: path2, phrase } = keyExtractSuri(suri);
+    let seed;
+    const isPhraseHex = isHex2(phrase, 256);
+    if (isPhraseHex) {
+      seed = hexToU8a2(phrase);
+    } else {
+      const parts = phrase.split(" ");
+      if ([12, 15, 18, 21, 24].includes(parts.length)) {
+        seed = type === "ethereum" ? mnemonicToLegacySeed(phrase, "", false, 64) : mnemonicToMiniSecret(phrase, password, wordlist);
+      } else {
+        if (phrase.length > 32) {
+          throw new Error("specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes");
+        }
+        seed = stringToU8a(phrase.padEnd(32));
+      }
+    }
+    const derived = type === "ethereum" ? isPhraseHex ? PairFromSeed[type](seed) : hdEthereum(seed, derivePath.substring(1)) : keyFromPath2(PairFromSeed[type](seed), path2, type);
+    return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
+  }
+  /**
+   * @name getPair
+   * @summary Retrieves an account keyring pair from the Keyring Pair Dictionary, given an account address
+   * @description Returns a keyring pair value from the keyring pair dictionary by performing
+   * a key lookup using the provided account address or public key (after decoding it).
+   */
+  getPair(address) {
+    return __privateGet(this, _pairs).get(address);
+  }
+  /**
+   * @name getPairs
+   * @summary Retrieves all account keyring pairs from the Keyring Pair Dictionary
+   * @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
+   */
+  getPairs() {
+    return __privateGet(this, _pairs).all();
+  }
+  /**
+   * @name getPublicKeys
+   * @summary Retrieves Public Keys of all Keyring Pairs stored in the Keyring Pair Dictionary
+   * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
+   */
+  getPublicKeys() {
+    return __privateGet(this, _pairs).all().map(pairToPublic);
+  }
+  /**
+   * @name removePair
+   * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
+   */
+  removePair(address) {
+    __privateGet(this, _pairs).remove(address);
+  }
+  /**
+   * @name setSS58Format;
+   * @description Sets the ss58 format for the keyring
+   */
+  setSS58Format(ss58) {
+    __privateSet(this, _ss58, ss58);
+  }
+  /**
+   * @name toJson
+   * @summary Returns a JSON object associated with the input argument that contains metadata assocated with an account
+   * @description Returns a JSON object containing the metadata associated with an account
+   * when valid address or public key and when the account passphrase is provided if the account secret
+   * is not already unlocked and available in memory. Note that in [Polkadot-JS Apps](https://github.com/polkadot-js/apps) the user
+   * may backup their account to a JSON file that contains this information.
+   */
+  toJson(address, passphrase) {
+    return __privateGet(this, _pairs).get(address).toJson(passphrase);
+  }
+};
+_pairs = new WeakMap();
+_type = new WeakMap();
+_ss58 = new WeakMap();
 export {
   API_EXTENSIONS,
   API_RPC,
@@ -2127,6 +2657,7 @@ export {
   DEFAULT_EMPTY_PAYLOAD,
   FileFromMetadataRef,
   HttpProvider,
+  Keyring3 as Keyring,
   MCryptFs,
   MCryptFsReader,
   MCryptFsWriter,
@@ -2138,6 +2669,7 @@ export {
   WsProvider3 as WsProvider,
   addStake,
   base64ToUint8Array,
+  buildFee,
   clearTokenCache,
   configure,
   createAccount,