@talismn/sapi 0.1.7 → 2.0.0

package/dist/index.mjs

@@ -1,714 +1,585 @@
-// src/fetchBestMetadata.ts
-import { toHex } 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", toHex(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 = toHex(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
-import { parseMetadataRpc } from "@talismn/scale";
-
-// src/log.ts
+import { getPjsTxHelper, getPjsTxHelper as getPjsTxHelper$1, getTxHelper } from "@polkadot-api/tx-utils";
+import { Binary, Bytes, Enum, Struct, compactNumber, createDecoder, enhanceDecoder, enhanceEncoder, extrinsicFormat, getSs58AddressInfo, u128, u16, u32, u8 } from "@polkadot-api/substrate-bindings";
+import { fromHex, mergeUint8, toHex } from "@polkadot-api/utils";
+import { Vector, u32 as u32$1 } from "scale-ts";
+import { getConstantValueFromMetadata, parseMetadataRpc } from "@talismn/scale";
 import anylogger from "anylogger";
-
-// package.json
-var package_default = {
-  name: "@talismn/sapi",
-  version: "0.1.7",
-  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.1.29",
-    "@polkadot-api/metadata-builders": "0.13.9",
-    "@polkadot-api/substrate-bindings": "0.17.0",
-    "@polkadot-api/utils": "0.2.0",
-    "@polkadot/types": "16.5.6",
-    "@polkadot/types-codec": "16.5.6",
-    "@talismn/scale": "workspace:*",
-    anylogger: "^1.0.11",
-    "polkadot-api": "1.23.3",
-    "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 = 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 {
-    log_default.error("Failed to find call docs", { pallet, method, chain });
-    return null;
-  }
+import { getLookupFn } from "@polkadot-api/metadata-builders";
+import { createV4Tx } from "@polkadot-api/signers-common";
+import { merkleizeMetadata } from "@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: 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 = Vector(u32$1).dec(metadataVersions);
+		const bestVersion = Math.max(...availableVersions.filter((v) => v <= 15));
+		const metadata = await rpcSend("state_call", ["Metadata_metadata_at_version", toHex(u32$1.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 });
+	}
 };
-
-// src/helpers/getConstantValue.ts
-import { getConstantValueFromMetadata } from "@talismn/scale";
-var getConstantValue = (chain, pallet, constant) => {
-  return getConstantValueFromMetadata(
-    {
-      builder: chain.builder,
-      unifiedMetadata: chain.metadata
-    },
-    pallet,
-    constant
-  );
+/**
+* Removes everything before the magic number in the metadata.
+* This ensures Opaque metadata is usable by pjs
+*/
+const normalizeMetadata = (metadata) => {
+	const hexMagicNumber = toHex(u32$1.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/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
-  };
+//#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}`;
 };
-
-// src/helpers/getDecodedCall.ts
-var getDecodedCall = (palletName, methodName, args) => ({
-  type: palletName,
-  value: { type: methodName, value: args }
+const 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);
 });
-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
-  };
+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 fromHex(address);
+	const info = getSs58AddressInfo(address);
+	if (!info.isValid) throw new Error(`Invalid address: ${address}`);
+	return info.publicKey;
 };
-
-// src/helpers/getDecodedCallFromExtrinsic.ts
-import {
-  Bin,
-  compactNumber,
-  createDecoder,
-  enhanceDecoder,
-  extrinsicFormat,
-  Struct,
-  u8
-} from "@polkadot-api/substrate-bindings";
-var allBytesDec = Bin(Infinity).dec;
-var getDecodedCallFromExtrinsic = (chain, extrinsicHex) => {
-  try {
-    const { metadata, builder } = chain;
-    const extensionsArray = metadata.extrinsic.signedExtensions[0] ?? [];
-    const extraDec = 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 = Struct.dec({
-      address: addressDec,
-      signature: signatureDec,
-      extra: extraDec,
-      callData: allBytesDec
-    });
-    const extrinsicDecoder = enhanceDecoder(
-      createDecoder((data) => {
-        const len = compactNumber.dec(data);
-        const { type, version } = extrinsicFormat[1](data);
-        if (type === "bare") {
-          return { len, version, type, callData: allBytesDec(data) };
-        }
-        if (type === "signed") {
-          return { len, version, type, ...v4Body(data) };
-        }
-        const extensionVersion = u8.dec(data);
-        const extra = extraDec(data);
-        return {
-          len,
-          type,
-          version,
-          extensionVersion,
-          extra,
-          callData: allBytesDec(data)
-        };
-      }),
-      (v) => ({
-        ...v,
-        call: callDec(v.callData.asBytes())
-      })
-    );
-    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;
-  }
+//#endregion
+//#region src/log.ts
+var log_default = anylogger("@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;
+	}
 };
