@aigne/afs-ocap 1.12.0-beta.5

package/dist/utils.cjs

@@ -0,0 +1,581 @@
+let _aigne_afs = require("@aigne/afs");
+let ufo = require("ufo");
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_did_util_cbor = require("@arcblock/did-util/cbor");
+
+//#region src/utils.ts
+const TOP_LEVEL_DIRS = [
+	"config",
+	"validators",
+	"transactions",
+	"accounts",
+	"tokens",
+	"assets",
+	"factories",
+	"stakes",
+	"bridges",
+	"delegates"
+];
+/** Collection path segment → singular kind suffix. Single source of truth. */
+const COLLECTION_KIND_MAP = {
+	config: "config",
+	validators: "validator",
+	transactions: "transaction",
+	accounts: "account",
+	tokens: "token",
+	assets: "asset",
+	factories: "factory",
+	stakes: "stake",
+	bridges: "bridge",
+	delegates: "delegate"
+};
+/** Search result type → collection path segment. */
+const TYPE_TO_COLLECTION = {
+	tx: "transactions",
+	transaction: "transactions",
+	account: "accounts",
+	token: "tokens",
+	asset: "assets",
+	factory: "factories",
+	stake: "stakes",
+	bridge: "bridges",
+	delegate: "delegates"
+};
+/** Returns the full `ocap:xxx` kind for a collection name. */
+function collectionKind(collection) {
+	return `ocap:${COLLECTION_KIND_MAP[collection] ?? collection}`;
+}
+function toPaging(options, defaultSize = 20) {
+	return {
+		size: options?.limit ?? defaultSize,
+		offset: options?.offset ?? 0
+	};
+}
+/**
+* Single-point narrow from `ctx.options` (typed as `RouteOptions` union in
+* `@aigne/afs/provider`) down to OCAP's domain-specific `OcapListOptions`
+* shape. Use this in every `@List` handler instead of casting through
+* `as any` / `as Record<string, unknown>` — the runtime cost is identical
+* (a bare assertion, no copy), but the type system now knows what fields
+* the handler may read, and `toPaging` + `extract*Filters` accept the
+* narrowed type directly without further casts.
+*/
+/**
+* Typed-where vocabulary (afs-collection-query T5.3): every field is one of
+* OCAP's documented filter keys, with the operator(s) its extractor shape
+* admits. ANYTHING else — unknown field, disallowed operator, non-string
+* value — is a strict `AFSValidationError`; no unvetted token can ever
+* reach a GQL variable. (The core grammar validator has already rejected
+* prototype keys / malformed dot-paths before this table is consulted.)
+*/
+const WHERE_SCALAR_FIELDS = new Set([
+	"sender",
+	"receiver",
+	"direction",
+	"validity",
+	"issuerAddress",
+	"ownerAddress",
+	"factoryAddress",
+	"tokenAddress",
+	"from",
+	"to"
+]);
+const WHERE_LIST_FIELDS = new Set([
+	"types",
+	"tokens",
+	"assets",
+	"factories",
+	"accounts",
+	"rollups",
+	"stakes",
+	"delegations",
+	"addressList"
+]);
+/** `time` leaves map gte→startDateTime / lte→endDateTime (ISO strings). */
+const WHERE_TIME_FIELD = "time";
+/** A leaf whose operator value is "" or [] is the form's untouched state. */
+function isEmptySentinelLeaf(leaf) {
+	if (typeof leaf !== "object" || leaf === null) return false;
+	const rec = leaf;
+	for (const op of [
+		"eq",
+		"in",
+		"notIn",
+		"contains",
+		"gte",
+		"lte"
+	]) if (op in rec) {
+		const v = rec[op];
+		return v === "" || Array.isArray(v) && v.length === 0;
+	}
+	return false;
+}
+/** Drop empty-sentinel leaves; undefined when nothing substantive remains. */
+function pruneEmptySentinels(where) {
+	if (typeof where !== "object" || where === null) return where;
+	const rec = where;
+	if (Array.isArray(rec.all)) {
+		const kept = rec.all.filter((leaf) => !isEmptySentinelLeaf(leaf));
+		if (kept.length === 0) return void 0;
+		return { all: kept };
+	}
+	if (typeof rec.field === "string" && isEmptySentinelLeaf(rec)) return void 0;
+	return where;
+}
+/**
+* Translate a typed `where` into the legacy private option keys the 7
+* `extract*Filters` entry points consume — the GQL filter structure the
+* extractors emit is therefore byte-identical to the private-key path
+* (design §6: chain-explorer / OCAP row). Empty string / empty array values
+* skip the leaf, mirroring the extractors' own empty-sentinel semantics.
+*/
+function whereToOcapOptions(where) {
+	const pruned = pruneEmptySentinels(where);
+	if (pruned === void 0) return {};
+	(0, _aigne_afs.validateCollectionQuerySpec)({ where: pruned });
+	const out = {};
+	for (const leaf of (0, _aigne_afs.normalizeWhere)(pruned)) {
+		const field = leaf.field;
+		const op = Object.keys(leaf).filter((k) => k !== "field")[0];
+		const value = leaf[op];
+		if (field === WHERE_TIME_FIELD) {
+			if (op !== "gte" && op !== "lte") throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: time accepts gte/lte only (got ${op})`);
+			if (typeof value !== "string") throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: ISO string required`);
+			if (value === "") continue;
+			out[op === "gte" ? "startDateTime" : "endDateTime"] = value;
+			continue;
+		}
+		if (WHERE_SCALAR_FIELDS.has(field)) {
+			if (op !== "eq") throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: scalar filter accepts eq only (got ${op})`);
+			if (typeof value !== "string") throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: string value required`);
+			if (value === "") continue;
+			out[field] = value;
+			continue;
+		}
+		if (WHERE_LIST_FIELDS.has(field)) {
+			if (op !== "eq" && op !== "in") throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: list filter accepts eq/in only (got ${op})`);
+			const arr = op === "in" ? value : [value];
+			if (!arr.every((v) => typeof v === "string")) throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: string values required`);
+			const cleaned = arr.filter((v) => v.length > 0);
+			if (cleaned.length === 0) continue;
+			out[field] = cleaned;
+			continue;
+		}
+		throw new _aigne_afs.AFSValidationError(`Invalid query spec: where.${field}: not an OCAP filter field`);
+	}
+	return out;
+}
+function listOpts(ctx) {
+	const raw = ctx.options;
+	if (!raw || raw.where === void 0 || raw.where === null) return raw;
+	return {
+		...raw,
+		...whereToOcapOptions(raw.where)
+	};
+}
+function buildDirEntry(basePath, name, childrenCount) {
+	const isHidden = name === ".." || name.startsWith(".");
+	const meta = {
+		kind: collectionKind(name),
+		childrenCount: childrenCount ?? -1
+	};
+	if (isHidden) meta.visibility = "hidden";
+	return {
+		id: name,
+		path: (0, ufo.joinURL)(basePath, name),
+		meta,
+		summary: name
+	};
+}
+function buildListResult(entries, total) {
+	return {
+		data: entries,
+		total
+	};
+}
+/** Reverse mapping: collection path segment → search result types. */
+const COLLECTION_TO_TYPES = {};
+for (const [type, col] of Object.entries(TYPE_TO_COLLECTION)) {
+	if (!COLLECTION_TO_TYPES[col]) COLLECTION_TO_TYPES[col] = [];
+	COLLECTION_TO_TYPES[col].push(type);
+}
+function pickDefined(obj) {
+	const result = {};
+	let hasAny = false;
+	for (const [k, v] of Object.entries(obj)) if (v !== void 0 && v !== null) {
+		result[k] = v;
+		hasAny = true;
+	}
+	return hasAny ? result : void 0;
+}
+function extractTimeFilter(opts) {
+	const start = opts?.startDateTime ?? opts?.timeStart;
+	const end = opts?.endDateTime ?? opts?.timeEnd;
+	if (!start && !end) return void 0;
+	const filter = {};
+	if (start) filter.startDateTime = start;
+	if (end) filter.endDateTime = end;
+	return filter;
+}
+/**
+* Normalize the user-supplied validity value to the GQL enum. Accepts the
+* canonical strings (`"VALID"` / `"INVALID"` / `"BOTH"`), the lowercase
+* variants emitted by URL params, and the empty / undefined sentinels meaning
+* "no filter". Any other value is dropped so an arbitrary URL param can't
+* smuggle a non-enum string through to the GQL layer.
+*/
+function normalizeValidity(value) {
+	if (typeof value !== "string" || !value) return void 0;
+	const upper = value.toUpperCase();
+	if (upper === "VALID" || upper === "INVALID" || upper === "BOTH") return upper;
+}
+function extractTxFilters(opts) {
+	if (!opts) return void 0;
+	let addressFilter;
+	if (opts.sender || opts.receiver) {
+		addressFilter = { direction: opts.direction ?? "UNION" };
+		if (opts.sender) addressFilter.sender = opts.sender;
+		if (opts.receiver) addressFilter.receiver = opts.receiver;
+	}
+	const validity = normalizeValidity(opts.validity);
+	const toList = (v) => {
+		if (Array.isArray(v)) {
+			const cleaned = v.filter((x) => typeof x === "string" && x.length > 0);
+			return cleaned.length > 0 ? cleaned : void 0;
+		}
+		if (typeof v === "string" && v.length > 0) return [v];
+	};
+	const types = toList(opts.types);
+	const tokens = toList(opts.tokens);
+	return pickDefined({
+		addressFilter,
+		typeFilter: types ? { types } : void 0,
+		tokenFilter: tokens ? { tokens } : void 0,
+		assetFilter: opts.assets ? { assets: opts.assets } : void 0,
+		factoryFilter: opts.factories ? { factories: opts.factories } : void 0,
+		accountFilter: opts.accounts ? { accounts: opts.accounts } : void 0,
+		rollupFilter: opts.rollups ? { rollups: opts.rollups } : void 0,
+		stakeFilter: opts.stakes ? { stakes: opts.stakes } : void 0,
+		delegationFilter: opts.delegations ? { delegations: opts.delegations } : void 0,
+		validityFilter: validity && validity !== "BOTH" ? { validity } : void 0,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractTokenFilters(opts) {
+	if (!opts) return void 0;
+	return pickDefined({
+		issuerAddress: opts.issuerAddress,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractAssetFilters(opts) {
+	if (!opts) return void 0;
+	return pickDefined({
+		ownerAddress: opts.ownerAddress,
+		factoryAddress: opts.factoryAddress,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractFactoryFilters(opts) {
+	if (!opts) return void 0;
+	return pickDefined({
+		ownerAddress: opts.ownerAddress,
+		addressList: opts.addressList,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractStakeFilters(opts) {
+	if (!opts) return void 0;
+	let addressFilter;
+	if (opts.sender || opts.receiver) {
+		addressFilter = { direction: opts.direction ?? "UNION" };
+		if (opts.sender) addressFilter.sender = opts.sender;
+		if (opts.receiver) addressFilter.receiver = opts.receiver;
+	}
+	return pickDefined({
+		addressFilter,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractBridgeFilters(opts) {
+	if (!opts) return void 0;
+	return pickDefined({
+		tokenAddress: opts.tokenAddress,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+function extractDelegationFilters(opts) {
+	if (!opts) return void 0;
+	return pickDefined({
+		from: opts.from,
+		to: opts.to,
+		timeFilter: extractTimeFilter(opts)
+	});
+}
+/** DID role code → OCAP entity type name. */
+const ROLE_TO_ENTITY = {
+	[_arcblock_did.types.RoleType.ROLE_ACCOUNT]: "account",
+	[_arcblock_did.types.RoleType.ROLE_APPLICATION]: "account",
+	[_arcblock_did.types.RoleType.ROLE_NODE]: "account",
+	[_arcblock_did.types.RoleType.ROLE_VALIDATOR]: "account",
+	[_arcblock_did.types.RoleType.ROLE_BOT]: "account",
+	[_arcblock_did.types.RoleType.ROLE_PASSKEY]: "account",
+	[_arcblock_did.types.RoleType.ROLE_TOKEN]: "token",
+	[_arcblock_did.types.RoleType.ROLE_ASSET]: "asset",
+	[_arcblock_did.types.RoleType.ROLE_FACTORY]: "factory",
+	[_arcblock_did.types.RoleType.ROLE_TOKEN_FACTORY]: "factory",
+	[_arcblock_did.types.RoleType.ROLE_STAKE]: "stake",
+	[_arcblock_did.types.RoleType.ROLE_ROLLUP]: "bridge",
+	[_arcblock_did.types.RoleType.ROLE_DELEGATION]: "delegate"
+};
+/** Extract OCAP entity type from a DID address using its encoded role byte. */
+function resolveDidRole(address) {
+	try {
+		const info = (0, _arcblock_did.toTypeInfo)(address);
+		if (info.role === void 0) return null;
+		return ROLE_TO_ENTITY[info.role] ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Granular human-readable role label for a DID (e.g., "Validator", "Bot",
+* "Application"). Used by the account detail page's role pill — the
+* generic resolveDidRole returns just "account" for ROLE_VALIDATOR /
+* ROLE_BOT / ROLE_NODE / etc., losing the actual sub-type information
+* the user sees in legacy explorers.
+*/
+const ROLE_TO_LABEL = {
+	[_arcblock_did.types.RoleType.ROLE_ACCOUNT]: "Account",
+	[_arcblock_did.types.RoleType.ROLE_APPLICATION]: "Application",
+	[_arcblock_did.types.RoleType.ROLE_NODE]: "Node",
+	[_arcblock_did.types.RoleType.ROLE_VALIDATOR]: "Validator",
+	[_arcblock_did.types.RoleType.ROLE_BOT]: "Bot",
+	[_arcblock_did.types.RoleType.ROLE_PASSKEY]: "Passkey",
+	[_arcblock_did.types.RoleType.ROLE_TOKEN]: "Token",
+	[_arcblock_did.types.RoleType.ROLE_ASSET]: "Asset",
+	[_arcblock_did.types.RoleType.ROLE_FACTORY]: "Factory",
+	[_arcblock_did.types.RoleType.ROLE_TOKEN_FACTORY]: "Token Factory",
+	[_arcblock_did.types.RoleType.ROLE_STAKE]: "Stake",
+	[_arcblock_did.types.RoleType.ROLE_ROLLUP]: "Rollup",
+	[_arcblock_did.types.RoleType.ROLE_DELEGATION]: "Delegation"
+};
+function resolveDidRoleLabel(address) {
+	try {
+		const info = (0, _arcblock_did.toTypeInfo)(address);
+		if (info.role === void 0) return null;
+		return ROLE_TO_LABEL[info.role] ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* "transfer_v3" → "Transfer V3"
+*
+* Display rebrand: the chain protocol calls them "rollups" in tx type names
+* (\`create_rollup\`, \`update_rollup\`, …) but the user-facing surface uses
+* "Bridge". Substitute the word in the rendered label so the Type column
+* reads "Create Bridge" / "Update Bridge" without changing the on-chain
+* type literal that GQL still uses.
+*/
+function formatTxTypeName(type) {
+	return type.split("_").filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" ").replace(/\bRollup\b/g, "Bridge");
+}
+/** Map tx status code to an AUP intent string. */
+function txStatusIntent(code) {
+	if (!code || code === "OK") return "success";
+	return "danger";
+}
+/**
+* Resolve a transaction's true sender and receiver from its nested `tx.itxJson`.
+*
+* v3-style (transfer_v3, acquire_asset_v3) carries an `inputs[]`/`outputs[]`
+* payload. The true sender is `inputs[0].owner`; the outer `tx.from` holds the
+* output owner (submitter), not the party losing tokens. Using `tx.from` as the
+* sender makes every v3 transfer look like a self-transfer.
+*
+* Legacy (transfer, transfer_v2, …) has no inputs/outputs — sender comes from
+* the outer `tx.from` and receiver from `itxJson.to` / `itxJson.receiver`.
+*
+* account_migrate carries the migration target in `itxJson.address` (the new
+* DID the account is migrating to); the outer receiver is empty on chain. We
+* surface it as the receiver so the global tx list "To" column points at the
+* destination account instead of rendering blank.
+*/
+function resolveTxParties(tx) {
+	const outer = tx.tx ?? {};
+	const itxJson = outer.itxJson ?? {};
+	const inputOwner = itxJson.inputs?.[0]?.owner;
+	const outputOwner = itxJson.outputs?.[0]?.owner;
+	const nonEmpty = (v) => typeof v === "string" && v.length > 0;
+	const senderFromTop = nonEmpty(tx.sender) ? tx.sender : void 0;
+	const receiverFromTop = nonEmpty(tx.receiver) ? tx.receiver : void 0;
+	if (inputOwner || outputOwner) {
+		const sender$1 = nonEmpty(inputOwner) ? inputOwner : senderFromTop ?? (nonEmpty(outer.from) ? outer.from : void 0);
+		const receiver$1 = nonEmpty(outputOwner) ? outputOwner : receiverFromTop;
+		if (sender$1 || receiver$1) return {
+			sender: sender$1,
+			receiver: receiver$1
+		};
+	}
+	let sender = senderFromTop;
+	if (!sender && nonEmpty(outer.from)) sender = outer.from;
+	let receiver = receiverFromTop;
+	if (!receiver) {
+		if (nonEmpty(itxJson.receiver)) receiver = itxJson.receiver;
+		else if (nonEmpty(itxJson.to)) receiver = itxJson.to;
+		else if (nonEmpty(outer.receiver)) receiver = outer.receiver;
+		else if (itxJson.type_url === "fg:t:account_migrate" && nonEmpty(itxJson.address)) receiver = itxJson.address;
+		else if (typeof itxJson.type_url === "string" && STAKE_LIKE_TYPE_URLS.has(itxJson.type_url) && nonEmpty(itxJson.address)) receiver = itxJson.address;
+	}
+	return {
+		sender,
+		receiver
+	};
+}
+const STAKE_LIKE_TYPE_URLS = new Set([
+	"fg:t:stake",
+	"fg:t:revoke_stake",
+	"fg:t:claim_stake",
+	"fg:t:return_stake",
+	"fg:t:slash_stake"
+]);
+/**
+* Format a raw bignum string (possibly negative) to a human-readable decimal
+* with a leading +/- sign. Suitable for displaying receipt change amounts.
+*
+* The integer part wears thousand separators so that pre-formatted strings
+* (`_gasFeeFormatted`, `_serviceFeeFormatted`, receipt `valueFormatted`)
+* read consistently with the browser-side `bignum` formatter (B1).
+*
+* Example: formatBignumValue("1000000000000000000", 18) → "+1"
+*          formatBignumValue("-500000000000000000", 18) → "-0.5"
+*          formatBignumValue("1230000000000000000000000000", 18) → "+1,230,000,000"
+*/
+function formatBignumValue(value, decimal) {
+	if (!value || value === "0") return "0";
+	try {
+		const negative = value.startsWith("-");
+		const padded = (negative ? value.slice(1) : value).padStart(decimal + 1, "0");
+		const intPart = padded.slice(0, padded.length - decimal) || "0";
+		const fracPart = padded.slice(padded.length - decimal).replace(/0+$/, "");
+		const intWithSep = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+		const formatted = fracPart ? `${intWithSep}.${fracPart}` : intWithSep;
+		return negative ? `-${formatted}` : `+${formatted}`;
+	} catch {
+		return value;
+	}
+}
+/**
+* B6 — Account moniker often defaults to the account's own address when the
+* user never set a friendly name. Surfacing it in a "Name" column next to
+* "Address" creates a duplicate-looking row. This helper strips that
+* duplication so the column shows "—" instead.
+*/
+function displayMoniker(moniker, address) {
+	if (!moniker || moniker === address) return "—";
+	return moniker;
+}
+/**
+* B3 — render a numeric integer with thousand separators, replacing the
+* sentinel value `0` with a semantic label such as "Unlimited" / "Never".
+*
+* Why server-side: the value the user reads ("Unlimited") and the value
+* the renderer formats ("1,234") are two different presentations of the
+* same field. Rather than teach the renderer about provider-specific
+* sentinels (factory limit=0, asset ttl=0, tx serviceFee=0), the provider
+* resolves the sentinel and ships a plain string the renderer can drop in.
+*/
+function formatIntegerOrSentinel(value, zeroLabel) {
+	if (value === null || value === void 0 || value === "") return zeroLabel;
+	const n = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(n) || n === 0) return zeroLabel;
+	return n.toLocaleString("en-US");
+}
+/**
+* Compose bridge `closed` + `paused` into a single user-facing label so the
+* Bridges list and the bridge detail hero surface the same information.
+*
+* Why combined instead of "closed only" on the list: a bridge can be both
+* closed and paused, or active-but-paused. Hiding the paused flag on the
+* list left users wondering why an "Active" bridge wasn't accepting traffic.
+*
+* Output shape:
+*   - Active                   (closed=false, paused=false)
+*   - Active · Paused          (closed=false, paused=true)
+*   - Closed                   (closed=true,  paused=false)
+*   - Closed · Paused          (closed=true,  paused=true)
+*/
+function formatBridgeStatusLabel(closed, paused) {
+	const base = closed ? "Closed" : "Active";
+	return paused ? `${base} · Paused` : base;
+}
+/**
+* Sibling color pair for the Status colored-badge in the bridges list.
+*
+* Mapping mirrors `formatBridgeStatusLabel`:
+*   - Closed → red (operational dead-end, not coming back)
+*   - Paused (still open) → amber (warning, may resume)
+*   - Active → green (healthy)
+*
+* Uses the same `{main, light}` shape the colored-badge formatter expects.
+*/
+function formatBridgeStatusColor(closed, paused) {
+	if (closed) return {
+		main: "#991B1B",
+		light: "#FEE2E2"
+	};
+	if (paused) return {
+		main: "#92400E",
+		light: "#FEF3C7"
+	};
+	return {
+		main: "#0E7C5A",
+		light: "#E8F8F1"
+	};
+}
+/**
+* Re-export `toStakeAddress` from `@arcblock/did-util` so OCAP callers stay
+* tied to the canonical chain primitive (single source of truth lives in
+* `blockchain/did/did-util/src/shared.ts`).
+*
+* did-util's implementation uses `Buffer.concat([Buffer.from(x)])`. On
+* Cloudflare Workers this still works because the arc worker enables
+* `compatibility_flags = ["nodejs_compat"]` (`runtimes/cloudflare/wrangler.toml:25`),
+* which exposes the Node-style `Buffer` global. The `worker-compat.test.ts`
+* guard rail bans `node:*` imports from shipped provider sources, not the
+* Node-compat globals, so this re-export is safe across Node, Bun, and
+* workerd.
+*
+* Used by Bridge Slash listing to match `claim_block_reward` receipts back
+* to the rollup's validator stake addresses.
+*/
+const toStakeAddress = _arcblock_did_util_cbor.toStakeAddress;
+
+//#endregion
+exports.COLLECTION_TO_TYPES = COLLECTION_TO_TYPES;
+exports.TOP_LEVEL_DIRS = TOP_LEVEL_DIRS;
+exports.TYPE_TO_COLLECTION = TYPE_TO_COLLECTION;
+exports.buildDirEntry = buildDirEntry;
+exports.buildListResult = buildListResult;
+exports.collectionKind = collectionKind;
+exports.displayMoniker = displayMoniker;
+exports.extractAssetFilters = extractAssetFilters;
+exports.extractBridgeFilters = extractBridgeFilters;
+exports.extractDelegationFilters = extractDelegationFilters;
+exports.extractFactoryFilters = extractFactoryFilters;
+exports.extractStakeFilters = extractStakeFilters;
+exports.extractTokenFilters = extractTokenFilters;
+exports.extractTxFilters = extractTxFilters;
+exports.formatBignumValue = formatBignumValue;
+exports.formatBridgeStatusColor = formatBridgeStatusColor;
+exports.formatBridgeStatusLabel = formatBridgeStatusLabel;
+exports.formatIntegerOrSentinel = formatIntegerOrSentinel;
+exports.formatTxTypeName = formatTxTypeName;
+exports.listOpts = listOpts;
+exports.resolveDidRole = resolveDidRole;
+exports.resolveDidRoleLabel = resolveDidRoleLabel;
+exports.resolveTxParties = resolveTxParties;
+exports.toPaging = toPaging;
+exports.toStakeAddress = toStakeAddress;
+exports.txStatusIntent = txStatusIntent;