@pushchain/core 6.0.27-alpha.3 → 6.0.27-alpha.4

package/src/lib/market/contracts/UniversalMarketplaceRules.d.ts

@@ -0,0 +1,241 @@
+export declare const MARKET_RULES_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "checkRulesMatchCard";
+    readonly inputs: readonly [{
+        readonly name: "cardRules";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "session";
+        readonly type: "tuple";
+        readonly internalType: "struct Session";
+        readonly components: readonly [{
+            readonly name: "sessionValidator";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sessionValidatorInitData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "salt";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "userOpPolicies";
+            readonly type: "tuple[]";
+            readonly internalType: "struct PolicyData[]";
+            readonly components: readonly [{
+                readonly name: "policy";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "initData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "erc7739Policies";
+            readonly type: "tuple";
+            readonly internalType: "struct ERC7739Data";
+            readonly components: readonly [{
+                readonly name: "allowedERC7739Content";
+                readonly type: "tuple[]";
+                readonly internalType: "struct ERC7739Context[]";
+                readonly components: readonly [{
+                    readonly name: "appDomainSeparator";
+                    readonly type: "bytes32";
+                    readonly internalType: "bytes32";
+                }, {
+                    readonly name: "contentNames";
+                    readonly type: "string[]";
+                    readonly internalType: "string[]";
+                }];
+            }, {
+                readonly name: "erc1271Policies";
+                readonly type: "tuple[]";
+                readonly internalType: "struct PolicyData[]";
+                readonly components: readonly [{
+                    readonly name: "policy";
+                    readonly type: "address";
+                    readonly internalType: "address";
+                }, {
+                    readonly name: "initData";
+                    readonly type: "bytes";
+                    readonly internalType: "bytes";
+                }];
+            }];
+        }, {
+            readonly name: "actions";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ActionData[]";
+            readonly components: readonly [{
+                readonly name: "actionTargetSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "actionTarget";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "actionPolicies";
+                readonly type: "tuple[]";
+                readonly internalType: "struct PolicyData[]";
+                readonly components: readonly [{
+                    readonly name: "policy";
+                    readonly type: "address";
+                    readonly internalType: "address";
+                }, {
+                    readonly name: "initData";
+                    readonly type: "bytes";
+                    readonly internalType: "bytes";
+                }];
+            }];
+        }, {
+            readonly name: "permitERC4337Paymaster";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }, {
+        readonly name: "ctx";
+        readonly type: "tuple";
+        readonly internalType: "struct SessionContext";
+        readonly components: readonly [{
+            readonly name: "agent";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "chainHash";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "principal";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "expiredAt";
+            readonly type: "uint48";
+            readonly internalType: "uint48";
+        }, {
+            readonly name: "expectedCEA";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "validateAgentCardRules";
+    readonly inputs: readonly [{
+        readonly name: "rules";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokens";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "error";
+    readonly name: "ActionCount";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ActionsMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AgentMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AssetCountMismatch";
+    readonly inputs: readonly [{
+        readonly name: "expected";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "actual";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "AssetMismatch";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ChainMismatch";
+    readonly inputs: readonly [{
+        readonly name: "i";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "EnvelopeVersionMismatch";
+    readonly inputs: readonly [{
+        readonly name: "actual";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ExpectedCEAMismatch";
+    readonly inputs: readonly [{
+        readonly name: "expected";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "actual";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ExpiryMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "GasCapMismatch";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidAgentCard";
+    readonly inputs: readonly [{
+        readonly name: "reason";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "PinMismatch";
+    readonly inputs: readonly [{
+        readonly name: "call";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "pin";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "PolicyShape";
+    readonly inputs: readonly [{
+        readonly name: "i";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "PrincipalCapMismatch";
+    readonly inputs: readonly [];
+}];

package/src/lib/market/contracts/UniversalMarketplaceRules.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKET_RULES_ABI = void 0;
+// Generated from sdk-iteration-v1@443b4e2; Donut marketplace v2.
+exports.MARKET_RULES_ABI = [
+    {
+        type: 'function',
+        name: 'checkRulesMatchCard',
+        inputs: [
+            {
+                name: 'cardRules',
+                type: 'bytes',
+                internalType: 'bytes',
+            },
+            {
+                name: 'session',
+                type: 'tuple',
+                internalType: 'struct Session',
+                components: [
+                    {
+                        name: 'sessionValidator',
+                        type: 'address',
+                        internalType: 'address',
+                    },
+                    {
+                        name: 'sessionValidatorInitData',
+                        type: 'bytes',
+                        internalType: 'bytes',
+                    },
+                    {
+                        name: 'salt',
+                        type: 'bytes32',
+                        internalType: 'bytes32',
+                    },
+                    {
+                        name: 'userOpPolicies',
+                        type: 'tuple[]',
+                        internalType: 'struct PolicyData[]',
+                        components: [
+                            {
+                                name: 'policy',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            {
+                                name: 'initData',
+                                type: 'bytes',
+                                internalType: 'bytes',
+                            },
+                        ],
+                    },
+                    {
+                        name: 'erc7739Policies',
+                        type: 'tuple',
+                        internalType: 'struct ERC7739Data',
+                        components: [
+                            {
+                                name: 'allowedERC7739Content',
+                                type: 'tuple[]',
+                                internalType: 'struct ERC7739Context[]',
+                                components: [
+                                    {
+                                        name: 'appDomainSeparator',
+                                        type: 'bytes32',
+                                        internalType: 'bytes32',
+                                    },
+                                    {
+                                        name: 'contentNames',
+                                        type: 'string[]',
+                                        internalType: 'string[]',
+                                    },
+                                ],
+                            },
+                            {
+                                name: 'erc1271Policies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'actions',
+                        type: 'tuple[]',
+                        internalType: 'struct ActionData[]',
+                        components: [
+                            {
+                                name: 'actionTargetSelector',
+                                type: 'bytes4',
+                                internalType: 'bytes4',
+                            },
+                            {
+                                name: 'actionTarget',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            {
+                                name: 'actionPolicies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'permitERC4337Paymaster',
+                        type: 'bool',
+                        internalType: 'bool',
+                    },
+                ],
+            },
+            {
+                name: 'ctx',
+                type: 'tuple',
+                internalType: 'struct SessionContext',
+                components: [
+                    {
+                        name: 'agent',
+                        type: 'address',
+                        internalType: 'address',
+                    },
+                    {
+                        name: 'chainHash',
+                        type: 'bytes32',
+                        internalType: 'bytes32',
+                    },
+                    {
+                        name: 'principal',
+                        type: 'uint256',
+                        internalType: 'uint256',
+                    },
+                    {
+                        name: 'expiredAt',
+                        type: 'uint48',
+                        internalType: 'uint48',
+                    },
+                    {
+                        name: 'expectedCEA',
+                        type: 'address',
+                        internalType: 'address',
+                    },
+                ],
+            },
+        ],
+        outputs: [],
+        stateMutability: 'pure',
+    },
+    {
+        type: 'function',
+        name: 'validateAgentCardRules',
+        inputs: [
+            {
+                name: 'rules',
+                type: 'bytes',
+                internalType: 'bytes',
+            },
+        ],
+        outputs: [
+            {
+                name: 'tokens',
+                type: 'address[]',
+                internalType: 'address[]',
+            },
+        ],
+        stateMutability: 'pure',
+    },
+    {
+        type: 'error',
+        name: 'ActionCount',
+        inputs: [],
+    },
+    {
+        type: 'error',
+        name: 'ActionsMismatch',
+        inputs: [],
+    },
+    {
+        type: 'error',
+        name: 'AgentMismatch',
+        inputs: [],
+    },
+    {
+        type: 'error',
+        name: 'AssetCountMismatch',
+        inputs: [
+            {
+                name: 'expected',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+            {
+                name: 'actual',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'AssetMismatch',
+        inputs: [
+            {
+                name: 'index',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'ChainMismatch',
+        inputs: [
+            {
+                name: 'i',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'EnvelopeVersionMismatch',
+        inputs: [
+            {
+                name: 'actual',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'ExpectedCEAMismatch',
+        inputs: [
+            {
+                name: 'expected',
+                type: 'address',
+                internalType: 'address',
+            },
+            {
+                name: 'actual',
+                type: 'address',
+                internalType: 'address',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'ExpiryMismatch',
+        inputs: [],
+    },
+    {
+        type: 'error',
+        name: 'GasCapMismatch',
+        inputs: [],
+    },
+    {
+        type: 'error',
+        name: 'InvalidAgentCard',
+        inputs: [
+            {
+                name: 'reason',
+                type: 'string',
+                internalType: 'string',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'PinMismatch',
+        inputs: [
+            {
+                name: 'call',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+            {
+                name: 'pin',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'PolicyShape',
+        inputs: [
+            {
+                name: 'i',
+                type: 'uint256',
+                internalType: 'uint256',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'PrincipalCapMismatch',
+        inputs: [],
+    },
+];
+//# sourceMappingURL=UniversalMarketplaceRules.js.map

package/src/lib/market/data.d.ts

@@ -0,0 +1,8 @@
+import { type Abi, type Hex } from 'viem';
+/** Copy public data before awaiting RPCs or a wallet; BigInts and array order are retained. */
+export declare function copyData<T>(value: T): T;
+export declare function fingerprint(value: unknown): string;
+/** Locate canonical ABI calls inside ordinary, UEA, AGW or multisig transaction inputs.
+ * Candidates are data, not proof of execution: callers must bind them to authenticated receipt events.
+ */
+export declare function embeddedCalls(input: Hex, abi: Abi, name: string): readonly unknown[][];

package/src/lib/market/data.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyData = copyData;
+exports.fingerprint = fingerprint;
+exports.embeddedCalls = embeddedCalls;
+const viem_1 = require("viem");
+/** Copy public data before awaiting RPCs or a wallet; BigInts and array order are retained. */
+function copyData(value) {
+    if (Array.isArray(value))
+        return value.map(copyData);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, copyData(v)]));
+    return value;
+}
+function fingerprint(value) {
+    const sorted = (v) => Array.isArray(v)
+        ? v.map(sorted)
+        : v && typeof v === 'object'
+            ? Object.fromEntries(Object.entries(v)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, x]) => [k, sorted(x)]))
+            : typeof v === 'bigint'
+                ? `${v}n`
+                : v;
+    return JSON.stringify(sorted(value));
+}
+/** Locate canonical ABI calls inside ordinary, UEA, AGW or multisig transaction inputs.
+ * Candidates are data, not proof of execution: callers must bind them to authenticated receipt events.
+ */
+function embeddedCalls(input, abi, name) {
+    const item = (0, viem_1.getAbiItem)({ abi, name });
+    if (!item || item.type !== 'function')
+        return [];
+    const selector = (0, viem_1.toFunctionSelector)(item).slice(2).toLowerCase();
+    const hex = input.toLowerCase();
+    const calls = [];
+    let offset = 2;
+    while ((offset = hex.indexOf(selector, offset)) !== -1) {
+        const at = offset;
+        offset += 2;
+        if (at % 2 !== 0)
+            continue;
+        try {
+            const data = ('0x' + input.slice(at));
+            const decoded = (0, viem_1.decodeFunctionData)({ abi: [item], data });
+            const encoded = (0, viem_1.encodeFunctionData)({
+                abi: [item],
+                functionName: name,
+                args: decoded.args,
+            });
+            if (data.slice(0, encoded.length).toLowerCase() === encoded.toLowerCase())
+                calls.push([...(decoded.args ?? [])]);
+        }
+        catch {
+            /* A selector-shaped value inside unrelated calldata is not a candidate. */
+        }
+    }
+    return calls;
+}
+//# sourceMappingURL=data.js.map

package/src/lib/market/deployment.d.ts

@@ -0,0 +1,14 @@
+import { PUSH_NETWORK } from '../constants/enums';
+export declare const DONUT_MARKETPLACE: Readonly<{
+    readonly sourceCommit: "443b4e2dd9ca5dd9ffc8efebdfcecd619dd66c47";
+    readonly version: "2.0.0";
+    readonly startBlock: bigint;
+    readonly marketplace: "0x9071ebE01B75123A91e88eB6ec4BF163F3fE9BF4";
+    readonly kernel: "0x977cf1AC973E9eC4332791d531507575006157Ed";
+    readonly hook: "0xDe7A94e510b6C571DE7880d441349689F73A32b3";
+    readonly rules: "0x5b98A8E0df5b918DF76cD2BE84bA7995B39dfd44";
+    readonly evaluator: "0x1afC81396f1bb36F91f74506284952b81e4bd47c";
+    readonly paymentToken: "0x7A58048036206bB898008b5bBDA85697DB1e5d66";
+}>;
+export type MarketDeployment = Omit<typeof DONUT_MARKETPLACE, 'marketplace' | 'kernel' | 'hook' | 'rules' | 'evaluator' | 'paymentToken'> & Record<'marketplace' | 'kernel' | 'hook' | 'rules' | 'evaluator' | 'paymentToken', `0x${string}`>;
+export declare function marketplaceDeployment(network: PUSH_NETWORK): MarketDeployment;

package/src/lib/market/deployment.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DONUT_MARKETPLACE = void 0;
+exports.marketplaceDeployment = marketplaceDeployment;
+const enums_1 = require("../constants/enums");
+const errors_1 = require("./errors");
+exports.DONUT_MARKETPLACE = Object.freeze({
+    sourceCommit: '443b4e2dd9ca5dd9ffc8efebdfcecd619dd66c47',
+    version: '2.0.0',
+    startBlock: BigInt(24443653),
+    marketplace: '0x9071ebE01B75123A91e88eB6ec4BF163F3fE9BF4',
+    kernel: '0x977cf1AC973E9eC4332791d531507575006157Ed',
+    hook: '0xDe7A94e510b6C571DE7880d441349689F73A32b3',
+    rules: '0x5b98A8E0df5b918DF76cD2BE84bA7995B39dfd44',
+    evaluator: '0x1afC81396f1bb36F91f74506284952b81e4bd47c',
+    paymentToken: '0x7A58048036206bB898008b5bBDA85697DB1e5d66',
+});
+function marketplaceDeployment(network) {
+    if (network !== enums_1.PUSH_NETWORK.TESTNET_DONUT)
+        (0, errors_1.unavailable)('Marketplace on this Push network');
+    return exports.DONUT_MARKETPLACE;
+}
+//# sourceMappingURL=deployment.js.map