@talismn/sapi 0.0.0-pr2277-20251211071316 → 0.0.0-pr2295-20260110044132

package/dist/index.mjs

@@ -0,0 +1,616 @@
+// src/sapi.ts
+import { parseMetadataRpc } from "@talismn/scale";
+
+// src/log.ts
+import anylogger from "anylogger";
+
+// package.json
+var package_default = {
+  name: "@talismn/sapi",
+  version: "0.0.0-pr2295-20260110044132",
+  author: "Talisman",
+  homepage: "https://talisman.xyz",
+  license: "GPL-3.0-or-later",
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    directory: "packages/sapi",
+    type: "git",
+    url: "https://github.com/talismansociety/talisman.git"
+  },
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    test: "vitest run",
+    lint: "eslint src --max-warnings 0",
+    clean: "rm -rf dist .turbo node_modules",
+    build: "tsup"
+  },
+  dependencies: {
+    "@polkadot-api/merkleize-metadata": "1.1.18",
+    "@polkadot-api/metadata-builders": "0.12.2",
+    "@polkadot-api/substrate-bindings": "0.14.0",
+    "@polkadot-api/utils": "0.2.0",
+    "@polkadot/types": "16.1.2",
+    "@polkadot/types-codec": "16.1.2",
+    "@polkadot/util": "13.5.3",
+    "@talismn/scale": "workspace:*",
+    anylogger: "^1.0.11",
+    "polkadot-api": "1.13.1",
+    "scale-ts": "^1.6.1"
+  },
+  devDependencies: {
+    "@talismn/eslint-config": "workspace:*",
+    "@talismn/tsconfig": "workspace:*",
+    eslint: "^8.57.1",
+    typescript: "^5.6.3"
+  },
+  eslintConfig: {
+    root: true,
+    extends: [
+      "@talismn/eslint-config/base"
+    ]
+  },
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.mts",
+        default: "./dist/index.mjs"
+      },
+      require: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      }
+    }
+  }
+};
+
+// src/log.ts
+var log_default = anylogger(package_default.name);
+
+// src/helpers/getCallDocs.ts
+var getCallDocs = (chain, pallet, method) => {
+  try {
+    const typeIdCalls = chain.metadata.pallets.find(({ name }) => name === pallet)?.calls?.type;
+    if (!typeIdCalls) return null;
+    let palletCalls = chain.metadata.lookup[typeIdCalls];
+    if (!palletCalls || palletCalls.id !== typeIdCalls)
+      palletCalls = chain.metadata.lookup.find((v) => v.id === typeIdCalls);
+    if (!palletCalls) return null;
+    const call = palletCalls.def.value.find(
+      (c) => c.name === method
+    );
+    return call?.docs?.join("\n") ?? null;
+  } catch (err) {
+    log_default.error("Failed to find call docs", { pallet, method, chain });
+    return null;
+  }
+};
+
+// src/helpers/getConstantValue.ts
+import { getConstantValueFromMetadata } from "@talismn/scale";
+var getConstantValue = (chain, pallet, constant) => {
+  return getConstantValueFromMetadata(
+    {
+      builder: chain.builder,
+      unifiedMetadata: chain.metadata
+    },
+    pallet,
+    constant
+  );
+};
+
+// src/helpers/getChainInfo.ts
+var getChainInfo = (chain) => {
+  const {
+    spec_name: specName,
+    spec_version: specVersion,
+    transaction_version: transactionVersion
+  } = getConstantValue(chain, "System", "Version");
+  const base58Prefix = getConstantValue(chain, "System", "SS58Prefix");
+  return {
+    specName,
+    specVersion,
+    transactionVersion,
+    base58Prefix
+  };
+};
+
+// src/helpers/getDecodedCall.ts
+var getDecodedCall = (palletName, methodName, args) => ({
+  type: palletName,
+  value: { type: methodName, value: args }
+});
+var getDecodedCallFromPayload = (chain, payload) => {
+  const def = chain.builder.buildDefinition(chain.lookup.call);
+  const decoded = def.dec(payload.method);
+  return {
+    pallet: decoded.type,
+    method: decoded.value.type,
+    args: decoded.value.value
+  };
+};
+
+// src/helpers/getDryRunCall.ts
+import { Enum } from "polkadot-api";
+
+// src/helpers/errors.ts
+import { getLookupFn } from "@polkadot-api/metadata-builders";
+var getDispatchErrorMessage = (chain, err) => {
+  try {
+    if (!err) return null;
+    const error = err;
+    if (!error.type) throw new Error("Unknown dispatch error");
+    const lv1 = DISPATCH_ERROR[error.type];
+    if (!lv1) throw new Error("Unknown dispatch error");
+    if (lv1 === ERROR_METADATA_LOOKUP)
+      return getModuleErrorMessage(chain, error.value);
+    if (typeof lv1 === "string") return lv1;
+    const lv2 = lv1[error.value?.type];
+    if (!lv2) throw new Error("Unknown dispatch error");
+    if (typeof lv2 === "string") return lv2;
+    throw new Error("Unknown dispatch error");
+  } catch (cause) {
+    log_default.error("Failed to parse runtime error", { chainId: chain.connector.chainId, cause, err });
+    return tryFormatError(err);
+  }
+};
+var ERROR_METADATA_LOOKUP = "METADATA_LOOKUP";
+var ERRORS_TRANSACTIONAL = {
+  LimitReached: "Too many transactional layers have been spawned",
+  NoLayer: "A transactional layer was expected, but does not exist"
+};
+var ERRORS_TOKEN = {
+  FundsUnavailable: "Funds are unavailable",
+  OnlyProvider: "Account that must exist would die",
+  BelowMinimum: "Account cannot exist with the funds that would be given",
+  CannotCreate: "Account cannot be created",
+  UnknownAsset: "The asset in question is unknown",
+  Frozen: "Funds exist but are frozen",
+  Unsupported: "Operation is not supported by the asset",
+  CannotCreateHold: "Account cannot be created for recording amount on hold",
+  NotExpendable: "Account that is desired to remain would die",
+  Blocked: "Account cannot receive the assets"
+};
+var ERRORS_ARITHMETIC = {
+  Overflow: "An underflow would occur",
+  Underflow: "An overflow would occur",
+  DivisionByZero: "Division by zero"
+};
+var DISPATCH_ERROR = {
+  CannotLookup: "Cannot lookup",
+  BadOrigin: "Bad origin",
+  Module: ERROR_METADATA_LOOKUP,
+  ConsumerRemaining: "Consumer remaining",
+  NoProviders: "No providers",
+  TooManyConsumers: "Too many consumers",
+  Token: ERRORS_TOKEN,
+  Arithmetic: ERRORS_ARITHMETIC,
+  Transactional: ERRORS_TRANSACTIONAL,
+  Exhausted: "Resources exhausted",
+  Corruption: "State corrupt",
+  Unavailable: "Resource unavailable",
+  RootNotAllowed: "Root not allowed",
+  Trie: "Unknown error",
+  // unsupported,
+  Other: "Unknown error"
+  // unsupported,
+};
+var getModuleErrorMessage = (chain, error) => {
+  try {
+    if (!chain.metadata) throw new Error("Could not fetch metadata");
+    const pallet = chain.metadata.pallets.find((p) => p.name === error.type);
+    if (typeof pallet?.errors !== "number") throw new Error("Unknown pallet");
+    const lookup = getLookupFn(chain.metadata);
+    const palletErrors = lookup(pallet.errors);
+    if (palletErrors.type !== "enum" || !palletErrors.innerDocs[error.value.type]?.length)
+      throw new Error("Unknown error type");
+    return palletErrors.innerDocs[error.value.type].join(" ");
+  } catch (err) {
+    log_default.error("Failed to parse module error", { chainId: chain.connector.chainId, error, err });
+    return [error.type, error.value.type].join(": ");
+  }
+};
+var tryFormatError = (err) => {
+  try {
+    const unsafeErr = err;
+    if (unsafeErr.type && unsafeErr.value?.type)
+      return [unsafeErr.type, unsafeErr.value.type].join(": ");
+  } catch (err2) {
+  }
+  return "Unknown error";
+};
+
+// src/helpers/getRuntimeCallResult.ts
+import { toHex } from "@polkadot-api/utils";
+
+// src/helpers/getSendRequestResult.ts
+var getSendRequestResult = (chain, method, params, isCacheable) => {
+  return chain.connector.send(method, params, isCacheable);
+};
+
+// src/helpers/getRuntimeCallResult.ts
+var getRuntimeCallResult = async (chain, apiName, method, args) => {
+  const call = chain.builder.buildRuntimeCall(apiName, method);
+  const hex = await getSendRequestResult(chain, "state_call", [
+    `${apiName}_${method}`,
+    toHex(call.args.enc(args))
+  ]);
+  return call.value.dec(hex);
+};
+
+// src/helpers/isApiAvailable.ts
+var isApiAvailable = (chain, name, method) => {
+  return chain.metadata.apis.some(
+    (a) => a.name === name && a.methods.some((m) => m.name === method)
+  );
+};
+
+// src/helpers/getDryRunCall.ts
+var getDryRunCall = async (chain, from, decodedCall) => {
+  try {
+    if (!isApiAvailable(chain, "DryRunApi", "dry_run_call"))
+      return {
+        available: false,
+        data: null
+      };
+    const origin = Enum("system", Enum("Signed", from));
+    const { pallet, method, args } = decodedCall;
+    const call = { type: pallet, value: { type: method, value: args } };
+    const data = await getRuntimeCallResult(chain, "DryRunApi", "dry_run_call", [
+      origin,
+      call
+    ]);
+    const ok = data.success && data.value.execution_result.success;
+    const errorMessage = data.success && !data.value.execution_result.success ? getDispatchErrorMessage(chain, data.value.execution_result.value.error) : null;
+    return {
+      available: true,
+      // NOTE: we can't re-export `@polkadot-api/descriptors` from this package.
+      // So, the caller of this function must pass in their own instance of `type DryRunResult` as the generic argument `T`.
+      data,
+      ok,
+      errorMessage
+    };
+  } catch (err) {
+    log_default.error("Failed to dry run", { chainId: chain.connector.chainId, err });
+    return {
+      available: false,
+      data: null
+    };
+  }
+};
+
+// src/helpers/getFeeEstimate.ts
+import { Binary } from "polkadot-api";
+
+// src/helpers/getExtrinsicDispatchInfo.ts
+import { assert, u8aConcatStrict } from "@polkadot/util";
+var getExtrinsicDispatchInfo = async (chain, signedExtrinsic) => {
+  assert(signedExtrinsic.isSigned, "Extrinsic must be signed (or fakeSigned) in order to query fee");
+  const len = signedExtrinsic.registry.createType("u32", signedExtrinsic.encodedLength);
+  const dispatchInfo = await stateCall(
+    chain.connector.send,
+    "TransactionPaymentApi_query_info",
+    "RuntimeDispatchInfo",
+    [signedExtrinsic, len],
+    void 0,
+    true
+  );
+  return {
+    partialFee: dispatchInfo.partialFee.toString()
+  };
+};
+var stateCall = async (request, method, resultType, args, blockHash, isCacheable) => {
+  const registry = args[0].registry;
+  const bytes = registry.createType("Raw", u8aConcatStrict(args.map((arg) => arg.toU8a())));
+  const result = await request("state_call", [method, bytes.toHex(), blockHash], isCacheable);
+  return registry.createType(resultType, result);
+};
+
+// src/helpers/getTypeRegistry.ts
+import { Metadata, TypeRegistry } from "@polkadot/types";
+var getTypeRegistry = (chain, payload) => {
+  log_default.log(`[sapi] getTypeRegistry begin: ${Date.now()}`);
+  const registry = new TypeRegistry();
+  if (chain.registryTypes) registry.register(chain.registryTypes);
+  const meta = new Metadata(registry, chain.hexMetadata);
+  registry.setMetadata(meta, payload.signedExtensions, chain.signedExtensions);
+  log_default.log(`[sapi] getTypeRegistry end: ${Date.now()}`);
+  return registry;
+};
+
+// src/helpers/getFeeEstimate.ts
+var getFeeEstimate = async (chain, payload, chainInfo) => {
+  const registry = getTypeRegistry(chain, payload);
+  const extrinsic = registry.createType("Extrinsic", payload);
+  extrinsic.signFake(payload.address, {
+    appId: 0,
+    nonce: payload.nonce,
+    blockHash: payload.blockHash,
+    genesisHash: payload.genesisHash,
+    runtimeVersion: {
+      specVersion: chainInfo.specVersion,
+      transactionVersion: chainInfo.transactionVersion
+      // other fields aren't necessary for signing
+    }
+  });
+  const bytes = extrinsic.toU8a(true);
+  const binary = Binary.fromBytes(bytes);
+  try {
+    const result = await getRuntimeCallResult(
+      chain,
+      "TransactionPaymentApi",
+      "query_info",
+      [binary, bytes.length]
+    );
+    if (!result?.partial_fee && result.partial_fee !== 0n) {
+      throw new Error("partialFee is not found");
+    }
+    return result.partial_fee;
+  } catch (err) {
+    log_default.error("Failed to get fee estimate using getRuntimeCallValue", { err });
+  }
+  const { partialFee } = await getExtrinsicDispatchInfo(chain, extrinsic);
+  return BigInt(partialFee);
+};
+
+// src/helpers/getSapiConnector.ts
+var getSapiConnector = ({
+  chainId,
+  send,
+  submit: submit2,
+  submitWithBittensorMevShield
+}) => ({
+  chainId,
+  send,
+  submit: (...args) => {
+    if (submit2) return submit2(...args);
+    throw new Error("submit handler not provided");
+  },
+  submitWithBittensorMevShield: (...args) => {
+    if (submitWithBittensorMevShield) return submitWithBittensorMevShield(...args);
+    throw new Error("submitWithBittensorMevShield handler not provided");
+  }
+});
+
+// src/helpers/getSignerPayloadJSON.ts
+import { mergeUint8, toHex as toHex3 } from "@polkadot-api/utils";
+import { u8aToHex } from "@polkadot/util";
+import { Binary as Binary2 } from "polkadot-api";
+
+// src/helpers/getPayloadWithMetadataHash.ts
+import { merkleizeMetadata } from "@polkadot-api/merkleize-metadata";
+import { toHex as toHex2 } from "@polkadot-api/utils";
+var getPayloadWithMetadataHash = (chain, chainInfo, payload) => {
+  if (!chain.hasCheckMetadataHash || !payload.signedExtensions.includes("CheckMetadataHash"))
+    return {
+      payload,
+      txMetadata: void 0
+    };
+  try {
+    const { decimals, symbol: tokenSymbol } = chain.token;
+    const { base58Prefix, specName, specVersion } = chainInfo;
+    const metadataHashInputs = { tokenSymbol, decimals, base58Prefix, specName, specVersion };
+    const merkleizedMetadata = merkleizeMetadata(chain.hexMetadata, metadataHashInputs);
+    const metadataHash = toHex2(merkleizedMetadata.digest());
+    log_default.log("metadataHash", metadataHash, metadataHashInputs);
+    const payloadWithMetadataHash = {
+      ...payload,
+      mode: 1,
+      metadataHash,
+      withSignedTransaction: true
+    };
+    const registry = getTypeRegistry(chain, payload);
+    const extPayload = registry.createType("ExtrinsicPayload", payloadWithMetadataHash);
+    const barePayload = extPayload.toU8a(true);
+    const txMetadata = merkleizedMetadata.getProofForExtrinsicPayload(barePayload);
+    return {
+      payload: payloadWithMetadataHash,
+      txMetadata
+    };
+  } catch (err) {
+    log_default.error("Failed to get shortened metadata", { error: err });
+    return {
+      payload,
+      txMetadata: void 0
+    };
+  }
+};
+
+// src/helpers/getStorageValue.ts
+var getStorageValue = async (chain, pallet, entry, keys, at) => {
+  const storageCodec = chain.builder.buildStorage(pallet, entry);
+  const stateKey = storageCodec.keys.enc(...keys);
+  const hexValue = await getSendRequestResult(chain, "state_getStorage", [
+    stateKey,
+    at
+  ]);
+  if (!hexValue) return null;
+  return storageCodec.value.dec(hexValue);
+};
+
+// src/helpers/papi.ts
+import { Bytes, enhanceEncoder, u16 } from "@polkadot-api/substrate-bindings";
+var toPjsHex = (value, minByteLen) => {
+  let inner = value.toString(16);
+  inner = (inner.length % 2 ? "0" : "") + inner;
+  const nPaddedBytes = Math.max(0, (minByteLen || 0) - inner.length / 2);
+  return "0x" + "00".repeat(nPaddedBytes) + inner;
+};
+var mortal = enhanceEncoder(Bytes(2).enc, (value) => {
+  const factor = Math.max(value.period >> 12, 1);
+  const left = Math.min(Math.max(trailingZeroes(value.period) - 1, 1), 15);
+  const right = value.phase / factor << 4;
+  return u16.enc(left | right);
+});
+function trailingZeroes(n) {
+  let i = 0;
+  while (!(n & 1)) {
+    i++;
+    n >>= 1;
+  }
+  return i;
+}
+
+// src/helpers/getSignerPayloadJSON.ts
+var ERA_PERIOD = 64;
+var getSignerPayloadJSON = async (chain, palletName, methodName, args, signerConfig, chainInfo) => {
+  const { codec, location } = chain.builder.buildCall(palletName, methodName);
+  const method = Binary2.fromBytes(mergeUint8([new Uint8Array(location), codec.enc(args)]));
+  let blockHash = await getSendRequestResult(
+    chain,
+    "chain_getFinalizedHead",
+    [],
+    false
+  );
+  const [nonce, genesisHash, blockNumberFinalized, blockNumberCurrent] = await Promise.all([
+    getSendRequestResult(chain, "system_accountNextIndex", [signerConfig.address], false),
+    getStorageValue(chain, "System", "BlockHash", [0]),
+    getStorageValue(chain, "System", "Number", [], blockHash),
+    getStorageValue(chain, "System", "Number", [])
+  ]);
+  if (!genesisHash) throw new Error("Genesis hash not found");
+  if (!blockHash) throw new Error("Block hash not found");
+  let blockNumber = blockNumberFinalized;
+  if (blockNumberCurrent - blockNumberFinalized > 32) {
+    blockNumber = blockNumberCurrent - 16;
+    const binBlockHash = await getStorageValue(chain, "System", "BlockHash", [blockNumber]);
+    blockHash = binBlockHash.asHex();
+  }
+  const era = mortal({ period: ERA_PERIOD, phase: blockNumber % ERA_PERIOD });
+  const signedExtensions = chain.metadata.extrinsic.signedExtensions.map((ext) => ext.identifier);
+  const basePayload = {
+    address: signerConfig.address,
+    genesisHash: genesisHash.asHex(),
+    blockHash,
+    method: method.asHex(),
+    signedExtensions,
+    nonce: toPjsHex(nonce, 4),
+    specVersion: toPjsHex(chainInfo.specVersion, 4),
+    transactionVersion: toPjsHex(chainInfo.transactionVersion, 4),
+    blockNumber: toPjsHex(blockNumber, 4),
+    era: toHex3(era),
+    tip: toPjsHex(0, 16),
+    // TODO gas station (required for Astar)
+    assetId: void 0,
+    version: 4
+  };
+  const { payload, txMetadata } = getPayloadWithMetadataHash(chain, chainInfo, basePayload);
+  const shortMetadata = txMetadata ? u8aToHex(txMetadata) : void 0;
+  if (payload.signedExtensions.includes("CheckAppId"))
+    payload.appId = 0;
+  log_default.log("[sapi] payload", { newPayload: payload, txMetadata });
+  return {
+    payload,
+    txMetadata,
+    // TODO remove
+    shortMetadata
+  };
+};
+
+// src/helpers/submit.ts
+var submit = async (chain, payload, signature, txInfo, mode) => {
+  switch (mode) {
+    case "bittensor-mev-shield":
+      if (signature)
+        throw new Error("Signature should not be provided when using bittensor-mev-shield mode");
+      return chain.connector.submitWithBittensorMevShield(payload, txInfo);
+    default:
+      return chain.connector.submit(payload, signature, txInfo);
+  }
+};
+
+// src/sapi.ts
+var getScaleApi = (connector, hexMetadata, token, hasCheckMetadataHash, signedExtensions, registryTypes) => {
+  const { unifiedMetadata: metadata, lookupFn: lookup, builder } = parseMetadataRpc(hexMetadata);
+  const chain = {
+    connector: getSapiConnector(connector),
+    hexMetadata,
+    token,
+    hasCheckMetadataHash,
+    signedExtensions,
+    registryTypes,
+    metadata,
+    lookup,
+    builder,
+    metadataRpc: hexMetadata
+  };
+  const chainInfo = getChainInfo(chain);
+  const { specName, specVersion, base58Prefix } = chainInfo;
+  return {
+    id: `${connector.chainId}::${specName}::${specVersion}`,
+    chainId: connector.chainId,
+    specName,
+    specVersion,
+    hasCheckMetadataHash,
+    base58Prefix,
+    token: chain.token,
+    chain,
+    getConstant: (pallet, constant) => getConstantValue(chain, pallet, constant),
+    getStorage: (pallet, entry, keys, at) => getStorageValue(chain, pallet, entry, keys, at),
+    getDecodedCall: (pallet, method, args) => getDecodedCall(pallet, method, args),
+    getDecodedCallFromPayload: (payload) => getDecodedCallFromPayload(chain, payload),
+    getExtrinsicPayload: (pallet, method, args, config) => getSignerPayloadJSON(chain, pallet, method, args, config, chainInfo),
+    getFeeEstimate: (payload) => getFeeEstimate(chain, payload, chainInfo),
+    getRuntimeCallValue: (apiName, method, args) => getRuntimeCallResult(chain, apiName, method, args),
+    getTypeRegistry: (payload) => getTypeRegistry(chain, payload),
+    submit: (payload, signature, txInfo, mode) => submit(chain, payload, signature, txInfo, mode),
+    getCallDocs: (pallet, method) => getCallDocs(chain, pallet, method),
+    getDryRunCall: (from, decodedCall) => getDryRunCall(chain, from, decodedCall),
+    isApiAvailable: (name, method) => isApiAvailable(chain, name, method)
+  };
+};
+
+// src/fetchBestMetadata.ts
+import { toHex as toHex4 } from "@polkadot-api/utils";
+import { u32, Vector } from "scale-ts";
+var MAGIC_NUMBER = 1635018093;
+var MAX_SUPPORTED_METADATA_VERSION = 15;
+var fetchBestMetadata = async (rpcSend, allowLegacyFallback) => {
+  try {
+    const metadataVersions = await rpcSend(
+      "state_call",
+      ["Metadata_metadata_versions", "0x"],
+      true
+    );
+    const availableVersions = Vector(u32).dec(metadataVersions);
+    const bestVersion = Math.max(
+      ...availableVersions.filter((v) => v <= MAX_SUPPORTED_METADATA_VERSION)
+    );
+    const metadata = await rpcSend(
+      "state_call",
+      ["Metadata_metadata_at_version", toHex4(u32.enc(bestVersion))],
+      true
+    );
+    return normalizeMetadata(metadata);
+  } catch (cause) {
+    const message = cause?.message;
+    if (allowLegacyFallback || message?.includes("is not found") || // ex: crust standalone
+    message?.includes("Module doesn't have export Metadata_metadata_versions") || // ex: 3DPass
+    message?.includes("Exported method Metadata_metadata_versions is not found") || // ex: sora-polkadot & sora-standalone
+    message?.includes("Execution, MethodNotFound, Metadata_metadata_versions")) {
+      return await rpcSend("state_getMetadata", [], true);
+    }
+    throw new Error("Failed to fetch metadata", { cause });
+  }
+};
+var normalizeMetadata = (metadata) => {
+  const hexMagicNumber = toHex4(u32.enc(MAGIC_NUMBER)).slice(2);
+  const magicNumberIndex = metadata.indexOf(hexMagicNumber);
+  if (magicNumberIndex === -1) throw new Error("Invalid metadata format: magic number not found");
+  return `0x${metadata.slice(magicNumberIndex)}`;
+};
+export {
+  MAX_SUPPORTED_METADATA_VERSION,
+  fetchBestMetadata,
+  getScaleApi
+};
+//# sourceMappingURL=index.mjs.map