maroo-viem-poc 0.1.0

package/dist/index.mjs

@@ -0,0 +1,717 @@
+import { BaseError, ContractFunctionRevertedError, decodeAbiParameters, decodeErrorResult, encodeAbiParameters, encodeFunctionData, maxUint256 } from "viem";
+import { readContract, writeContract } from "viem/actions";
+import { getAction } from "viem/utils";
+import { iPclAbi } from "@maroo-chain/contracts/abi/precompiles/pcl/IPcl";
+import { iAgentAbi } from "@maroo-chain/contracts/abi/precompiles/agent/IAgent";
+import { iEasAbi } from "@maroo-chain/contracts/abi/precompiles/eas/IEas";
+import { iOkrwAbi } from "@maroo-chain/contracts/abi/precompiles/okrw/IOkrw";
+//#region src/constants.ts
+/**
+* Maroo static precompile addresses.
+*
+* Mirrors the `*_PRECOMPILED_ADDRESS` constants in
+* `@maroo-chain/contracts/precompiles/{okrw,pcl,eas,agent}/I*.sol`.
+*
+* The contracts package does not export these from its TypeScript build
+* (only the `.sol` sources carry them), so we redeclare them here.
+* `test/addresses.test.ts` asserts these still match the installed package.
+*/
+const precompileAddresses = {
+	okrw: "0x1000000000000000000000000000000000000001",
+	pcl: "0x1000000000000000000000000000000000000005",
+	/** Returns `eas` module params. Not the EAS contract itself — see {@link easContracts}. */
+	eas: "0x1000000000000000000000000000000000000009",
+	agent: "0x100000000000000000000000000000000000000A",
+	/** Clairveil shielded pool. Not yet deployed on marooTestnet. */
+	privacy: "0x100000000000000000000000000000000000000b"
+};
+/**
+* EAS contracts, as reported by `eas.getParams()` on marooTestnet.
+*
+* These sit at precompile-shaped addresses but implement the standard
+* Ethereum Attestation Service interfaces. `@maroo-chain/contracts@0.0.6`
+* ships no ABI for them; use `@ethereum-attestation-service/eas-contracts`.
+*
+* Do not hardcode these in application code — read them from
+* `client.eas.getParams()`, which is authoritative per network.
+*/
+const easContracts = {
+	schemaRegistry: "0x1000000000000000000000000000000000000006",
+	eas: "0x1000000000000000000000000000000000000007",
+	indexer: "0x1000000000000000000000000000000000000008"
+};
+/**
+* ABI entries that exist for chain-side codegen or proxy plumbing and must
+* never be surfaced as client actions.
+*
+* - `_policies` is a `pure` no-op declared solely so the Solidity compiler
+*   emits the policy structs into the ABI (see the comment at the bottom of
+*   `IPcl.sol`). Calling it does nothing.
+* - `preCall`/`postCall` are invoked by the PCL proxy hook with a `principal`
+*   the caller cannot forge. Application code goes through {@link runOnPcl}.
+*/
+const excludedFunctions = { pcl: [
+	"_policies",
+	"preCall",
+	"postCall"
+] };
+/** The selector wildcard. An empty `selector` matches every function. */
+const SELECTOR_ALL = "0x";
+/** `VolumeUnitPolicy.maxLimit` sentinel meaning "no upper bound". */
+const NO_MAX_LIMIT = maxUint256;
+//#endregion
+//#region src/core/precompileActions.ts
+const isRead = (m) => m === "view" || m === "pure";
+/**
+* Build a typed action map from an `as const` ABI by walking it at runtime.
+*
+* Replaces per-precompile codegen: every function in `abi` becomes one method,
+* dispatched to `readContract` or `writeContract` by its state mutability.
+*
+* Overloads that agree on mutability share one dispatcher (viem resolves the
+* overload from `args`). Overloads that mix read and write mutability throw at
+* factory construction — a single dispatcher would silently misroute one side.
+*
+* @param abi - The precompile interface, as an `as const` ABI.
+* @param defaultAddress - Where the precompile lives on a stock Maroo chain.
+* @param options.mode - Emit only reads, only writes, or both.
+* @param options.exclude - Function names to omit (codegen dummies, proxy hooks).
+*/
+function precompileActions(abi, defaultAddress, options = {}) {
+	const { mode = "all", exclude = [] } = options;
+	const excluded = new Set(exclude);
+	const classification = /* @__PURE__ */ new Map();
+	const payableNames = /* @__PURE__ */ new Set();
+	for (const item of abi) {
+		if (item.type !== "function" || excluded.has(item.name)) continue;
+		const read = isRead(item.stateMutability);
+		const prev = classification.get(item.name);
+		if (prev !== void 0 && prev !== read) throw new Error(`precompileActions: "${item.name}" has overloads with mixed read/write mutability; add it to options.exclude and wrap it by hand`);
+		classification.set(item.name, read);
+		if (item.stateMutability === "payable") payableNames.add(item.name);
+	}
+	return (config = {}) => (client) => {
+		const actions = {};
+		for (const item of abi) {
+			if (item.type !== "function") continue;
+			if (excluded.has(item.name)) continue;
+			if (actions[item.name]) continue;
+			const read = isRead(item.stateMutability);
+			if (mode === "read" && !read) continue;
+			if (mode === "write" && read) continue;
+			const functionName = item.name;
+			const payable = payableNames.has(functionName);
+			const resolveCall = (parameters) => {
+				const { address, args, value: _value, ...rest } = parameters;
+				return {
+					...rest,
+					abi,
+					functionName,
+					args: args ?? [],
+					address: address ?? config.address ?? defaultAddress
+				};
+			};
+			const fn = (parameters = {}) => {
+				const call = resolveCall(parameters);
+				if (read) return getAction(client, readContract, "readContract")(call);
+				const value = payable ? parameters.value : void 0;
+				return getAction(client, writeContract, "writeContract")({
+					...call,
+					...value !== void 0 ? { value } : {}
+				});
+			};
+			if (read) fn.call = (parameters = {}) => resolveCall(parameters);
+			actions[functionName] = fn;
+		}
+		return actions;
+	};
+}
+//#endregion
+//#region src/actions/runOnPcl.ts
+/**
+* Call a contract *through* the PCL precompile so that contract-scoped
+* policies are enforced.
+*
+* A direct call to the same contract enforces **global policies only**. There
+* is nothing in the target contract's ABI, nor in any revert, that signals
+* this — the call simply succeeds with contract policies unapplied. Route
+* through `runOnPcl` whenever the target has policies registered.
+*
+* For a contract call the parameter shape mirrors `writeContract`, so
+* switching a call site is a one-word change. Omit `abi`/`functionName` to
+* forward a bare native transfer, or pass pre-encoded `data`.
+*
+* @example
+* ```ts
+* const hash = await client.pcl.runOnPcl({
+*   address: token,
+*   abi: erc20Abi,
+*   functionName: 'transfer',
+*   args: [recipient, amount],
+* })
+*
+* // Native transfer, policy-checked:
+* const hash = await client.pcl.runOnPcl({ address: recipient, value: parseEther('1') })
+* ```
+*/
+async function runOnPcl(client, parameters) {
+	const { address, value = 0n, gas, pclAddress } = parameters;
+	const data = parameters.abi ? encodeFunctionData({
+		abi: parameters.abi,
+		functionName: parameters.functionName,
+		args: parameters.args
+	}) : parameters.data ?? "0x";
+	return getAction(client, writeContract, "writeContract")({
+		address: pclAddress ?? precompileAddresses.pcl,
+		abi: iPclAbi,
+		functionName: "runOnPcl",
+		args: [
+			address,
+			data,
+			value
+		],
+		gas
+	});
+}
+//#endregion
+//#region src/decorators/precompiles.ts
+const pclReadActions = precompileActions(iPclAbi, precompileAddresses.pcl, {
+	mode: "read",
+	exclude: excludedFunctions.pcl
+});
+const okrwReadActions = precompileActions(iOkrwAbi, precompileAddresses.okrw, { mode: "read" });
+const easReadActions = precompileActions(iEasAbi, precompileAddresses.eas, { mode: "read" });
+const agentReadActions = precompileActions(iAgentAbi, precompileAddresses.agent, { mode: "read" });
+const pclWriteActions = precompileActions(iPclAbi, precompileAddresses.pcl, {
+	mode: "write",
+	exclude: excludedFunctions.pcl
+});
+const okrwWriteActions = precompileActions(iOkrwAbi, precompileAddresses.okrw, { mode: "write" });
+//#endregion
+//#region src/decorators/maroo.ts
+/**
+* Read actions for every Maroo precompile.
+*
+* @example
+* ```ts
+* const client = createPublicClient({ chain: marooTestnet, transport: http() })
+*   .extend(marooPublicActions())
+*
+* const { policyAdmin, entrypoints } = await client.pcl.getParams()
+* const { policies } = await client.pcl.globalPolicies()
+* const [ids, page] = await client.agent.getAgentIds({ args: [wallet, pageRequest] })
+* ```
+*/
+function marooPublicActions() {
+	return (client) => ({
+		pcl: pclReadActions()(client),
+		okrw: okrwReadActions()(client),
+		eas: easReadActions()(client),
+		agent: agentReadActions()(client)
+	});
+}
+/**
+* @example
+* ```ts
+* const client = createWalletClient({ chain: marooTestnet, account, transport: http() })
+*   .extend(marooWalletActions())
+*
+* const hash = await client.pcl.runOnPcl({
+*   address: token, abi: erc20Abi, functionName: 'transfer', args: [to, amount],
+* })
+* ```
+*/
+function marooWalletActions() {
+	return (client) => ({
+		pcl: {
+			...pclWriteActions()(client),
+			runOnPcl: (parameters) => runOnPcl(client, parameters)
+		},
+		okrw: okrwWriteActions()(client)
+	});
+}
+//#endregion
+//#region src/codec/policy.ts
+/**
+* PCL policy codec.
+*
+* `PolicySet.policy` is an opaque `bytes` field whose layout is chosen by the
+* sibling `templateId` string. That mapping exists nowhere in the ABI — the
+* `_policies` dummy function only forces the structs into the artifact. This
+* module is the mapping.
+*
+* Verified against `marooTestnet.globalPolicies()` at block 12447862.
+*/
+const policyTemplateIds = [
+	"EAS_POLICY",
+	"DENYLIST_POLICY",
+	"VOLUME_POLICY",
+	"OKRW_EAS_TRANSFER_LIMIT_POLICY",
+	"PERIODIC_VOLUME_POLICY",
+	"AGENT_OKRW_TRANSFER_LIMIT_POLICY",
+	"OKRW_EAS_PERIODIC_VOLUME_LIMIT_POLICY",
+	"LOGICAL_POLICY",
+	"FOR_EACH_POLICY"
+];
+const LogicalQuantifier = {
+	Unspecified: 0,
+	And: 1,
+	Or: 2
+};
+const ForEachQuantifier = {
+	Unspecified: 0,
+	Any: 1,
+	Every: 2
+};
+const ForEachSubject = {
+	Unspecified: 0,
+	AgentOwners: 1
+};
+const nameOf = (e, v) => Object.keys(e).find((k) => e[k] === v) ?? "Unspecified";
+const POLICY_SET_COMPONENTS = [
+	{
+		name: "templateId",
+		type: "string"
+	},
+	{
+		name: "policy",
+		type: "bytes"
+	},
+	{
+		name: "selector",
+		type: "bytes"
+	}
+];
+/**
+* `templateId` → the ABI parameters of its `policy` bytes payload.
+*
+* Each entry is a one-element parameter list wrapping the payload tuple, so
+* `decodeAbiParameters(codec, bytes)[0]` is the decoded struct.
+*/
+const policyCodecs = {
+	EAS_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [
+			{
+				name: "easContract",
+				type: "address"
+			},
+			{
+				name: "indexContract",
+				type: "address"
+			},
+			{
+				name: "schemaUid",
+				type: "bytes32"
+			}
+		]
+	}],
+	DENYLIST_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [{
+			name: "addresses",
+			type: "address[]"
+		}]
+	}],
+	VOLUME_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [{
+			name: "tokens",
+			type: "string[]"
+		}, {
+			name: "limits",
+			type: "tuple[]",
+			components: [{
+				name: "minLimit",
+				type: "uint256"
+			}, {
+				name: "maxLimit",
+				type: "uint256"
+			}]
+		}]
+	}],
+	PERIODIC_VOLUME_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [{
+			name: "tokens",
+			type: "string[]"
+		}, {
+			name: "limits",
+			type: "tuple[]",
+			components: [{
+				name: "maxAmount",
+				type: "uint256"
+			}, {
+				name: "resetPeriodSeconds",
+				type: "uint64"
+			}]
+		}]
+	}],
+	OKRW_EAS_TRANSFER_LIMIT_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [
+			{
+				name: "easContract",
+				type: "address"
+			},
+			{
+				name: "indexContract",
+				type: "address"
+			},
+			{
+				name: "schemaUid",
+				type: "bytes32"
+			},
+			{
+				name: "transferLimitAmount",
+				type: "uint256"
+			}
+		]
+	}],
+	OKRW_EAS_PERIODIC_VOLUME_LIMIT_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [
+			{
+				name: "easContract",
+				type: "address"
+			},
+			{
+				name: "indexContract",
+				type: "address"
+			},
+			{
+				name: "schemaUid",
+				type: "bytes32"
+			},
+			{
+				name: "maxAmount",
+				type: "uint256"
+			},
+			{
+				name: "resetPeriodSeconds",
+				type: "uint64"
+			}
+		]
+	}],
+	AGENT_OKRW_TRANSFER_LIMIT_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [{
+			name: "reserved",
+			type: "uint256"
+		}]
+	}],
+	LOGICAL_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [{
+			name: "quantifier",
+			type: "uint8"
+		}, {
+			name: "children",
+			type: "tuple[]",
+			components: POLICY_SET_COMPONENTS
+		}]
+	}],
+	FOR_EACH_POLICY: [{
+		name: "policy",
+		type: "tuple",
+		components: [
+			{
+				name: "quantifier",
+				type: "uint8"
+			},
+			{
+				name: "subject",
+				type: "uint8"
+			},
+			{
+				name: "child",
+				type: "tuple",
+				components: POLICY_SET_COMPONENTS
+			}
+		]
+	}]
+};
+const MAX_DEPTH = 8;
+const isKnown = (id) => Object.prototype.hasOwnProperty.call(policyCodecs, id);
+/**
+* Recursively decode a `PolicySet` returned by `globalPolicies()` or
+* `contractPolicies()` into a readable tree.
+*
+* Unrecognised template ids decode to `{ unknown: true, raw }` rather than
+* throwing, so a chain upgrade that adds a policy type degrades a dApp's
+* policy inspector instead of breaking it.
+*/
+function decodePolicySet(set, depth = 0) {
+	if (depth > MAX_DEPTH) throw new Error(`policy nesting exceeded depth ${MAX_DEPTH}`);
+	const { selector } = set;
+	if (!isKnown(set.templateId)) return {
+		templateId: set.templateId,
+		selector,
+		raw: set.policy,
+		unknown: true
+	};
+	switch (set.templateId) {
+		case "EAS_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.EAS_POLICY, set.policy);
+			return {
+				templateId: "EAS_POLICY",
+				selector,
+				easContract: p.easContract,
+				indexContract: p.indexContract,
+				schemaUid: p.schemaUid
+			};
+		}
+		case "DENYLIST_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.DENYLIST_POLICY, set.policy);
+			return {
+				templateId: "DENYLIST_POLICY",
+				selector,
+				addresses: p.addresses
+			};
+		}
+		case "VOLUME_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.VOLUME_POLICY, set.policy);
+			if (p.tokens.length !== p.limits.length) return {
+				templateId: set.templateId,
+				selector,
+				raw: set.policy,
+				unknown: true
+			};
+			return {
+				templateId: "VOLUME_POLICY",
+				selector,
+				limits: p.tokens.map((token, i) => ({
+					token,
+					minLimit: p.limits[i].minLimit,
+					maxLimit: p.limits[i].maxLimit
+				}))
+			};
+		}
+		case "PERIODIC_VOLUME_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.PERIODIC_VOLUME_POLICY, set.policy);
+			if (p.tokens.length !== p.limits.length) return {
+				templateId: set.templateId,
+				selector,
+				raw: set.policy,
+				unknown: true
+			};
+			return {
+				templateId: "PERIODIC_VOLUME_POLICY",
+				selector,
+				limits: p.tokens.map((token, i) => ({
+					token,
+					maxAmount: p.limits[i].maxAmount,
+					resetPeriodSeconds: p.limits[i].resetPeriodSeconds
+				}))
+			};
+		}
+		case "OKRW_EAS_TRANSFER_LIMIT_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.OKRW_EAS_TRANSFER_LIMIT_POLICY, set.policy);
+			return {
+				templateId: "OKRW_EAS_TRANSFER_LIMIT_POLICY",
+				selector,
+				easContract: p.easContract,
+				indexContract: p.indexContract,
+				schemaUid: p.schemaUid,
+				transferLimitAmount: p.transferLimitAmount
+			};
+		}
+		case "OKRW_EAS_PERIODIC_VOLUME_LIMIT_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.OKRW_EAS_PERIODIC_VOLUME_LIMIT_POLICY, set.policy);
+			return {
+				templateId: "OKRW_EAS_PERIODIC_VOLUME_LIMIT_POLICY",
+				selector,
+				easContract: p.easContract,
+				indexContract: p.indexContract,
+				schemaUid: p.schemaUid,
+				maxAmount: p.maxAmount,
+				resetPeriodSeconds: p.resetPeriodSeconds
+			};
+		}
+		case "AGENT_OKRW_TRANSFER_LIMIT_POLICY":
+			decodeAbiParameters(policyCodecs.AGENT_OKRW_TRANSFER_LIMIT_POLICY, set.policy);
+			return {
+				templateId: "AGENT_OKRW_TRANSFER_LIMIT_POLICY",
+				selector
+			};
+		case "LOGICAL_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.LOGICAL_POLICY, set.policy);
+			return {
+				templateId: "LOGICAL_POLICY",
+				selector,
+				quantifier: nameOf(LogicalQuantifier, p.quantifier),
+				children: p.children.map((c) => decodePolicySet(c, depth + 1))
+			};
+		}
+		case "FOR_EACH_POLICY": {
+			const [p] = decodeAbiParameters(policyCodecs.FOR_EACH_POLICY, set.policy);
+			return {
+				templateId: "FOR_EACH_POLICY",
+				selector,
+				quantifier: nameOf(ForEachQuantifier, p.quantifier),
+				subject: nameOf(ForEachSubject, p.subject),
+				child: decodePolicySet(p.child, depth + 1)
+			};
+		}
+		default: return {
+			templateId: set.templateId,
+			selector,
+			raw: set.policy,
+			unknown: true
+		};
+	}
+}
+/**
+* ABI-encode a policy payload for its template.
+*
+* The `policy` argument is typed per `templateId` via {@link PolicyInput}, so
+* the public signature is fully checked. The single internal cast is the
+* unavoidable one: indexing `policyCodecs` by a generic `id` yields a union
+* that `encodeAbiParameters` cannot unify positionally (viem does the same at
+* this boundary).
+*
+* Admin-facing: only `policyAdmin` may set global policies, and only a
+* contract's registered admin may change its contract policies.
+*/
+function encodePolicy(templateId, policy) {
+	const codec = policyCodecs[templateId];
+	return encodeAbiParameters(codec, [policy]);
+}
+/**
+* Normalize a function selector for a `PolicySet`.
+*
+* The chain accepts either an empty value (wildcard, stored internally as
+* `"__all__"`) or exactly 4 bytes, lowercased. Anything else is rejected with
+* `InvalidSelector`.
+*/
+function normalizeSelector(selector) {
+	if (!selector || selector === "0x") return "0x";
+	const body = selector.slice(2).toLowerCase();
+	if (!/^[0-9a-f]{8}$/.test(body)) throw new Error(`selector must be 4 bytes of hex (8 hex chars), got "${selector}"`);
+	return `0x${body}`;
+}
+//#endregion
+//#region src/errors/pcl.ts
+/**
+* The errors PCL actually declares. Used to refuse errors we do not own —
+* `decodeErrorResult` also recognises the built-in `Error(string)` / `Panic`
+* signatures, and those must decode to `null`, not to a policy verdict.
+*/
+const PCL_ERROR_NAMES = new Set(iPclAbi.flatMap((item) => item.type === "error" ? [item.name] : []));
+/**
+* `AnyOfRejected` nests (a LOGICAL(Or) branch can itself be a LOGICAL(Or)),
+* and revert bytes are attacker-controlled via `eth_call` — cap the recursion
+* like the policy codec caps its tree depth. Past the cap, children surface
+* as `undecodable` instead of overflowing the stack inside an error handler.
+*/
+const MAX_ERROR_DEPTH = 8;
+const ATTESTATION = {
+	EasAttestationRequired: "required",
+	EasNoAttestationReceived: "none-received",
+	EasAttestationLookupFailed: "lookup-failed",
+	EasAttestationRevoked: "revoked",
+	EasAttestationExpired: "expired"
+};
+function toViolation(name, args, depth) {
+	const a = args;
+	switch (name) {
+		case "InDenylist": return {
+			kind: "denylist",
+			sender: a[0]
+		};
+		case "VolumeBelowMinLimit": return {
+			kind: "volume-below-min",
+			minLimit: a[0],
+			value: a[1]
+		};
+		case "VolumeAboveMaxLimit": return {
+			kind: "volume-above-max",
+			maxLimit: a[0],
+			value: a[1]
+		};
+		case "ExceededPeriodicVolume": return {
+			kind: "periodic-volume",
+			maxLimit: a[0],
+			value: a[1],
+			resetAt: /* @__PURE__ */ new Date(Number(a[2]) * 1e3)
+		};
+		case "ReachedLimitOfNonEAS": return {
+			kind: "non-eas-limit",
+			maxLimit: a[0],
+			value: a[1]
+		};
+		case "ExceededAgentTransferLimit": return {
+			kind: "agent-transfer-limit",
+			maxLimit: a[0],
+			value: a[1]
+		};
+		case "Unauthorized": return { kind: "unauthorized" };
+		case "AnyOfRejected": return {
+			kind: "any-of-rejected",
+			children: (a[0] ?? []).map((child) => decode(child, depth + 1) ?? {
+				kind: "unknown",
+				name: "undecodable"
+			})
+		};
+		default:
+			if (name in ATTESTATION) return {
+				kind: "attestation",
+				reason: ATTESTATION[name],
+				sender: a[0]
+			};
+			return {
+				kind: "unknown",
+				name,
+				args
+			};
+	}
+}
+function decode(source, depth) {
+	if (depth > MAX_ERROR_DEPTH) return null;
+	let data;
+	if (typeof source === "string" && source.startsWith("0x")) data = source;
+	else if (source instanceof BaseError) {
+		const revert = source.walk((e) => e instanceof ContractFunctionRevertedError);
+		if (revert instanceof ContractFunctionRevertedError) data = revert.raw;
+	}
+	if (!data || data === "0x") return null;
+	try {
+		const { errorName, args } = decodeErrorResult({
+			abi: iPclAbi,
+			data
+		});
+		if (!PCL_ERROR_NAMES.has(errorName)) return null;
+		return toViolation(errorName, args ?? [], depth);
+	} catch {
+		return null;
+	}
+}
+/**
+* Decode PCL revert data — or a thrown viem error wrapping it — into a
+* {@link PclViolation}. Returns `null` if the revert is not a PCL error.
+*
+* @example
+* ```ts
+* try {
+*   await client.pcl.runOnPcl({ ... })
+* } catch (err) {
+*   const v = decodePclError(err)
+*   if (v?.kind === 'periodic-volume')
+*     throw new Error(`24h limit hit. Resets ${v.resetAt.toISOString()}`)
+*   throw err
+* }
+* ```
+*/
+function decodePclError(source) {
+	return decode(source, 0);
+}
+//#endregion
+export { ForEachQuantifier, ForEachSubject, LogicalQuantifier, NO_MAX_LIMIT, SELECTOR_ALL, agentReadActions, decodePclError, decodePolicySet, easContracts, easReadActions, encodePolicy, marooPublicActions, marooWalletActions, normalizeSelector, okrwReadActions, okrwWriteActions, pclReadActions, pclWriteActions, policyCodecs, policyTemplateIds, precompileActions, precompileAddresses, runOnPcl };