@parity/product-lab 0.0.1-placeholder → 0.1.0

package/adapters/chain/papi/src/extrinsic-decoder.js

@@ -0,0 +1,396 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { AccountId, compactNumber, Tuple, u8 } from "@polkadot-api/substrate-bindings";
+import { plainValue } from "./plain-value.js";
+export const UNSIGNED_ORIGIN_GAP = "Unsigned call has no proven chain origin";
+export const GENERAL_UNREAD_ORIGIN_GAP = "General extrinsic has no enabled standard authorization (VerifyMultiSignature); its origin comes from an extension the lab does not read";
+export const AUTHORIZED_CALL_ORIGIN_GAP = "General extrinsic authorized by its own call (AuthorizeCall): no account origin";
+const AUTHORIZE_CALL = "frame_system::extensions::authorize_call::AuthorizeCall";
+const AS_RESOURCES = "AsResources";
+const MAX_EXTRINSIC_BYTES = 16 * 1024 * 1024;
+const MAX_SCALE_ITEMS = 1_000_000;
+class UnsupportedScaleLayout extends Error {
+}
+const HEX = /^0x(?:[0-9a-fA-F]{2})+$/;
+const same = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+function variant(value) {
+    if (value && typeof value === "object" && "type" in value && typeof value.type === "string")
+        return value;
+    return undefined;
+}
+function oneAccountArgument(value) {
+    const plain = plainValue(value);
+    if (!plain || typeof plain !== "object" || Array.isArray(plain))
+        return undefined;
+    const accounts = [];
+    for (const field of Object.values(plain)) {
+        if (typeof field !== "string")
+            continue;
+        if (/^0x[0-9a-fA-F]{64}$/.test(field))
+            accounts.push(field.toLowerCase());
+        else
+            try {
+                accounts.push(`0x${Buffer.from(AccountId().enc(field)).toString("hex")}`);
+            }
+            catch {  }
+    }
+    return accounts.length === 1 ? accounts[0] : undefined;
+}
+function ringOf(value) {
+    const plain = plainValue(value);
+    const [index, revision] = Array.isArray(plain) ? [plain[1], plain[2]] : [plain?.ring_index, plain?.revision];
+    return typeof index === "number" && typeof revision === "number" ? { index, revision } : undefined;
+}
+function signatureOf(value) {
+    const plain = plainValue(value);
+    if (typeof plain === "string" && HEX.test(plain))
+        return plain.toLowerCase();
+    const tagged = variant(plain);
+    if (tagged && ["Ed25519", "Sr25519", "Ecdsa"].includes(tagged.type))
+        return signatureOf(tagged.value);
+    return undefined;
+}
+function addressOf(value) {
+    const plain = plainValue(value);
+    if (typeof plain === "string")
+        return { signer: plain };
+    const tagged = variant(plain);
+    if (!tagged)
+        return { gap: "Runtime address form cannot identify an account" };
+    if (tagged.type === "Id" && typeof tagged.value === "string")
+        return { signer: tagged.value };
+    const encoded = typeof tagged.value === "string" ? tagged.value : JSON.stringify(tagged.value);
+    return {
+        signer: `${tagged.type}:${encoded}`,
+        gap: `${tagged.type} address requires runtime lookup to identify the signer`,
+    };
+}
+function byteArray(types, id, length) {
+    const entry = types.get(id);
+    if (entry?.def.tag !== "array" || entry.def.value.len !== length)
+        return false;
+    const byte = types.get(entry.def.value.type);
+    return byte?.def.tag === "primitive" && byte.def.value.tag === "u8";
+}
+function accountType(types, id) {
+    const entry = types.get(id);
+    return entry?.path.join("::") === "sp_core::crypto::AccountId32" && entry.def.tag === "composite" && entry.def.value.length === 1 &&
+        entry.def.value[0].name === undefined && byteArray(types, entry.def.value[0].type, 32);
+}
+function accountAddress(types, id, value) {
+    if (accountType(types, id))
+        return true;
+    const entry = types.get(id);
+    if (entry?.path.join("::") !== "sp_runtime::multiaddress::MultiAddress" || entry.def.tag !== "variant" || variant(plainValue(value))?.type !== "Id")
+        return false;
+    const variants = entry.def.value;
+    if (new Set(variants.map((item) => item.name)).size !== variants.length || new Set(variants.map((item) => item.index)).size !== variants.length)
+        return false;
+    const identity = variants.find((item) => item.name === "Id" && item.index === 0);
+    return identity?.fields.length === 1 && identity.fields[0].name === undefined && accountType(types, identity.fields[0].type);
+}
+function standardAuthorization(types, identifier, id) {
+    const entry = types.get(id);
+    if (identifier !== "VerifyMultiSignature" || entry?.path.join("::") !== "pallet_verify_signature::extension::VerifySignature" || entry.def.tag !== "variant")
+        return false;
+    const variants = entry.def.value;
+    const disabled = variants.find((item) => item.name === "Disabled" && item.index === 0);
+    const signed = variants.find((item) => item.name === "Signed" && item.index === 1);
+    if (variants.length !== 2 || disabled?.fields.length !== 0 || signed?.fields.length !== 2)
+        return false;
+    const [signature, account] = signed.fields;
+    if (signature.name !== "signature" || account.name !== "account" || !accountType(types, account.type))
+        return false;
+    const signatureEntry = types.get(signature.type);
+    if (signatureEntry?.path.join("::") !== "sp_runtime::MultiSignature" || signatureEntry.def.tag !== "variant")
+        return false;
+    const signatureVariants = signatureEntry.def.value;
+    if (new Set(signatureVariants.map((item) => item.index)).size !== signatureVariants.length || new Set(signatureVariants.map((item) => item.name)).size !== signatureVariants.length)
+        return false;
+    return [["Ed25519", 0, 64], ["Sr25519", 1, 64], ["Ecdsa", 2, 65]].every(([name, index, length]) => {
+        const item = signatureVariants.find((item) => item.name === name && item.index === index);
+        return item?.fields.length === 1 && item.fields[0].name === undefined && byteArray(types, item.fields[0].type, length);
+    });
+}
+function optional(types, id, depth = 0) {
+    const entry = types.get(id);
+    if (!entry || depth > 8)
+        return false;
+    if (entry.path.join("::") === "Option")
+        return true;
+    return entry.def.tag === "composite" && entry.def.value.length === 1 && entry.def.value[0].name === undefined && optional(types, entry.def.value[0].type, depth + 1);
+}
+function scaleBounds(bytes, types) {
+    let budget = Math.min(MAX_SCALE_ITEMS, bytes.length * 8 + 1024);
+    return (id, offset) => {
+        let cursor = offset;
+        const skip = (length) => {
+            if (!Number.isSafeInteger(length) || length < 0 || cursor + length > bytes.length)
+                throw new Error("Truncated SCALE field");
+            cursor += length;
+        };
+        const compact = () => {
+            const start = cursor;
+            skip(1);
+            const first = bytes[start];
+            const mode = first & 3;
+            if (mode === 0)
+                return BigInt(first >> 2);
+            const length = mode === 1 ? 2 : mode === 2 ? 4 : (first >> 2) + 4;
+            skip(length - (mode === 3 ? 0 : 1));
+            let value = 0n;
+            for (let index = cursor - 1; index >= start + (mode === 3 ? 1 : 0); index--)
+                value = (value << 8n) | BigInt(bytes[index]);
+            if (mode !== 3)
+                value >>= 2n;
+            if (value < (mode === 1 ? 64n : mode === 2 ? 16384n : 1n << 30n) || (mode === 3 && bytes[cursor - 1] === 0))
+                throw new Error("Noncanonical SCALE compact");
+            return value;
+        };
+        const count = (value) => {
+            if (value > BigInt(budget))
+                throw new Error("SCALE collection exceeds decoding budget");
+            return Number(value);
+        };
+        const walk = (type, depth) => {
+            if (--budget < 0 || depth > 128)
+                throw new Error("SCALE type exceeds decoding budget");
+            const def = types.get(type)?.def;
+            if (!def)
+                throw new Error("SCALE type unavailable");
+            switch (def.tag) {
+                case "primitive": {
+                    const tag = def.value.tag;
+                    if (tag === "str") {
+                        skip(Number(compact()));
+                        return;
+                    }
+                    if (tag === "char") {
+                        skip(4);
+                        throw new UnsupportedScaleLayout("SCALE char is unsupported by the runtime codec");
+                    }
+                    skip(tag === "bool" ? 1 : Number(tag.slice(1)) / 8);
+                    return;
+                }
+                case "compact":
+                    compact();
+                    return;
+                case "composite":
+                    for (const field of def.value)
+                        walk(field.type, depth + 1);
+                    return;
+                case "tuple":
+                    for (const field of def.value)
+                        walk(field, depth + 1);
+                    return;
+                case "variant": {
+                    const index = bytes[cursor];
+                    skip(1);
+                    const matches = def.value.filter((item) => item.index === index);
+                    if (matches.length !== 1)
+                        throw new Error("SCALE variant unavailable or ambiguous");
+                    for (const field of matches[0].fields)
+                        walk(field.type, depth + 1);
+                    return;
+                }
+                case "array":
+                case "sequence": {
+                    const length = def.tag === "array" ? count(BigInt(def.value.len)) : count(compact());
+                    const inner = def.tag === "array" ? def.value.type : def.value;
+                    const primitive = types.get(inner)?.def;
+                    if (primitive?.tag === "primitive" && primitive.value.tag === "u8") {
+                        skip(length);
+                        return;
+                    }
+                    for (let index = 0; index < length; index++)
+                        walk(inner, depth + 1);
+                    return;
+                }
+                case "bitSequence": {
+                    const store = types.get(def.value.bitStoreType)?.def;
+                    if (store?.tag !== "primitive" || !["u8", "u16", "u32", "u64"].includes(store.value.tag))
+                        throw new UnsupportedScaleLayout("SCALE bit sequence has an unsupported store type");
+                    const width = Number(store.value.tag.slice(1));
+                    skip(Math.ceil(count(compact()) / width) * width / 8);
+                    if (width !== 8)
+                        throw new UnsupportedScaleLayout("SCALE bit sequence store widths above u8 are unsupported by the runtime codec");
+                    return;
+                }
+            }
+        };
+        walk(id, 0);
+        return cursor;
+    };
+}
+export const METADATA_UNAVAILABLE_GAP = "Runtime metadata unavailable for extrinsic decoding";
+export function extrinsicDetails(bytes) {
+    return decode(bytes);
+}
+export function createExtrinsicDecoder(lookup, builder) {
+    let canonicalRegistry = true;
+    for (let index = 0; index < lookup.metadata.lookup.length; index++) {
+        if (lookup.metadata.lookup[index]?.id !== index) {
+            canonicalRegistry = false;
+            break;
+        }
+    }
+    const types = canonicalRegistry ? new Map(lookup.metadata.lookup.map((entry) => [entry.id, entry])) : undefined;
+    return (bytes, options) => decode(bytes, { lookup, builder, types }, options?.includeCallArguments);
+}
+function decode(bytes, context, includeCallArguments = false) {
+    const details = {};
+    const account = {};
+    let resource;
+    let claimed = false;
+    const gaps = [];
+    let offset = 0;
+    let stage = "length prefix";
+    let framed = false;
+    const read = (codec) => {
+        const remaining = bytes.slice(offset);
+        const guarded = new Uint8Array(remaining.length + 1);
+        guarded.set(remaining);
+        const [value] = Tuple(codec, u8).dec(guarded);
+        const encoded = codec.enc(value);
+        if (encoded.length > remaining.length || !same(encoded, remaining.slice(0, encoded.length)))
+            throw new Error("Malformed SCALE field");
+        offset += encoded.length;
+        return value;
+    };
+    try {
+        if (bytes.length > MAX_EXTRINSIC_BYTES)
+            throw new Error("Extrinsic exceeds decoding budget");
+        const length = Number(read(compactNumber));
+        if (length !== bytes.length - offset || length === 0)
+            throw new Error("Extrinsic length mismatch");
+        const format = bytes[offset++];
+        details.version = format & 0x3f;
+        const kind = format >> 6;
+        framed = true;
+        if (!(details.version === 4 && (kind === 0 || kind === 2)) && !(details.version === 5 && (kind === 0 || kind === 1))) {
+            return { ...details, decoded: "unknown", gap: `Unsupported extrinsic format ${format}` };
+        }
+        if (!context)
+            return { ...details, decoded: "partial", gap: METADATA_UNAVAILABLE_GAP };
+        if (!context.types)
+            return { ...details, decoded: "partial", gap: "Runtime type registry IDs do not match the metadata builder indexes" };
+        const { lookup, builder, types: entries } = context;
+        const checkBounds = scaleBounds(bytes, entries);
+        const readType = (type) => {
+            const end = checkBounds(type, offset);
+            const value = read(builder.buildDefinition(type));
+            if (offset !== end)
+                throw new UnsupportedScaleLayout("SCALE runtime codec disagrees with the metadata field layout");
+            return value;
+        };
+        const { metadata } = lookup;
+        const legacyBareV5 = kind === 0 && details.version === 5 && metadata.version < 16 && metadata.extrinsic.version.length === 1 && metadata.extrinsic.version[0] === 4;
+        if (!metadata.extrinsic.version.includes(details.version) && !legacyBareV5)
+            return { ...details, decoded: "partial", gap: `Runtime metadata does not declare extrinsic version ${details.version}` };
+        stage = "runtime type definitions";
+        const extrinsic = metadata.extrinsic;
+        const types = "address" in extrinsic ? extrinsic : (() => {
+            if (!("type" in extrinsic))
+                throw new Error("Extrinsic types unavailable");
+            const entry = metadata.lookup.find((item) => item.id === extrinsic.type);
+            const param = (name) => entry?.params.find((item) => item.name === name)?.type;
+            return { address: param("Address"), signature: param("Signature") };
+        })();
+        let extensionVersion = 0;
+        if (kind === 2) {
+            stage = "address";
+            if (types.address === undefined)
+                throw new Error("Address type unavailable");
+            const value = readType(types.address);
+            const address = addressOf(value);
+            const identity = accountAddress(entries, types.address, value);
+            if (address.signer !== undefined && (identity || address.gap))
+                account.signer = address.signer;
+            if (address.gap)
+                gaps.push(address.gap);
+            else if (!identity)
+                gaps.push("Runtime address type has no recognized account identity schema");
+            stage = "signature";
+            if (types.signature === undefined)
+                throw new Error("Signature type unavailable");
+            account.signature = signatureOf(readType(types.signature));
+            if (!account.signature)
+                gaps.push("Runtime signature form cannot be compared with host signature bytes");
+            if (identity && !address.gap && account.signer && account.signature)
+                account.accountEvidence = "signed-preamble";
+        }
+        else if (kind === 1) {
+            stage = "extension version";
+            if (offset >= bytes.length)
+                throw new Error("Extension version unavailable");
+            extensionVersion = bytes[offset++];
+        }
+        if (kind !== 0) {
+            stage = "transaction extensions";
+            const extensions = metadata.extrinsic.extensionsByVersion[extensionVersion];
+            if (!extensions)
+                throw new Error("Extension types unavailable");
+            const claims = [];
+            let enabledAuthorizations = 0;
+            const filled = [];
+            for (const extension of extensions) {
+                const value = readType(extension.type);
+                if (kind === 1 && optional(entries, extension.type) && plainValue(value) !== undefined)
+                    filled.push(extension.identifier);
+                if (kind === 1 && extension.identifier === AS_RESOURCES) {
+                    const claim = variant(plainValue(value));
+                    if (claim)
+                        resource = { claim: claim.type, ...(ringOf(claim.value) ? { ring: ringOf(claim.value) } : {}) };
+                }
+                if (kind !== 1 || !standardAuthorization(entries, extension.identifier, extension.type))
+                    continue;
+                const tagged = variant(plainValue(value));
+                if (tagged?.type !== "Signed" || !tagged.value || typeof tagged.value !== "object")
+                    continue;
+                enabledAuthorizations++;
+                const signed = tagged.value;
+                const signature = signatureOf(signed.signature);
+                if (typeof signed.account === "string" && signature)
+                    claims.push({ signer: signed.account, signature, accountEvidence: "standard-extension" });
+            }
+            if (enabledAuthorizations === 1 && claims.length === 1)
+                Object.assign(account, claims[0]);
+            else if (enabledAuthorizations > 1)
+                gaps.push("Multiple standard authorization extensions cannot identify one claimed account");
+            else if (enabledAuthorizations === 1)
+                gaps.push("The standard authorization extension's account or signature cannot be read");
+            else if (kind === 1 && resource && filled.length === 1 && filled[0] === AS_RESOURCES)
+                claimed = true;
+            else if (kind === 1 && filled.length)
+                gaps.push(`General extrinsic authorized by ${filled.join(", ")}, which the lab does not read`);
+            else if (kind === 1 && extensions.some((extension) => entries.get(extension.type)?.path.join("::") === AUTHORIZE_CALL))
+                gaps.push(AUTHORIZED_CALL_ORIGIN_GAP);
+            else if (kind === 1)
+                gaps.push(GENERAL_UNREAD_ORIGIN_GAP);
+        }
+        stage = "call";
+        if (lookup.call === null)
+            throw new Error("Call type unavailable");
+        const outer = variant(readType(lookup.call));
+        const inner = variant(outer?.value);
+        if (!outer || !inner)
+            throw new Error("Call names unavailable");
+        details.call = { pallet: outer.type, name: inner.type };
+        stage = "trailing bytes";
+        if (offset !== bytes.length)
+            throw new Error("Extrinsic has trailing bytes");
+        if (includeCallArguments)
+            details.callArguments = plainValue(inner.value) ?? null;
+        if (kind === 0)
+            gaps.push(UNSIGNED_ORIGIN_GAP);
+        const beneficiary = resource && claimed ? oneAccountArgument(inner.value) : undefined;
+        const resourceClaim = resource && claimed ? { extension: AS_RESOURCES, claim: resource.claim, ...(beneficiary ? { beneficiary } : {}), ...(resource.ring ? { ring: resource.ring } : {}) } : undefined;
+        return { ...details, ...account, ...(resourceClaim ? { resourceClaim } : {}), decoded: gaps.length ? "partial" : "complete", ...(gaps.length ? { gap: gaps.join("; ") } : {}) };
+    }
+    catch (error) {
+        if (error instanceof UnsupportedScaleLayout)
+            gaps.push(error.message);
+        gaps.push(`Cannot decode extrinsic ${stage} from runtime metadata`);
+        return { ...details, decoded: framed ? "partial" : "unknown", gap: gaps.join("; ") };
+    }
+}