-
-// 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);
-  }
+//#endregion
+//#region src/helpers/getConstantValue.ts
+const getConstantValue = (chain, pallet, constant) => {
+	return getConstantValueFromMetadata({
+		builder: chain.builder,
+		unifiedMetadata: chain.metadata
+	}, pallet, constant);
 };
-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"
+//#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")
+	};
 };
-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"
+//#endregion
+//#region src/helpers/getDecodedCall.ts
+const getDecodedCall = (palletName, methodName, args) => ({
+	type: palletName,
+	value: {
+		type: methodName,
+		value: args
+	}
+});
+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
+	};
 };
-var ERRORS_ARITHMETIC = {
-  Overflow: "An underflow would occur",
-  Underflow: "An overflow would occur",
-  DivisionByZero: "Division by zero"
+//#endregion
+//#region src/helpers/getDecodedCallFromExtrinsic.ts
+const allBytesDec = 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 = 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 = Struct.dec({
+			address: addressDec,
+			signature: signatureDec,
+			extra: extraDec,
+			callData: allBytesDec
+		});
+		const decoded = enhanceDecoder(createDecoder((data) => {
+			const len = compactNumber.dec(data);
+			const { type, version } = 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: 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;
+	}
 };
-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,
+//#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);
+	}
 };
-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(": ");
-  }
+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"
 };
-var tryFormatError = (err) => {
-  try {
-    const unsafeErr = err;
-    if (unsafeErr.type && unsafeErr.value?.type)
-      return [unsafeErr.type, unsafeErr.value.type].join(": ");
-  } catch {
-  }
-  return "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 = 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(": ");
+	}
 };
-
-// src/helpers/getRuntimeCallResult.ts
-import { toHex as toHex2 } from "@polkadot-api/utils";
-
-// src/helpers/getSendRequestResult.ts
-var getSendRequestResult = (chain, method, params, isCacheable) => {
-  return chain.connector.send(method, params, isCacheable);
+const 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 getRuntimeCallResult = async (chain, apiName, method, args) => {
-  const call = chain.builder.buildRuntimeCall(apiName, method);
-  const hex = await getSendRequestResult(chain, "state_call", [
-    `${apiName}_${method}`,
-    toHex2(call.args.enc(args))
-  ]);
-  return call.value.dec(hex);
+//#endregion
+//#region src/helpers/getSendRequestResult.ts
+const getSendRequestResult = (chain, method, params, isCacheable) => {
+	return chain.connector.send(method, params, isCacheable);
 };
-
-// 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)
-  );
+//#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}`, toHex(call.args.enc(args))]);
+	return call.value.dec(hex);
 };
-
-// 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
-    };
-  }
+//#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));
 };
-
-// src/helpers/getFeeEstimate.ts
-import { Binary } from "polkadot-api";
-
-// src/helpers/getExtrinsicDispatchInfo.ts
-import { mergeUint8 } from "@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()
-  };
+//#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 = Enum("system", 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
+		};
+	}
 };
