@pushchain/core 6.0.26 → 6.0.27-alpha.1

package/src/lib/agentic/reads/wallets.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walletCount = walletCount;
+exports.deriveForOwner = deriveForOwner;
+exports.rulesCount = rulesCount;
+exports.listForOwner = listForOwner;
+exports.walletOwner = walletOwner;
+exports.walletInfo = walletInfo;
+const viem_1 = require("viem");
+const ids_1 = require("../codec/ids");
+const errors_1 = require("../errors");
+const snapshot_1 = require("./snapshot");
+/** Factory-predicted address for (owner, index), cross-checked against the pure mirror. */
+async function predict(snap, gen, owner, index) {
+    const [address, deployed] = await snap.read(gen.addresses.factory, gen.contracts.abis.factory, 'predictWallet', [owner, index]);
+    const mirror = (0, ids_1.deriveWallet)({
+        factory: gen.addresses.factory,
+        walletImplementation: gen.addresses.walletImplementation,
+        owner,
+        index,
+    });
+    if ((0, viem_1.getAddress)(address) !== mirror) {
+        // Derivation drift between the SDK mirror and the factory (obligation 13).
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INCONSISTENT_READ, `factory predicted ${address} for (${owner}, ${index}) but the SDK derives ${mirror}`, { details: { generation: gen.id } });
+    }
+    return { address: (0, viem_1.getAddress)(address), deployed };
+}
+async function walletCount(snap, gen, owner) {
+    return BigInt(await snap.read(gen.addresses.factory, gen.contracts.abis.factory, 'walletCount', [owner]));
+}
+/** client.agentic.derive: default index is the owner's next unused slot. */
+async function deriveForOwner(reader, gen, owner, index) {
+    const snap = await snapshot_1.Snapshot.at(reader);
+    const next = await walletCount(snap, gen, owner);
+    let target = next;
+    if (index !== undefined) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'index must be a non-negative integer');
+        }
+        target = BigInt(index);
+        if (target > next) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `index ${index} is beyond the owner's next unused index ${next}; the factory only predicts up to the next slot`);
+        }
+    }
+    const p = await predict(snap, gen, owner, target);
+    return { address: p.address, index: Number(target), deployed: p.deployed };
+}
+async function rulesCount(snap, gen, wallet) {
+    const ids = await snap.read(gen.addresses.sessionEngine, gen.contracts.abis.engine, 'getPermissionIDs', [wallet]);
+    return ids.length;
+}
+/**
+ * client.agentic.list: every deployed slot plus the next undeployed slot
+ * (deployed=false, rulesCount=0), as in the spec example.
+ */
+async function listForOwner(reader, gen, owner) {
+    const snap = await snapshot_1.Snapshot.at(reader);
+    const count = await walletCount(snap, gen, owner);
+    const out = [];
+    for (let i = BigInt(0); i <= count; i++) {
+        const p = await predict(snap, gen, owner, i);
+        const deployed = i < count;
+        if (deployed !== p.deployed) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INCONSISTENT_READ, `factory reports slot ${i} deployed=${p.deployed} but walletCount is ${count}`);
+        }
+        const label = deployed
+            ? await snap.read(p.address, gen.contracts.abis.wallet, 'label')
+            : '';
+        out.push({
+            address: p.address,
+            index: Number(i),
+            label,
+            deployed,
+            rulesCount: deployed ? await rulesCount(snap, gen, p.address) : 0,
+        });
+    }
+    return out;
+}
+/** w.owner(): the owner as the wallet stores it. */
+async function walletOwner(reader, gen, wallet) {
+    const snap = await snapshot_1.Snapshot.at(reader);
+    return (0, viem_1.getAddress)(await snap.read(wallet, gen.contracts.abis.wallet, 'owner'));
+}
+/**
+ * w.info(). A deployed wallet is read from chain. An undeployed address is
+ * only describable when it is `signerIdentity`'s next predicted slot.
+ */
+async function walletInfo(reader, gen, wallet, signerIdentity) {
+    const snap = await snapshot_1.Snapshot.at(reader);
+    const deployed = await snap.code(wallet);
+    if (!deployed) {
+        if (signerIdentity) {
+            const next = await walletCount(snap, gen, signerIdentity);
+            const p = await predict(snap, gen, signerIdentity, next);
+            if (p.address === (0, viem_1.getAddress)(wallet)) {
+                return {
+                    address: p.address,
+                    label: '',
+                    index: Number(next),
+                    owner: (0, viem_1.getAddress)(signerIdentity),
+                    deployed: false,
+                    rulesCount: 0,
+                };
+            }
+        }
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.WALLET_NOT_DEPLOYED, `${wallet} is not deployed and is not the connected owner's next wallet slot`);
+    }
+    const [owner, index] = await Promise.all([
+        snap.read(wallet, gen.contracts.abis.wallet, 'owner'),
+        snap.read(gen.addresses.factory, gen.contracts.abis.factory, 'indexOf', [wallet]),
+    ]);
+    const label = await snap.read(wallet, gen.contracts.abis.wallet, 'label');
+    return {
+        address: (0, viem_1.getAddress)(wallet),
+        label,
+        index: Number(index),
+        owner: (0, viem_1.getAddress)(owner),
+        deployed: true,
+        rulesCount: await rulesCount(snap, gen, wallet),
+    };
+}
+//# sourceMappingURL=wallets.js.map