package/adapters/chain/papi/src/extrinsic-signer.d.ts

@@ -0,0 +1,2 @@
+/** An account as its 32-byte id, from an SS58 address or a 0x public key; undefined when it is neither. */
+export declare function accountKey(account: string): Uint8Array | undefined;

package/adapters/chain/papi/src/extrinsic-signer.js

@@ -0,0 +1,14 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { AccountId } from "polkadot-api";
+const PUBLIC_KEY = /^0x[0-9a-fA-F]{64}$/;
+export function accountKey(account) {
+    try {
+        if (PUBLIC_KEY.test(account))
+            return Uint8Array.from(account.slice(2).match(/../g), (pair) => parseInt(pair, 16));
+        return AccountId().enc(account);
+    }
+    catch {
+        return undefined;
+    }
+}

package/adapters/chain/papi/src/index.d.ts

@@ -0,0 +1,5 @@
+export { PapiChainAccess, type ChainApiFactory, type PapiChainAccessOptions, type PublicEndpoint, type UnsafeChainApi, } from "./chain-access.js";
+export { PapiTransactionSubmitter, decodeCompact, eraBounds, withSignedExtensions, type PapiTransaction, type PapiTransactionSubmitterOptions, type SignedExtensions, } from "./transaction-submitter.js";
+export { toTxCreator, type AccountTxCreator, type PolkadotSigner2 } from "./signer.js";
+export { trackTransaction, type InclusionMove, type TrackedInclusion, type TransactionEvents } from "./track-transaction.js";
+export { readStatement, RpcStatementStoreReader } from "./statement-store-reader.js";

