@talismn/sapi 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,743 +1,628 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  MAX_SUPPORTED_METADATA_VERSION: () => MAX_SUPPORTED_METADATA_VERSION,
-  fetchBestMetadata: () => fetchBestMetadata,
-  getScaleApi: () => getScaleApi
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _polkadot_api_tx_utils = require("@polkadot-api/tx-utils");
+let _polkadot_api_substrate_bindings = require("@polkadot-api/substrate-bindings");
+let _polkadot_api_utils = require("@polkadot-api/utils");
+let scale_ts = require("scale-ts");
+let _talismn_scale = require("@talismn/scale");
+let anylogger = require("anylogger");
+anylogger = __toESM(anylogger);
+let _polkadot_api_metadata_builders = require("@polkadot-api/metadata-builders");
+let _polkadot_api_signers_common = require("@polkadot-api/signers-common");
+let _polkadot_api_merkleize_metadata = require("@polkadot-api/merkleize-metadata");
+//#region src/customSignedExtensions.ts
+const EMPTY = /* @__PURE__ */ new Uint8Array();
+/**
+* Encoders for chain-specific signed extensions that `@polkadot-api/tx-utils` doesn't know about.
+*/
+const CUSTOM_SIGNED_EXTENSIONS = { CheckAppId: ({ pjsPayload }) => {
+	const appId = Number(pjsPayload.appId ?? 0);
+	return {
+		value: _polkadot_api_substrate_bindings.compactNumber.enc(Number.isFinite(appId) ? appId : 0),
+		additionalSigned: EMPTY
+	};
+} };
+//#endregion
+//#region src/fetchBestMetadata.ts
+const MAGIC_NUMBER = 1635018093;
+const MAX_SUPPORTED_METADATA_VERSION = 15;
+/**
+* Fetches the highest supported version of metadata from the chain.
+*
+* @param rpcSend
+* @returns hex-encoded metadata starting with the magic number
+*/
+const fetchBestMetadata = async (rpcSend, allowLegacyFallback) => {
+	try {
+		const metadataVersions = await rpcSend("state_call", ["Metadata_metadata_versions", "0x"], true);
+		const availableVersions = (0, scale_ts.Vector)(scale_ts.u32).dec(metadataVersions);
+		const bestVersion = Math.max(...availableVersions.filter((v) => v <= 15));
+		const metadata = await rpcSend("state_call", ["Metadata_metadata_at_version", (0, _polkadot_api_utils.toHex)(scale_ts.u32.enc(bestVersion))], true);
+		return normalizeMetadata(metadata);
+	} catch (cause) {
+		const message = cause?.message;
+		if (allowLegacyFallback || message?.includes("is not found") || message?.includes("Module doesn't have export Metadata_metadata_versions") || message?.includes("Exported method Metadata_metadata_versions is not found") || message?.includes("Execution, MethodNotFound, Metadata_metadata_versions")) return await rpcSend("state_getMetadata", [], true);
+		throw new Error("Failed to fetch metadata", { cause });
+	}
+};
+/**
+* Removes everything before the magic number in the metadata.
+* This ensures Opaque metadata is usable by pjs
+*/
+const normalizeMetadata = (metadata) => {
+	const hexMagicNumber = (0, _polkadot_api_utils.toHex)(scale_ts.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)}`;
+};
+//#endregion
+//#region src/helpers/papi.ts
+const 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}`;
+};
+const mortal = (0, _polkadot_api_substrate_bindings.enhanceEncoder)((0, _polkadot_api_substrate_bindings.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 _polkadot_api_substrate_bindings.u16.enc(left | right);
 });