package/src/lib/agentic/response.d.ts

@@ -0,0 +1,41 @@
+import { type Address, type Hex } from 'viem';
+import { CHAIN } from '../constants/enums';
+import type { TransactionRouteType, UniversalTxResponse } from '../orchestrator/orchestrator.types';
+import type { AgenticRuntime } from './runtime';
+import type { AgenticTxMetadata } from './agentic.types';
+export interface LogicalCall {
+    to: string;
+    data: string;
+    value: bigint;
+}
+/**
+ * Present an AGW send as the wallet's own transaction: `from` is the AGW and
+ * `to`/`data`/`value` are the logical call. The signer's `origin`, hashes,
+ * nonce, gas and the on-chain `raw` fields are kept untouched; the wrapped
+ * call the signer actually sent is recorded in `agentic.rawTo/rawData`.
+ * Mutates in place so `wait()` (which reads these fields) reports the same
+ * identity on the receipt.
+ */
+export declare function adaptAgenticResponse(resp: UniversalTxResponse, meta: Omit<AgenticTxMetadata, 'rawTo' | 'rawData'> & {
+    logical: LogicalCall;
+    route?: TransactionRouteType;
+    chain?: CHAIN;
+}): UniversalTxResponse;
+/**
+ * trackTransaction replay: if the tracked Push tx called execute/executeAsAgent
+ * on a wallet of a registered, verified generation, restore the same logical
+ * identity a live send reports. Anything unrecognised is returned unchanged.
+ */
+export declare function adaptTrackedResponse(runtime: Pick<AgenticRuntime, 'reader' | 'network'>, resp: UniversalTxResponse): Promise<UniversalTxResponse>;
+/**
+ * Canonical outbound summary for both send and replay: the first actual
+ * destination call. The complete ordered calls live in agentic.destinationCalls.
+ * Identical calldata can come from explicit calls or generated transfers, so
+ * never infer the original input shape from a selector. For an unrecognized
+ * historical payload, retain the actual gateway call instead of inventing one.
+ */
+export declare function outboundResponseCall(calls: readonly {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}[], fallback: LogicalCall): LogicalCall;