package/adapters/chain/papi/src/index.js

@@ -0,0 +1,7 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+export { PapiChainAccess, } from "./chain-access.js";
+export { PapiTransactionSubmitter, decodeCompact, eraBounds, withSignedExtensions, } from "./transaction-submitter.js";
+export { toTxCreator } from "./signer.js";
+export { trackTransaction } from "./track-transaction.js";
+export { readStatement, RpcStatementStoreReader } from "./statement-store-reader.js";

package/adapters/chain/papi/src/plain-value.d.ts

@@ -0,0 +1,7 @@
+/** `value` with nothing JSON cannot hold; nesting deeper than 12 levels is cut to "…". */
+export declare function plainValue(value: unknown, depth?: number): unknown;
+/** Which of `accounts` (as given) the decoded value mentions anywhere. */
+export declare function mentionedAccounts(value: unknown, accounts: readonly {
+    account: string;
+    key: Uint8Array;
+}[]): string[];

package/adapters/chain/papi/src/plain-value.js

@@ -0,0 +1,58 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { accountKey } from "./extrinsic-signer.js";
+const hex = (bytes) => `0x${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+function isBinary(value) {
+    return typeof value.asBytes === "function";
+}
+export function plainValue(value, depth = 0) {
+    if (depth > 12)
+        return "…";
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value === null || typeof value !== "object")
+        return typeof value === "function" || typeof value === "symbol" ? undefined : value;
+    if (value instanceof Uint8Array)
+        return hex(value);
+    if (isBinary(value))
+        return hex(value.asBytes());
+    if (Array.isArray(value))
+        return value.map((item) => plainValue(item, depth + 1) ?? null);
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        const plain = plainValue(item, depth + 1);
+        if (plain !== undefined)
+            out[key] = plain;
+    }
+    return out;
+}
+const same = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+const ADDRESS = /^(0x[0-9a-fA-F]{64}|[1-9A-HJ-NP-Za-km-z]{40,60})$/;
+export function mentionedAccounts(value, accounts) {
+    if (!accounts.length)
+        return [];
+    const found = new Set();
+    const visit = (item, depth) => {
+        if (depth > 12 || item === null || item === undefined)
+            return;
+        let key;
+        if (typeof item === "string")
+            key = ADDRESS.test(item) ? accountKey(item) : undefined;
+        else if (item instanceof Uint8Array)
+            key = item.length === 32 ? item : undefined;
+        else if (typeof item === "object" && isBinary(item))
+            key = item.asBytes().length === 32 ? item.asBytes() : undefined;
+        else if (Array.isArray(item))
+            for (const child of item)
+                visit(child, depth + 1);
+        else if (typeof item === "object")
+            for (const child of Object.values(item))
+                visit(child, depth + 1);
+        if (key)
+            for (const account of accounts)
+                if (same(account.key, key))
+                    found.add(account.account);
+    };
+    visit(value, 0);
+    return accounts.map((item) => item.account).filter((account) => found.has(account));
+}

package/adapters/chain/papi/src/signer.d.ts

@@ -0,0 +1,27 @@
+import { type CommonSignerTxCreator } from "@polkadot-api/signers-common";
+import type { Signer } from "@parity/product-lab/ports/chain";
+/**
+ * A polkadot-api 2.x signer (`PolkadotSigner` of `@polkadot-api/polkadot-signer`): what a product SDK built on
+ * polkadot-api 2.x hands out, for example a host identity's signer reached through an app page. polkadot-api 2.x
+ * computed every signed extension and handed them to `signTx`; 3.x asks the signer for the whole transaction.
+ */
+export interface PolkadotSigner2 {
+    readonly publicKey: Uint8Array;
+    signTx(callData: Uint8Array, signedExtensions: Record<string, {
+        identifier: string;
+        value: Uint8Array;
+        additionalSigned: Uint8Array;
+    }>, metadata: Uint8Array, atBlockNumber: number, hasher?: (data: Uint8Array) => Uint8Array): Promise<Uint8Array>;
+    signBytes(data: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * The signer of a polkadot-api 3.x transaction, with the account it signs for and the options of polkadot-api's
+ * common extensions (`nonce`, `mortality`, `tip`): what `getTxCreator` returns.
+ */
+export type AccountTxCreator = CommonSignerTxCreator;
+/**
+ * The polkadot-api 3.x signer for a port signer: a KeySigner (derived key) through `getTxCreator`; a polkadot-api
+ * 3.x creator as it is; a polkadot-api 2.x signer (for example one a host supplies through a 2.x SDK) through a
+ * bridge that hands it the extensions polkadot-api computed.
+ */
+export declare function toTxCreator(signer: Signer): AccountTxCreator;

package/adapters/chain/papi/src/signer.js

@@ -0,0 +1,51 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { getFakeTxCreator, getTxCreator } from "polkadot-api/tx-creator";
+import { withCommonExtensions, withNonce } from "@polkadot-api/signers-common";
+import { decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
+const SCHEMES = {
+    sr25519: "Sr25519",
+    ed25519: "Ed25519",
+    ecdsa: "Ecdsa",
+};
+const bytes = (hex) => Uint8Array.from(Buffer.from(hex.replace(/^0x/, ""), "hex"));
+const hex = (value) => `0x${Buffer.from(value).toString("hex")}`;
+const isTxCreator = (signer) => typeof signer === "function";
+const isPolkadotSigner2 = (signer) => typeof signer.signTx === "function" &&
+    typeof signer.signBytes === "function";
+const isKeySigner = (signer) => typeof signer.sign === "function" && signer.scheme !== undefined;
+function inRuntimeOrder(payload) {
+    const version = payload.txExtVersion ?? 0;
+    if (version !== 0)
+        throw new Error(`Legacy signer cannot select transaction extension version ${version}; only version 0 is supported`);
+    const declared = unifyMetadata(decAnyMetadata(payload.context.metadata)).extrinsic.extensionsByVersion[version];
+    if (!declared)
+        throw new Error(`Runtime declares no transaction extension version ${version}`);
+    return declared.flatMap(({ identifier }) => {
+        const extension = payload.extensions.find(({ id }) => id === identifier);
+        return extension ? [extension] : [];
+    });
+}
+function fromPolkadotSigner2(signer) {
+    const fake = getFakeTxCreator(signer.publicKey);
+    const creator = async (payload, opts, bindings, mocked) => {
+        if (mocked)
+            return fake(payload, opts, bindings, mocked);
+        const extensions = Object.fromEntries(inRuntimeOrder(payload).map(({ id, extra, additionalSigned }) => [id, { identifier: id, value: bytes(extra), additionalSigned: bytes(additionalSigned) }]));
+        const at = opts.mortality?.at?.number ?? payload.context.bestBlockHeight;
+        return hex(await signer.signTx(bytes(payload.callData), extensions, bytes(payload.context.metadata), at));
+    };
+    return Object.assign(withNonce(signer.publicKey)(withCommonExtensions(creator)), {
+        publicKey: signer.publicKey,
+        signBytes: (data) => signer.signBytes(data),
+    });
+}
+export function toTxCreator(signer) {
+    if (isTxCreator(signer))
+        return signer;
+    if (isKeySigner(signer))
+        return getTxCreator(signer.publicKey, SCHEMES[signer.scheme], (payload) => signer.sign(payload));
+    if (isPolkadotSigner2(signer))
+        return fromPolkadotSigner2(signer);
+    throw new Error("Signer cannot sign: expected a KeySigner, a polkadot-api TxCreator or a polkadot-api 2.x signer");
+}

package/adapters/chain/papi/src/statement-store-reader.d.ts

@@ -0,0 +1,12 @@
+import type { ReadStatement, StatementAllowanceRead, StatementQuery, StatementStoreReader } from "@parity/product-lab/ports/chain";
+/** A statement's proof checked against its fields (undefined: no proof, or a kind not checked here). */
+export declare function readStatement(encoded: Uint8Array): ReadStatement;
+/** The Statement Store of one node (its WebSocket RPC endpoint). */
+export declare class RpcStatementStoreReader implements StatementStoreReader {
+    private readonly ws;
+    constructor(ws: string);
+    allowanceAt(account: string, at: "best" | "finalized"): Promise<StatementAllowanceRead>;
+    /** Requests over one connection, one after another. */
+    private requests;
+    statements(query: StatementQuery): Promise<readonly ReadStatement[]>;
+}