-module.exports = __toCommonJS(index_exports);
-
-// src/fetchBestMetadata.ts
-var import_utils = require("@polkadot-api/utils");
-var import_scale_ts = require("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 = (0, import_scale_ts.Vector)(import_scale_ts.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", (0, import_utils.toHex)(import_scale_ts.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 = (0, import_utils.toHex)(import_scale_ts.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)}`;
-};
-
-// src/sapi.ts
-var import_scale2 = require("@talismn/scale");
-
-// src/log.ts
-var import_anylogger = __toESM(require("anylogger"));
-
-// package.json
-var package_default = {
-  name: "@talismn/sapi",
-  version: "1.0.0",
-  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",
-    clean: "rm -rf dist .turbo node_modules",
-    build: "tsup --silent",
-    typecheck: "tsc --noEmit"
-  },
-  dependencies: {
-    "@polkadot-api/merkleize-metadata": "1.2.3",
-    "@polkadot-api/metadata-builders": "0.14.3",
-    "@polkadot-api/substrate-bindings": "0.20.3",
-    "@polkadot-api/utils": "0.4.0",
-    "@polkadot/types": "16.5.6",
-    "@polkadot/types-codec": "16.5.6",
-    "@talismn/scale": "workspace:*",
-    anylogger: "^1.0.11",
-    "polkadot-api": "2.1.6",
-    "scale-ts": "^1.6.1"
-  },
-  devDependencies: {
-    "@talismn/tsconfig": "workspace:*",
-    typescript: "^6.0.3"
-  },
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      "@talismn/source": "./src/index.ts",
-      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 = (0, import_anylogger.default)(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 {
-    log_default.error("Failed to find call docs", { pallet, method, chain });
-    return null;
-  }
-};
-
-// src/helpers/getConstantValue.ts
-var import_scale = require("@talismn/scale");
-var getConstantValue = (chain, pallet, constant) => {
-  return (0, import_scale.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 }
+function trailingZeroes(n) {
+	let i = 0;
+	while (!(n & 1)) {
+		i++;
+		n >>= 1;
+	}
+	return i;
+}
+const isEthereumAddress = (address) => /^0x[0-9a-fA-F]{40}$/.test(address);
+/** decodes an ss58 or ethereum address into its raw account bytes */
+const getAddressBytes = (address) => {
+	if (isEthereumAddress(address)) return (0, _polkadot_api_utils.fromHex)(address);
+	const info = (0, _polkadot_api_substrate_bindings.getSs58AddressInfo)(address);
+	if (!info.isValid) throw new Error(`Invalid address: ${address}`);
+	return info.publicKey;
+};
+//#endregion
+//#region src/log.ts
+var log_default = (0, anylogger.default)("@talismn/sapi");
+//#endregion
+//#region src/helpers/getCallDocs.ts
+const 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;
+		return palletCalls.def.value.find((c) => c.name === method)?.docs?.join("\n") ?? null;
+	} catch {
+		log_default.error("Failed to find call docs", {
+			pallet,
+			method,
+			chain
+		});
+		return null;
+	}
+};
+//#endregion
+//#region src/helpers/getConstantValue.ts
+const getConstantValue = (chain, pallet, constant) => {
+	return (0, _talismn_scale.getConstantValueFromMetadata)({
+		builder: chain.builder,
+		unifiedMetadata: chain.metadata
+	}, pallet, constant);
+};
+//#endregion
+//#region src/helpers/getChainInfo.ts
+const getChainInfo = (chain) => {
+	const { spec_name: specName, spec_version: specVersion, transaction_version: transactionVersion } = getConstantValue(chain, "System", "Version");
+	return {
+		specName,
+		specVersion,
+		transactionVersion,
+		base58Prefix: getConstantValue(chain, "System", "SS58Prefix")
+	};
+};
+//#endregion
+//#region src/helpers/getDecodedCall.ts
+const 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/getDecodedCallFromExtrinsic.ts
-var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
-var allBytesDec = (0, import_substrate_bindings.Bytes)(Infinity).dec;
-var getDecodedCallFromExtrinsic = (chain, extrinsicHex) => {
-  try {
-    const { metadata, builder } = chain;
-    const extensionsArray = metadata.extrinsic.signedExtensions[0] ?? [];
-    const extraDec = import_substrate_bindings.Struct.dec(
-      Object.fromEntries(
-        extensionsArray.map((x) => [x.identifier, builder.buildDefinition(x.type)[1]])
-      )
-    );
-    let callDec;
-    const { extrinsic } = metadata;
-    if ("address" in extrinsic) {
-      callDec = builder.buildDefinition(extrinsic.call)[1];
-    } else {
-      const params = metadata.lookup[extrinsic.type]?.params;
-      const callType = params?.find((v) => v.name === "Call")?.type;
-      if (callType == null) throw new Error("Call type not found in metadata");
-      callDec = builder.buildDefinition(callType)[1];
-    }
-    let addressDec;
-    let signatureDec;
-    if ("address" in extrinsic) {
-      addressDec = builder.buildDefinition(extrinsic.address)[1];
-      signatureDec = builder.buildDefinition(extrinsic.signature)[1];
-    } else {
-      const params = metadata.lookup[extrinsic.type]?.params;
-      const addrType = params?.find((v) => v.name === "Address")?.type;
-      const sigType = params?.find((v) => v.name === "Signature")?.type;
-      if (addrType == null || sigType == null)
-        throw new Error("Address or Signature type not found");
-      addressDec = builder.buildDefinition(addrType)[1];
-      signatureDec = builder.buildDefinition(sigType)[1];
-    }
-    const v4Body = import_substrate_bindings.Struct.dec({
-      address: addressDec,
-      signature: signatureDec,
-      extra: extraDec,
-      callData: allBytesDec
-    });
-    const extrinsicDecoder = (0, import_substrate_bindings.enhanceDecoder)(
-      (0, import_substrate_bindings.createDecoder)((data) => {
-        const len = import_substrate_bindings.compactNumber.dec(data);
-        const { type, version } = import_substrate_bindings.extrinsicFormat[1](data);
-        if (type === "bare") {
-          return { len, version, type, callData: allBytesDec(data) };
-        }
-        if (type === "signed") {
-          return { len, version, type, ...v4Body(data) };
-        }
-        const extensionVersion = import_substrate_bindings.u8.dec(data);
-        const extra = extraDec(data);
-        return {
-          len,
-          type,
-          version,
-          extensionVersion,
-          extra,
-          callData: allBytesDec(data)
-        };
-      }),
-      (v) => ({
-        ...v,
-        call: callDec(v.callData)
-      })
-    );
-    const decoded = extrinsicDecoder(extrinsicHex);
-    return {
-      pallet: decoded.call.type,
-      method: decoded.call.value.type,
-      args: decoded.call.value.value
-    };
-  } catch (err) {
-    console.error("[SAPI] Failed to decode extrinsic:", err);
-    return null;
-  }
-};
-
-// src/helpers/getDryRunCall.ts
-var import_polkadot_api = require("polkadot-api");
-
-// src/helpers/errors.ts
-var import_metadata_builders = require("@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 = (0, import_metadata_builders.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 {
-  }
-  return "Unknown error";
-};
-
-// src/helpers/getRuntimeCallResult.ts
-var import_utils2 = require("@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}`,
-    (0, import_utils2.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 = (0, import_polkadot_api.Enum)("system", (0, import_polkadot_api.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/getExtrinsicDispatchInfo.ts
-var import_utils3 = require("@polkadot-api/utils");
-var getExtrinsicDispatchInfo = async (chain, signedExtrinsic) => {
-  if (!signedExtrinsic.isSigned)
-    throw new Error("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", (0, import_utils3.mergeUint8)(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
-var import_types = require("@polkadot/types");
-var getTypeRegistry = (chain, payload) => {
-  log_default.debug(`[sapi] getTypeRegistry for payload (${chain.token.symbol})`);
-  const registry = new import_types.TypeRegistry();
-  if (chain.registryTypes) registry.register(chain.registryTypes);
-  const meta = new import_types.Metadata(registry, chain.hexMetadata);
-  registry.setMetadata(meta, payload.signedExtensions, chain.signedExtensions);
-  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);
-  try {
-    const result = await getRuntimeCallResult(
-      chain,
-      "TransactionPaymentApi",
-      "query_info",
-      [bytes, 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");
-  }
+const getDecodedCallFromPayload = (chain, payload) => {
+	const decoded = chain.builder.buildDefinition(chain.lookup.call).dec(payload.method);
+	return {
+		pallet: decoded.type,
+		method: decoded.value.type,
+		args: decoded.value.value
+	};
+};
+//#endregion
+//#region src/helpers/getDecodedCallFromExtrinsic.ts
+const allBytesDec = (0, _polkadot_api_substrate_bindings.Bytes)(Infinity).dec;
+/**
+* Decodes a signed extrinsic and extracts the call data.
+* Handles different metadata versions (v14, v15, v16) and extrinsic formats.
+*
+* @param chain - The chain context with metadata and builder
+* @param extrinsicHex - The hex-encoded extrinsic (with 0x prefix)
+* @returns The decoded call with pallet, method, and args, or null if decoding fails
+*/
+const getDecodedCallFromExtrinsic = (chain, extrinsicHex) => {
+	try {
+		const { metadata, builder } = chain;
+		const extensionsArray = metadata.extrinsic.signedExtensions[0] ?? [];
+		const extraDec = _polkadot_api_substrate_bindings.Struct.dec(Object.fromEntries(extensionsArray.map((x) => [x.identifier, builder.buildDefinition(x.type)[1]])));
+		let callDec;
+		const { extrinsic } = metadata;
+		if ("address" in extrinsic) callDec = builder.buildDefinition(extrinsic.call)[1];
+		else {
+			const callType = (metadata.lookup[extrinsic.type]?.params)?.find((v) => v.name === "Call")?.type;
+			if (callType == null) throw new Error("Call type not found in metadata");
+			callDec = builder.buildDefinition(callType)[1];
+		}
+		let addressDec;
+		let signatureDec;
+		if ("address" in extrinsic) {
+			addressDec = builder.buildDefinition(extrinsic.address)[1];
+			signatureDec = builder.buildDefinition(extrinsic.signature)[1];
+		} else {
+			const params = metadata.lookup[extrinsic.type]?.params;
+			const addrType = params?.find((v) => v.name === "Address")?.type;
+			const sigType = params?.find((v) => v.name === "Signature")?.type;
+			if (addrType == null || sigType == null) throw new Error("Address or Signature type not found");
+			addressDec = builder.buildDefinition(addrType)[1];
+			signatureDec = builder.buildDefinition(sigType)[1];
+		}
+		const v4Body = _polkadot_api_substrate_bindings.Struct.dec({
+			address: addressDec,
+			signature: signatureDec,
+			extra: extraDec,
+			callData: allBytesDec
+		});
+		const decoded = (0, _polkadot_api_substrate_bindings.enhanceDecoder)((0, _polkadot_api_substrate_bindings.createDecoder)((data) => {
+			const len = _polkadot_api_substrate_bindings.compactNumber.dec(data);
+			const { type, version } = _polkadot_api_substrate_bindings.extrinsicFormat[1](data);
+			if (type === "bare") return {
+				len,
+				version,
+				type,
+				callData: allBytesDec(data)
+			};
+			if (type === "signed") return {
+				len,
+				version,
+				type,
+				...v4Body(data)
+			};
+			return {
+				len,
+				type,
+				version,
+				extensionVersion: _polkadot_api_substrate_bindings.u8.dec(data),
+				extra: extraDec(data),
+				callData: allBytesDec(data)
+			};
+		}), (v) => ({
+			...v,
+			call: callDec(v.callData)
+		}))(extrinsicHex);
+		return {
+			pallet: decoded.call.type,
+			method: decoded.call.value.type,
+			args: decoded.call.value.value
+		};
+	} catch (err) {
+		console.error("[SAPI] Failed to decode extrinsic:", err);
+		return null;
+	}
+};
+//#endregion
+//#region src/helpers/errors.ts
+const 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);
+	}
+};
+const ERROR_METADATA_LOOKUP = "METADATA_LOOKUP";
+const DISPATCH_ERROR = {
+	CannotLookup: "Cannot lookup",
+	BadOrigin: "Bad origin",
+	Module: ERROR_METADATA_LOOKUP,
+	ConsumerRemaining: "Consumer remaining",
+	NoProviders: "No providers",
+	TooManyConsumers: "Too many consumers",
+	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"
+	},
+	Arithmetic: {
+		Overflow: "An underflow would occur",
+		Underflow: "An overflow would occur",
+		DivisionByZero: "Division by zero"
+	},
+	Transactional: {
+		LimitReached: "Too many transactional layers have been spawned",
+		NoLayer: "A transactional layer was expected, but does not exist"
+	},
+	Exhausted: "Resources exhausted",
+	Corruption: "State corrupt",
+	Unavailable: "Resource unavailable",
+	RootNotAllowed: "Root not allowed",
+	Trie: "Unknown error",
+	Other: "Unknown error"
+};
+const 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 palletErrors = (0, _polkadot_api_metadata_builders.getLookupFn)(chain.metadata)(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(": ");
+	}
+};
+const tryFormatError = (err) => {
+	try {
+		const unsafeErr = err;
+		if (unsafeErr.type && unsafeErr.value?.type) return [unsafeErr.type, unsafeErr.value.type].join(": ");
+	} catch {}
+	return "Unknown error";
+};
+//#endregion
+//#region src/helpers/getSendRequestResult.ts
+const getSendRequestResult = (chain, method, params, isCacheable) => {
+	return chain.connector.send(method, params, isCacheable);
+};
+//#endregion
+//#region src/helpers/getRuntimeCallResult.ts
+const getRuntimeCallResult = async (chain, apiName, method, args) => {
+	const call = chain.builder.buildRuntimeCall(apiName, method);
+	const hex = await getSendRequestResult(chain, "state_call", [`${apiName}_${method}`, (0, _polkadot_api_utils.toHex)(call.args.enc(args))]);
+	return call.value.dec(hex);
+};
+//#endregion
+//#region src/helpers/isApiAvailable.ts
+const isApiAvailable = (chain, name, method) => {
+	return chain.metadata.apis.some((a) => a.name === name && a.methods.some((m) => m.name === method));
+};
+//#endregion
+//#region src/helpers/getDryRunCall.ts
+const getDryRunCall = async (chain, from, decodedCall) => {
+	try {
+		if (!isApiAvailable(chain, "DryRunApi", "dry_run_call")) return {
+			available: false,
+			data: null
+		};
+		const origin = (0, _polkadot_api_substrate_bindings.Enum)("system", (0, _polkadot_api_substrate_bindings.Enum)("Signed", from));
+		const { pallet, method, args } = decodedCall;
+		const data = await getRuntimeCallResult(chain, "DryRunApi", "dry_run_call", [origin, {
+			type: pallet,
+			value: {
+				type: method,
+				value: args
+			}
+		}]);
+		return {
+			available: true,
+			data,
+			ok: data.success && data.value.execution_result.success,
+			errorMessage: data.success && !data.value.execution_result.success ? getDispatchErrorMessage(chain, data.value.execution_result.value.error) : null
+		};
+	} catch (err) {
+		log_default.error("Failed to dry run", {
+			chainId: chain.connector.chainId,
+			err
+		});
+		return {
+			available: false,
+			data: null
+		};
+	}
+};
+//#endregion
+//#region src/helpers/getExtrinsicDispatchInfo.ts
+const getExtrinsicDispatchInfo = async (chain, signedTxBytes) => {
+	const args = (0, _polkadot_api_utils.mergeUint8)([signedTxBytes, _polkadot_api_substrate_bindings.u32.enc(signedTxBytes.length)]);
+	const bytes = (0, _polkadot_api_utils.fromHex)(await chain.connector.send("state_call", ["TransactionPaymentApi_query_info", (0, _polkadot_api_utils.toHex)(args)], true));
+	if (bytes.length < 16) throw new Error("Invalid RuntimeDispatchInfo");
+	return { partialFee: _polkadot_api_substrate_bindings.u128.dec(bytes.slice(bytes.length - 16)).toString() };
+};
+//#endregion
+//#region src/helpers/getFeeEstimate.ts
+/** strips the leading compact length prefix from an encoded extrinsic */
+const stripLengthPrefix = (tx) => {
+	const mode = tx[0] & 3;
+	const prefixLen = mode === 0 ? 1 : mode === 1 ? 2 : mode === 2 ? 4 : 1 + (tx[0] >> 2) + 4;
+	return tx.subarray(prefixLen);
+};
+const getFeeEstimate = async (chain, payload) => {
+	const { callData, extra } = (0, _polkadot_api_tx_utils.getPjsTxHelper)(chain.hexMetadata, CUSTOM_SIGNED_EXTENSIONS)(payload);
+	const fakeSignature = isEthereumAddress(payload.address) ? /* @__PURE__ */ new Uint8Array(65) : (/* @__PURE__ */ new Uint8Array(66)).fill(2, 0, 1);
+	const signedTx = (0, _polkadot_api_signers_common.createV4Tx)(chain.metadata, getAddressBytes(payload.address), fakeSignature, [extra], callData);
+	const bytes = stripLengthPrefix(signedTx);
+	try {
+		const result = await getRuntimeCallResult(chain, "TransactionPaymentApi", "query_info", [bytes, 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, signedTx);
+	return BigInt(partialFee);
+};
+//#endregion
+//#region src/helpers/getSapiConnector.ts
+const getSapiConnector = ({ chainId, send, submit, submitWithBittensorMevShield }) => ({
+	chainId,
+	send,
+	submit: (...args) => {
+		if (submit) return submit(...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
-var import_utils5 = require("@polkadot-api/utils");
-var import_polkadot_api2 = require("polkadot-api");
-
-// src/helpers/getPayloadWithMetadataHash.ts
-var import_merkleize_metadata = require("@polkadot-api/merkleize-metadata");
-var import_utils4 = require("@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 = (0, import_merkleize_metadata.merkleizeMetadata)(chain.hexMetadata, metadataHashInputs);
-    const metadataHash = (0, import_utils4.toHex)(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
-var import_substrate_bindings2 = require("@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 = (0, import_substrate_bindings2.enhanceEncoder)((0, import_substrate_bindings2.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 import_substrate_bindings2.u16.enc(left | right);
+//#endregion
+//#region src/helpers/getPayloadWithMetadataHash.ts
+const 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 = (0, _polkadot_api_merkleize_metadata.merkleizeMetadata)(chain.hexMetadata, metadataHashInputs);
+		const metadataHash = (0, _polkadot_api_utils.toHex)(merkleizedMetadata.digest());
+		log_default.log("metadataHash", metadataHash, metadataHashInputs);
+		const payloadWithMetadataHash = {
+			...payload,
+			mode: 1,
+			metadataHash,
+			withSignedTransaction: true
+		};
+		const { callData, extra, additionalSigned } = (0, _polkadot_api_tx_utils.getPjsTxHelper)(chain.hexMetadata, CUSTOM_SIGNED_EXTENSIONS)(payloadWithMetadataHash);
+		const barePayload = (0, _polkadot_api_utils.mergeUint8)([
+			callData,
+			extra,
+			additionalSigned
+		]);
+		return {
+			payload: payloadWithMetadataHash,
+			txMetadata: merkleizedMetadata.getProofForExtrinsicPayload(barePayload)
+		};
+	} catch (err) {
+		log_default.error("Failed to get shortened metadata", { error: err });
+		return {
+			payload,
+			txMetadata: void 0
+		};
+	}
+};
+//#endregion
+//#region src/helpers/getStorageValue.ts
+const getStorageValue = async (chain, pallet, entry, keys, at) => {
+	const storageCodec = chain.builder.buildStorage(pallet, entry);
+	const hexValue = await getSendRequestResult(chain, "state_getStorage", [storageCodec.keys.enc(...keys), at]);
+	if (!hexValue) return null;
+	return storageCodec.value.dec(hexValue);
+};
+//#endregion
+//#region src/helpers/getSignerPayloadJSON.ts
+const ERA_PERIOD = 64;
+const getSignerPayloadJSON = async (chain, palletName, methodName, args, signerConfig, chainInfo) => {
+	const { codec, location } = chain.builder.buildCall(palletName, methodName);
+	const method = (0, _polkadot_api_utils.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;
+		blockHash = await getStorageValue(chain, "System", "BlockHash", [blockNumber]);
+	}
+	const era = mortal({
+		period: ERA_PERIOD,
+		phase: blockNumber % ERA_PERIOD
+	});
+	const signedExtensions = (chain.metadata.extrinsic.signedExtensions[0] ?? []).map((ext) => ext.identifier);
+	const { payload, txMetadata } = getPayloadWithMetadataHash(chain, chainInfo, {
+		address: signerConfig.address,
+		genesisHash,
+		blockHash,
+		method: _polkadot_api_substrate_bindings.Binary.toHex(method),
+		signedExtensions,
+		nonce: toPjsHex(nonce, 4),
+		specVersion: toPjsHex(chainInfo.specVersion, 4),
+		transactionVersion: toPjsHex(chainInfo.transactionVersion, 4),
+		blockNumber: toPjsHex(blockNumber, 4),
+		era: (0, _polkadot_api_utils.toHex)(era),
+		tip: toPjsHex(0, 16),
+		assetId: void 0,
+		version: 4
+	});
+	const shortMetadata = txMetadata ? (0, _polkadot_api_utils.toHex)(txMetadata) : void 0;
+	if (payload.signedExtensions.includes("CheckAppId")) payload.appId = 0;
+	log_default.log("[sapi] payload", {
+		newPayload: payload,
+		txMetadata
+	});
+	return {
+		payload,
+		txMetadata,
+		shortMetadata
+	};
+};
+//#endregion
+//#region src/helpers/hasConstant.ts
+const hasConstant = (chain, pallet, constant) => {
+	return !!chain.metadata.pallets.find((p) => p.name === pallet)?.constants.some((c) => c.name === constant);
+};
+//#endregion
+//#region src/helpers/hasEvent.ts
+const hasEvent = (chain, pallet, event) => {
+	try {
+		const palletDef = chain.metadata.pallets.find((p) => p.name === pallet);
+		if (typeof palletDef?.events !== "number") return false;
+		const palletEvents = (0, _polkadot_api_metadata_builders.getLookupFn)(chain.metadata)(palletDef.events);
+		return palletEvents.type === "enum" && event in palletEvents.innerDocs;
+	} catch (err) {
+		log_default.error("Failed to check event existence", {
+			pallet,
+			event,
+			err
+		});
+		return false;
+	}
+};
+//#endregion
+//#region src/helpers/submit.ts
+const 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);
+	}
+};
+//#endregion
+//#region src/sapi.ts
+const getScaleApi = (connector, hexMetadata, token, hasCheckMetadataHash, signedExtensions, registryTypes) => {
+	const { unifiedMetadata: metadata, lookupFn: lookup, builder } = (0, _talismn_scale.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),
+		getDecodedCallFromExtrinsic: (extrinsicHex) => getDecodedCallFromExtrinsic(chain, extrinsicHex),
+		getExtrinsicPayload: (pallet, method, args, config) => getSignerPayloadJSON(chain, pallet, method, args, config, chainInfo),
+		getFeeEstimate: (payload) => getFeeEstimate(chain, payload),
+		getRuntimeCallValue: (apiName, method, args) => getRuntimeCallResult(chain, apiName, method, args),
+		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),
+		hasEvent: (pallet, event) => hasEvent(chain, pallet, event),
+		hasConstant: (pallet, constant) => hasConstant(chain, pallet, constant)
+	};
+};
+//#endregion
+exports.CUSTOM_SIGNED_EXTENSIONS = CUSTOM_SIGNED_EXTENSIONS;
+exports.MAX_SUPPORTED_METADATA_VERSION = MAX_SUPPORTED_METADATA_VERSION;
+exports.fetchBestMetadata = fetchBestMetadata;
+exports.getAddressBytes = getAddressBytes;
+Object.defineProperty(exports, "getPjsTxHelper", {
+	enumerable: true,
+	get: function() {
+		return _polkadot_api_tx_utils.getPjsTxHelper;
+	}
 });
-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 = (0, import_utils5.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;
-  }
-  const era = mortal({ period: ERA_PERIOD, phase: blockNumber % ERA_PERIOD });
-  const signedExtensions = (chain.metadata.extrinsic.signedExtensions[0] ?? []).map(
-    (ext) => ext.identifier
-  );
-  const basePayload = {
-    address: signerConfig.address,
-    genesisHash,
-    blockHash,
-    method: import_polkadot_api2.Binary.toHex(method),
-    signedExtensions,
-    nonce: toPjsHex(nonce, 4),
-    specVersion: toPjsHex(chainInfo.specVersion, 4),
-    transactionVersion: toPjsHex(chainInfo.transactionVersion, 4),
-    blockNumber: toPjsHex(blockNumber, 4),
-    era: (0, import_utils5.toHex)(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 ? (0, import_utils5.toHex)(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/hasEvent.ts
-var import_metadata_builders2 = require("@polkadot-api/metadata-builders");
-var hasEvent = (chain, pallet, event) => {
-  try {
-    const palletDef = chain.metadata.pallets.find((p) => p.name === pallet);
-    if (typeof palletDef?.events !== "number") return false;
-    const lookup = (0, import_metadata_builders2.getLookupFn)(chain.metadata);
-    const palletEvents = lookup(palletDef.events);
-    return palletEvents.type === "enum" && event in palletEvents.innerDocs;
-  } catch (err) {
-    log_default.error("Failed to check event existence", { pallet, event, err });
-    return false;
-  }
-};
-
-// 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 } = (0, import_scale2.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),
-    getDecodedCallFromExtrinsic: (extrinsicHex) => getDecodedCallFromExtrinsic(chain, extrinsicHex),
-    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),
-    hasEvent: (pallet, event) => hasEvent(chain, pallet, event)
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MAX_SUPPORTED_METADATA_VERSION,
-  fetchBestMetadata,
-  getScaleApi
+exports.getScaleApi = getScaleApi;
+Object.defineProperty(exports, "getTxHelper", {
+	enumerable: true,
+	get: function() {
+		return _polkadot_api_tx_utils.getTxHelper;
+	}
 });
+exports.isEthereumAddress = isEthereumAddress;
+exports.mortal = mortal;
+exports.toPjsHex = toPjsHex;
+
 //# sourceMappingURL=index.js.map