-var stateCall = async (request, method, resultType, args, blockHash, isCacheable) => {
-  const registry = args[0].registry;
-  const bytes = registry.createType("Raw", mergeUint8(...args.map((arg) => arg.toU8a())));
-  const result = await request("state_call", [method, bytes.toHex(), blockHash], isCacheable);
-  return registry.createType(resultType, result);
+//#endregion
+//#region src/helpers/getExtrinsicDispatchInfo.ts
+const getExtrinsicDispatchInfo = async (chain, signedTxBytes) => {
+	const args = mergeUint8([signedTxBytes, u32.enc(signedTxBytes.length)]);
+	const bytes = fromHex(await chain.connector.send("state_call", ["TransactionPaymentApi_query_info", toHex(args)], true));
+	if (bytes.length < 16) throw new Error("Invalid RuntimeDispatchInfo");
+	return { partialFee: u128.dec(bytes.slice(bytes.length - 16)).toString() };
 };
-
-// src/helpers/getTypeRegistry.ts
-import { Metadata, TypeRegistry } from "@polkadot/types";
-var getTypeRegistry = (chain, payload) => {
-  log_default.debug(`[sapi] getTypeRegistry for payload (${chain.token.symbol})`);
-  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);
-  return registry;
+//#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);
 };
-
-// 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);
+const getFeeEstimate = async (chain, payload) => {
+	const { callData, extra } = getPjsTxHelper$1(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 = 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);
 };
-
-// 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");
-  }
+//#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
-import { mergeUint8 as mergeUint82, toHex as toHex4 } from "@polkadot-api/utils";
-import { Binary as Binary2 } from "polkadot-api";
-
-// src/helpers/getPayloadWithMetadataHash.ts
-import { merkleizeMetadata } from "@polkadot-api/merkleize-metadata";
-import { toHex as toHex3 } 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 = toHex3(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
-    };
-  }
+//#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 = merkleizeMetadata(chain.hexMetadata, metadataHashInputs);
+		const metadataHash = toHex(merkleizedMetadata.digest());
+		log_default.log("metadataHash", metadataHash, metadataHashInputs);
+		const payloadWithMetadataHash = {
+			...payload,
+			mode: 1,
+			metadataHash,
+			withSignedTransaction: true
+		};
+		const { callData, extra, additionalSigned } = getPjsTxHelper$1(chain.hexMetadata, CUSTOM_SIGNED_EXTENSIONS)(payloadWithMetadataHash);
+		const barePayload = 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
+		};
+	}
 };
-
-// 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);
+//#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);
 };
-
-// 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}`;
+//#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 = 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: Binary.toHex(method),
+		signedExtensions,
+		nonce: toPjsHex(nonce, 4),
+		specVersion: toPjsHex(chainInfo.specVersion, 4),
+		transactionVersion: toPjsHex(chainInfo.transactionVersion, 4),
+		blockNumber: toPjsHex(blockNumber, 4),
+		era: toHex(era),
+		tip: toPjsHex(0, 16),
+		assetId: void 0,
+		version: 4
+	});
+	const shortMetadata = txMetadata ? toHex(txMetadata) : void 0;
+	if (payload.signedExtensions.includes("CheckAppId")) payload.appId = 0;
+	log_default.log("[sapi] payload", {
+		newPayload: payload,
+		txMetadata
+	});
+	return {
+		payload,
+		txMetadata,
+		shortMetadata
+	};
 };
-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(mergeUint82([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[0] ?? []).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: toHex4(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 ? toHex4(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
-  };
+//#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);
 };
-
-// src/helpers/hasEvent.ts
-import { getLookupFn as getLookupFn2 } from "@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 = getLookupFn2(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;
-  }
+//#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 = 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;
+	}
 };
-
-// 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);
-  }
+//#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);
+	}
 };
-
-// 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),
-    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)
-  };
-};
-export {
-  MAX_SUPPORTED_METADATA_VERSION,
-  fetchBestMetadata,
-  getScaleApi
+//#endregion
+//#region src/sapi.ts
+const 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),
+		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
+export { CUSTOM_SIGNED_EXTENSIONS, MAX_SUPPORTED_METADATA_VERSION, fetchBestMetadata, getAddressBytes, getPjsTxHelper, getScaleApi, getTxHelper, isEthereumAddress, mortal, toPjsHex };
+
 //# sourceMappingURL=index.mjs.map