package/src/lib/agentic/response.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptAgenticResponse = adaptAgenticResponse;
+exports.adaptTrackedResponse = adaptTrackedResponse;
+exports.outboundResponseCall = outboundResponseCall;
+const snapshot_1 = require("./reads/snapshot");
+const prc20_metadata_1 = require("./contracts/prc20-metadata");
+const svm_payload_1 = require("./execution/svm-payload");
+const svm_accounts_1 = require("./codec/svm-accounts");
+const chain_1 = require("../constants/chain");
+const viem_1 = require("viem");
+const viem_2 = require("viem");
+const chain_2 = require("../constants/chain");
+const helpers_1 = require("../orchestrator/internals/helpers");
+const account_1 = require("../universal/account/account");
+const chain_3 = require("./chain");
+const abi_1 = require("../constants/abi");
+const v6_1 = require("./contracts/v6");
+const deployments_1 = require("./deployments");
+/**
+ * Present an AGW send as the wallet's own transaction: `from` is the AGW and
+ * `to`/`data`/`value` are the logical call. The signer's `origin`, hashes,
+ * nonce, gas and the on-chain `raw` fields are kept untouched; the wrapped
+ * call the signer actually sent is recorded in `agentic.rawTo/rawData`.
+ * Mutates in place so `wait()` (which reads these fields) reports the same
+ * identity on the receipt.
+ */
+function adaptAgenticResponse(resp, meta) {
+    const rawTo = resp.to;
+    const rawData = resp.data;
+    if (!resp.raw) {
+        resp.raw = {
+            from: resp.from,
+            to: resp.to,
+            nonce: resp.nonce,
+            data: resp.data,
+            value: resp.value,
+        };
+    }
+    resp.from = (0, viem_2.getAddress)(meta.wallet);
+    resp.to = meta.logical.to;
+    resp.data = meta.logical.data;
+    resp.value = meta.logical.value;
+    if (meta.route)
+        resp.route = meta.route;
+    if (meta.chain) {
+        resp.chain = meta.chain;
+        resp.chainNamespace = meta.chain;
+    }
+    resp.agentic = {
+        wallet: (0, viem_2.getAddress)(meta.wallet),
+        door: meta.door,
+        ...(meta.rulesId ? { rulesId: meta.rulesId } : {}),
+        ...(meta.chainNamespace ? { chainNamespace: meta.chainNamespace } : {}),
+        ...(meta.destinationAccount
+            ? { destinationAccount: meta.destinationAccount }
+            : {}),
+        ...(meta.destinationCalls
+            ? { destinationCalls: meta.destinationCalls.map((call) => ({ ...call })) }
+            : {}),
+        ...(meta.destinationInstruction
+            ? { destinationInstruction: meta.destinationInstruction }
+            : {}),
+        ...(meta.destinationTransfer
+            ? { destinationTransfer: { ...meta.destinationTransfer } }
+            : {}),
+        ...(meta.nativeCalls
+            ? { nativeCalls: meta.nativeCalls.map((call) => ({ ...call })) }
+            : {}),
+        rawTo,
+        rawData,
+    };
+    return resp;
+}
+/**
+ * trackTransaction replay: if the tracked Push tx called execute/executeAsAgent
+ * on a wallet of a registered, verified generation, restore the same logical
+ * identity a live send reports. Anything unrecognised is returned unchanged.
+ */
+async function adaptTrackedResponse(runtime, resp) {
+    if (resp.agentic || (0, deployments_1.generationsFor)(runtime.network).length === 0)
+        return resp;
+    const batch = await adaptNativeAgentBatch(runtime, resp);
+    if (batch)
+        return batch;
+    const decoded = v6_1.v6.decodeWalletCall(resp.data);
+    if (!decoded ||
+        (decoded.kind !== 'execute' && decoded.kind !== 'executeAsAgent'))
+        return resp;
+    let wallet;
+    try {
+        wallet = (0, viem_2.getAddress)(resp.to);
+    }
+    catch {
+        return resp;
+    }
+    let gen;
+    try {
+        gen = await (0, deployments_1.resolveWalletGeneration)(runtime.reader, runtime.network, wallet);
+    }
+    catch {
+        return resp;
+    }
+    const door = decoded.kind === 'execute' ? 'owner' : 'agent';
+    const rulesId = decoded.kind === 'executeAsAgent'
+        ? decoded.rulesId
+        : undefined;
+    const calls = decoded.calls;
+    const outbound = calls.find((c) => (0, viem_2.getAddress)(c.target) === gen.addresses.gateway &&
+        c.data.toLowerCase().startsWith(v6_1.SEND_OUTBOUND_SELECTOR));
+    if (outbound) {
+        const out = decodeOutbound(outbound.data);
+        const chain = await tokenChain(runtime, out.token);
+        if (chain?.startsWith('solana:')) {
+            if (door === 'owner' &&
+                out.payload === '0x' &&
+                out.amount > BigInt(0) &&
+                /^0x[0-9a-fA-F]{64}$/.test(out.recipient)) {
+                try {
+                    const gas = await (0, prc20_metadata_1.readGasPrc20)(new snapshot_1.Snapshot(runtime.reader, resp.blockNumber), chain);
+                    return adaptAgenticResponse(resp, {
+                        wallet,
+                        door,
+                        chainNamespace: chain,
+                        chain: chain,
+                        route: 'UOA_TO_CEA',
+                        destinationTransfer: {
+                            recipient: out.recipient,
+                            token: out.token,
+                            amount: out.amount,
+                        },
+                        logical: {
+                            to: out.recipient,
+                            data: '0x',
+                            value: (0, viem_2.getAddress)(gas) === out.token ? out.amount : BigInt(0),
+                        },
+                    });
+                }
+                catch {
+                    // Preserve the actual gateway summary when historical token metadata
+                    // cannot be read; destination polling below still uses the known chain.
+                }
+            }
+            try {
+                const instruction = (0, svm_payload_1.parseAgwSvmPayload)(out.payload);
+                const destinationInstruction = {
+                    program: instruction.program,
+                    accounts: instruction.accounts.map(({ pubkey, isWritable }) => ({
+                        pubkey,
+                        isWritable,
+                    })),
+                    data: (0, viem_1.bytesToHex)(instruction.instructionData),
+                };
+                return adaptAgenticResponse(resp, {
+                    wallet,
+                    door,
+                    rulesId,
+                    chainNamespace: chain,
+                    chain: chain,
+                    route: 'UOA_TO_CEA',
+                    destinationInstruction,
+                    destinationAccount: (0, svm_accounts_1.deriveAgwSvmCea)(wallet, chain_1.CHAIN_INFO[chain].lockerContract ?? '').address,
+                    logical: {
+                        to: instruction.program,
+                        data: destinationInstruction.data,
+                        value: BigInt(0),
+                    },
+                });
+            }
+            catch {
+                // Historical owner calls may use another payload format. Preserve the
+                // actual gateway call below instead of inventing instruction metadata.
+            }
+        }
+        // The decoded wallet call is authoritative: core may have inferred a
+        // Push-only route from an incomplete Cosmos record, which would stop
+        // wait() from polling the destination leg.
+        return adaptAgenticResponse(resp, {
+            wallet,
+            door,
+            rulesId,
+            chainNamespace: chain,
+            logical: outboundResponseCall(out.calls, {
+                to: outbound.target,
+                data: outbound.data,
+                value: outbound.value,
+            }),
+            ...(out.calls.length > 0 ? { destinationCalls: out.calls } : {}),
+            route: 'UOA_TO_CEA',
+            chain: chain ?? resp.chain,
+        });
+    }
+    const single = calls.length === 1 ? calls[0] : undefined;
+    return adaptAgenticResponse(resp, {
+        wallet,
+        door,
+        rulesId,
+        chainNamespace: undefined,
+        logical: single
+            ? { to: single.target, data: single.data, value: single.value }
+            : { to: wallet, data: resp.data, value: BigInt(0) },
+    });
+}
+/** Decode only supported sender-account batches, never an arbitrary forwarding helper. */
+async function adaptNativeAgentBatch(runtime, resp) {
+    let outer;
+    const isUea = resp.data.toLowerCase().startsWith(v6_1.UEA_MULTICALL_PREFIX);
+    try {
+        if (isUea) {
+            const [entries] = (0, viem_2.decodeAbiParameters)([
+                {
+                    type: 'tuple[]',
+                    components: [
+                        { name: 'to', type: 'address' },
+                        { name: 'value', type: 'uint256' },
+                        { name: 'data', type: 'bytes' },
+                    ],
+                },
+            ], `0x${resp.data.slice(10)}`);
+            outer = entries.map((c) => ({
+                target: (0, viem_2.getAddress)(c.to),
+                value: c.value,
+                data: c.data,
+            }));
+        }
+        else {
+            const batch = v6_1.v6.decodeWalletCall(resp.data);
+            if (batch?.kind !== 'execute' || batch.mode !== `0x01${'00'.repeat(31)}`)
+                return;
+            outer = batch.calls;
+        }
+        if (outer.length < 2 ||
+            outer.some((c) => c.value !== BigInt(0) || c.target !== outer[0].target))
+            return;
+        const inner = outer.map((c) => v6_1.v6.decodeWalletCall(c.data));
+        const first = inner[0];
+        if (first?.kind !== 'executeAsAgent' || first.calls.length !== 1)
+            return;
+        const nativeCalls = [];
+        for (const c of inner) {
+            if (c?.kind !== 'executeAsAgent' ||
+                c.calls.length !== 1 ||
+                c.rulesId !== first.rulesId ||
+                c.mode !== `0x${'00'.repeat(32)}`)
+                return;
+            const call = c.calls[0];
+            nativeCalls.push({ to: call.target, value: call.value, data: call.data });
+        }
+        const senderAccount = (0, viem_2.getAddress)(resp.from);
+        if (isUea) {
+            if ((0, viem_2.getAddress)(resp.raw?.to ?? resp.to) !== senderAccount)
+                return;
+            const origin = await (0, account_1.convertExecutorToOrigin)(senderAccount, {
+                _internal: true,
+            });
+            if (!origin.exists)
+                return;
+        }
+        else {
+            if ((0, viem_2.getAddress)(resp.to) !== senderAccount)
+                return;
+            const executor = (0, chain_2.getBatchExecutorAddress)((0, helpers_1.getPushChainForNetwork)(runtime.network));
+            if (!executor)
+                return;
+            const code = await runtime.reader.getCode({
+                address: senderAccount,
+                blockNumber: resp.blockNumber,
+            });
+            if (code?.toLowerCase() !== `0xef0100${executor.slice(2).toLowerCase()}`)
+                return;
+        }
+        const wallet = outer[0].target;
+        const gen = await (0, deployments_1.resolveWalletGeneration)(runtime.reader, runtime.network, wallet);
+        // This recognizer is only for native arrays; keep mixed/outbound batches raw.
+        if (nativeCalls.some((c) => c.to === gen.addresses.gateway))
+            return;
+        return adaptAgenticResponse(resp, {
+            wallet,
+            door: 'agent',
+            rulesId: first.rulesId,
+            chainNamespace: (0, chain_3.pushChainNamespaceFor)(runtime.network),
+            nativeCalls,
+            logical: { ...nativeCalls[0] },
+        });
+    }
+    catch {
+        // Unsupported payload or unverified sender/wallet: preserve the original response.
+        return;
+    }
+}
+/**
+ * Canonical outbound summary for both send and replay: the first actual
+ * destination call. The complete ordered calls live in agentic.destinationCalls.
+ * Identical calldata can come from explicit calls or generated transfers, so
+ * never infer the original input shape from a selector. For an unrecognized
+ * historical payload, retain the actual gateway call instead of inventing one.
+ */
+function outboundResponseCall(calls, fallback) {
+    const first = calls[0];
+    return first
+        ? { to: first.to, data: first.data, value: first.value }
+        : fallback;
+}
+function decodeOutbound(data) {
+    const { args } = (0, viem_2.decodeFunctionData)({ abi: abi_1.UNIVERSAL_GATEWAY_PC, data });
+    const req = args?.[0];
+    let calls = [];
+    if (req.payload.toLowerCase().startsWith(v6_1.UEA_MULTICALL_PREFIX)) {
+        try {
+            const [decodedCalls] = (0, viem_2.decodeAbiParameters)([
+                {
+                    type: 'tuple[]',
+                    components: [
+                        { name: 'to', type: 'address' },
+                        { name: 'value', type: 'uint256' },
+                        { name: 'data', type: 'bytes' },
+                    ],
+                },
+            ], `0x${req.payload.slice(10)}`);
+            calls = decodedCalls.map((c) => ({
+                to: (0, viem_2.getAddress)(c.to),
+                value: c.value,
+                data: c.data,
+            }));
+        }
+        catch {
+            calls = [];
+        }
+    }
+    return {
+        token: (0, viem_2.getAddress)(req.token),
+        payload: req.payload,
+        recipient: req.recipient,
+        amount: req.amount,
+        calls,
+    };
+}
+async function tokenChain(runtime, token) {
+    try {
+        return (await runtime.reader.readContract({
+            address: token,
+            abi: [
+                {
+                    type: 'function',
+                    name: 'SOURCE_CHAIN_NAMESPACE',
+                    inputs: [],
+                    outputs: [{ type: 'string' }],
+                    stateMutability: 'view',
+                },
+            ],
+            functionName: 'SOURCE_CHAIN_NAMESPACE',
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=response.js.map

package/src/lib/agentic/revert.d.ts

@@ -0,0 +1,7 @@
+import { type Hex } from 'viem';
+import type { DecodedErrorPayload } from '../orchestrator/internals/errors';
+/** URP reverts reached through the engine are truncated to this wrapper. */
+export declare const POLICY_CHECK_REVERTED_SELECTOR = "0xf4270752";
+/** Decode raw revert data against the AGW/URP/factory/engine error ABIs. */
+export declare function decodeAgwErrorData(data: Hex): DecodedErrorPayload | undefined;
+export declare function decodeAgenticRevert(err: unknown): DecodedErrorPayload | undefined;

package/src/lib/agentic/revert.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICY_CHECK_REVERTED_SELECTOR = void 0;
+exports.decodeAgwErrorData = decodeAgwErrorData;
+exports.decodeAgenticRevert = decodeAgenticRevert;
+const viem_1 = require("viem");
+const utils_1 = require("viem/utils");
+const v6_1 = require("./contracts/abi/v6");
+/** URP reverts reached through the engine are truncated to this wrapper. */
+exports.POLICY_CHECK_REVERTED_SELECTOR = '0xf4270752';
+const ERROR_ABIS = [
+    v6_1.AGW_ABI,
+    v6_1.UNIVERSAL_RULES_POLICY_ABI,
+    v6_1.AGW_FACTORY_ABI,
+    v6_1.SMART_SESSION_ABI,
+];
+/** selector → error name across the AGW/URP/factory/engine ABIs. */
+const ERROR_NAMES = new Map(ERROR_ABIS.flatMap((abi) => abi
+    .filter((item) => item.type === 'error')
+    .map((item) => {
+    const err = item;
+    return [
+        (0, viem_1.toFunctionSelector)((0, utils_1.formatAbiItem)(err)).toLowerCase(),
+        err.name,
+    ];
+})));
+const HEX_DATA = /0x[0-9a-fA-F]{8,}/g;
+const CUSTOM_ERROR_TEXT = /custom error (0x[0-9a-fA-F]{8}):?\s*([0-9a-fA-F]*)/g;
+/** Pull candidate revert data out of an error (viem chains, nested causes, messages). */
+function revertDataCandidates(err, depth = 0) {
+    if (!err || depth > 6)
+        return [];
+    const out = [];
+    const e = err;
+    if (typeof e.raw === 'string' && /^0x[0-9a-fA-F]{8,}$/.test(e.raw))
+        out.push(e.raw);
+    if (typeof e.data === 'string' && /^0x[0-9a-fA-F]{8,}$/.test(e.data))
+        out.push(e.data);
+    if (e.data &&
+        typeof e.data === 'object' &&
+        typeof e.data.data === 'string') {
+        out.push(e.data.data);
+    }
+    for (const text of [e.message, e.details]) {
+        if (typeof text !== 'string')
+            continue;
+        // viem renders unknown custom errors as "custom error 0x<selector>: <args hex>".
+        for (const m of text.matchAll(CUSTOM_ERROR_TEXT))
+            out.push(`${m[1]}${m[2] ?? ''}`);
+        out.push(...(text.match(HEX_DATA) ?? []));
+    }
+    out.push(...revertDataCandidates(e.cause, depth + 1));
+    return out;
+}
+/** Decode raw revert data against the AGW/URP/factory/engine error ABIs. */
+function decodeAgwErrorData(data) {
+    const selector = data.slice(0, 10).toLowerCase();
+    if (selector === exports.POLICY_CHECK_REVERTED_SELECTOR && data.length >= 10 + 64) {
+        // bytes32 = 4-byte policy error selector ‖ 28 bytes of its first argument.
+        // The arguments are truncated, so the inner error is named by selector only.
+        const word = `0x${data.slice(10, 74)}`;
+        const innerName = ERROR_NAMES.get(word.slice(0, 10).toLowerCase());
+        return {
+            name: innerName
+                ? `PolicyCheckReverted(${innerName})`
+                : 'PolicyCheckReverted',
+            selector,
+            decoded: word,
+            hint: 'URP rejected the action (truncated through the session engine). The inner selector names the gate; arguments are truncated to 28 bytes.',
+        };
+    }
+    for (const abi of ERROR_ABIS) {
+        try {
+            const r = (0, viem_1.decodeErrorResult)({ abi, data });
+            return {
+                name: r.errorName,
+                selector,
+                decoded: r.args && r.args.length ? stringifyArgs(r.args) : undefined,
+            };
+        }
+        catch {
+            // try the next ABI
+        }
+    }
+    // Arguments lost (e.g. a node rendered them as text): name the error by its selector.
+    const name = ERROR_NAMES.get(selector);
+    return name
+        ? { name, selector, hint: 'Error arguments were not available.' }
+        : undefined;
+}
+function decodeAgenticRevert(err) {
+    for (const data of revertDataCandidates(err)) {
+        const decoded = decodeAgwErrorData(data);
+        if (decoded)
+            return decoded;
+    }
+    return undefined;
+}
+function stringifyArgs(args) {
+    return JSON.stringify(args, (_k, v) => typeof v === 'bigint' ? v.toString() : v);
+}
+//# sourceMappingURL=revert.js.map