@pushchain/core 6.0.27-alpha.0 → 6.0.27-alpha.1

package/src/lib/agentic/codec/svm-terms.js

@@ -7,7 +7,7 @@ exports.isForbiddenSvmProgram = isForbiddenSvmProgram;
 exports.validateSvmTerms = validateSvmTerms;
 exports.encodeSvmTerms = encodeSvmTerms;
 exports.decodeSvmTerms = decodeSvmTerms;
-/** Internal v5 SVM wire representation; not a proposed public Rule API. */
+/** Internal v6 SVM wire representation; not a proposed public Rule API. */
 const viem_1 = require("viem");
 const errors_1 = require("../errors");
 const defaults_1 = require("./defaults");
@@ -149,7 +149,11 @@ function validateSvmTerms(t, nowSeconds) {
         if (typeof r.dataless !== 'boolean')
             throw svmInvalid('dataless must be boolean');
         integer(r.discriminatorLen, 8, 'discriminatorLen');
-        integer(r.maxAccounts, exports.SVM_LIMITS.accounts, 'maxAccounts');
+        if (r.maxAccounts !== 255) {
+            integer(r.maxAccounts, exports.SVM_LIMITS.accounts, 'maxAccounts');
+            if (r.maxAccounts === 0)
+                throw svmInvalid('maxAccounts must be 1..64 or 255');
+        }
         if (r.dataless !== (r.discriminatorLen === 0))
             throw svmInvalid('dataless and discriminator length disagree');
         if (isForbiddenSvmProgram(r.program, t))
@@ -177,7 +181,7 @@ function validateSvmTerms(t, nowSeconds) {
         integer(p.accountIndex, exports.SVM_LIMITS.accounts - 1, 'accountIndex');
         exactHex(p.expected, 32, 'pin expected');
         const count = t.programs[p.ruleIndex].maxAccounts;
-        if (count && p.accountIndex >= count)
+        if (count !== 255 && p.accountIndex >= count)
             throw svmInvalid('pin outside fixed account count');
         const key = `${p.ruleIndex}:${p.accountIndex}`;
         if (positions.has(key))

package/src/lib/agentic/codec/universal-terms.d.ts

@@ -1,3 +1,4 @@
+import { type ArgPinWire } from './pins';
 import { type Address, type Hex } from 'viem';
 export interface AssetCapWire {
     token: Address;
@@ -5,6 +6,7 @@ export interface AssetCapWire {
     maxTotal: bigint;
 }
 export interface AllowedCallWire {
+    pins: readonly ArgPinWire[];
     target: Address;
     selector: Hex;
     beneficiaryOffset: number;
@@ -60,6 +62,19 @@ export declare const UNIVERSAL_TERMS_PARAM: {
         }, {
             readonly name: "maxValue";
             readonly type: "uint256";
+        }, {
+            readonly name: "pins";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "offset";
+                readonly type: "uint16";
+            }, {
+                readonly name: "op";
+                readonly type: "uint8";
+            }, {
+                readonly name: "value";
+                readonly type: "bytes32";
+            }];
         }];
     }];
 };

package/src/lib/agentic/codec/universal-terms.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UNIVERSAL_TERMS_PARAM = void 0;
 exports.encodeUniversalTerms = encodeUniversalTerms;
 exports.decodeUniversalTerms = decodeUniversalTerms;
+const pins_1 = require("./pins");
 const viem_1 = require("viem");
 exports.UNIVERSAL_TERMS_PARAM = {
     type: 'tuple',
@@ -28,6 +29,7 @@ exports.UNIVERSAL_TERMS_PARAM = {
                 { name: 'beneficiaryOffset', type: 'uint16' },
                 { name: 'hasBeneficiary', type: 'bool' },
                 { name: 'maxValue', type: 'uint256' },
+                { name: 'pins', type: 'tuple[]', components: pins_1.ARG_PIN_COMPONENTS },
             ],
         },
     ],

package/src/lib/agentic/codec/universal.js

@@ -4,6 +4,7 @@ exports.MAX_ALLOWED_CALLS = exports.MAX_ASSETS = void 0;
 exports.validateUniversalRuleShape = validateUniversalRuleShape;
 exports.encodeUniversalRule = encodeUniversalRule;
 exports.universalTermsToRule = universalTermsToRule;
+const pins_1 = require("./pins");
 const viem_1 = require("viem");
 const capabilities_1 = require("../capabilities");
 const errors_1 = require("../errors");
@@ -11,7 +12,7 @@ const abi_layout_1 = require("./abi-layout");
 const selectors_1 = require("./selectors");
 const defaults_1 = require("./defaults");
 const session_1 = require("./session");
-const v5_1 = require("../contracts/v5");
+const v6_1 = require("../contracts/v6");
 const universal_terms_1 = require("./universal-terms");
 exports.MAX_ASSETS = 8;
 exports.MAX_ALLOWED_CALLS = 32;
@@ -38,7 +39,8 @@ function validateUniversalRuleShape(rule, nowSeconds) {
         rule.allowedCalls.length < 1 ||
         rule.allowedCalls.length > exports.MAX_ALLOWED_CALLS)
         throw invalid(`allowedCalls must contain 1..${exports.MAX_ALLOWED_CALLS} entries`);
-    const seen = new Set();
+    const seen = new Map();
+    let pinCount = 0;
     rule.allowedCalls.forEach((call, i) => {
         if (!(0, viem_1.isAddress)(call.target, { strict: false }))
             throw invalid(`allowedCalls[${i}].target is not an EVM address`);
@@ -55,10 +57,22 @@ function validateUniversalRuleShape(rule, nowSeconds) {
         if (call.beneficiaryOffset !== undefined)
             (0, abi_layout_1.rawOffset)(call.beneficiaryOffset, `allowedCalls[${i}].beneficiary`);
         cap(call.maxValue ?? defaults_1.AGENTIC_DEFAULTS.universal.allowedCallMaxValue.value, `allowedCalls[${i}].maxValue`);
+        try {
+            (0, pins_1.validatePins)(call.pins ?? []);
+        }
+        catch (error) {
+            throw invalid(error.message);
+        }
+        pinCount += call.pins?.length ?? 0;
+        if (pinCount > 32)
+            throw invalid('at most 32 pins across all allowed calls');
         const key = `${call.target.toLowerCase()}:${parsed.selector}`;
-        if (seen.has(key))
-            throw invalid(`allowedCalls[${i}] duplicates an earlier target/selector`);
-        seen.add(key);
+        const restricted = !!call.pins?.length ||
+            call.beneficiary !== undefined ||
+            call.beneficiaryOffset !== undefined;
+        if (seen.has(key) && (!restricted || !seen.get(key)))
+            throw invalid('an unpinned alternative would bypass restrictions for this target/selector');
+        seen.set(key, restricted);
     });
     const tokens = new Set();
     rule.assets.forEach((a, i) => {
@@ -97,6 +111,7 @@ function encodeUniversalRule(rule, ctx) {
         assets: resolved.assets,
         maxGasPerCall: rule.maxGasPerCall,
         allowedCalls: rule.allowedCalls.map((call) => ({
+            pins: call.pins ?? [],
             target: (0, viem_1.getAddress)(call.target),
             selector: (0, selectors_1.parseSelector)(call.selector).selector,
             hasBeneficiary: call.beneficiary !== undefined || call.beneficiaryOffset !== undefined,
@@ -120,7 +135,7 @@ function encodeUniversalRule(rule, ctx) {
             actions: [
                 {
                     target: ctx.gateway,
-                    selector: v5_1.SEND_OUTBOUND_SELECTOR,
+                    selector: v6_1.SEND_OUTBOUND_SELECTOR,
                     initData: (0, session_1.encodeEnvelope)(rule.chainNamespace, (0, universal_terms_1.encodeUniversalTerms)(terms)),
                 },
             ],
@@ -142,6 +157,7 @@ function universalTermsToRule(terms, agent, chainNamespace, tokens) {
             maxTotal: a.maxTotal,
         })),
         allowedCalls: terms.allowedCalls.map((c) => ({
+            pins: [...c.pins],
             target: c.target,
             selector: c.selector,
             maxValue: c.maxValue,

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

@@ -5,6 +5,7 @@ export declare const AGENTIC: Readonly<{
         CATEGORY: Readonly<{
             DEXES: "DEXES";
             LENDING: "LENDING";
+            STAKING: "STAKING";
             PREDICTION: "PREDICTION";
         }>;
     }>;

package/src/lib/agentic/constants.js

@@ -8,6 +8,7 @@ exports.AGENTIC = Object.freeze({
         CATEGORY: Object.freeze({
             DEXES: 'DEXES',
             LENDING: 'LENDING',
+            STAKING: 'STAKING',
             PREDICTION: 'PREDICTION',
         }),
     }),

package/src/lib/agentic/contracts/abi/{v5 → v6}/agent-validator.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AGENT_VALIDATOR_ABI = void 0;
 // GENERATED by packages/core/scripts/agw-local/gen-abi.mjs — do not edit.
 // Source: packages/core/scripts/agw-local/abis/validator.json
-// push-agentic-wallets@2e61e133e641b4e0e1ddbdc9306b0903b60e4dbb
+// push-agentic-wallets@ffd567d3e49b2d27c6f50ad36093274dbac3090f
 // sha256(AgentValidator.json) = a4570ddc373241580de8742cbb3d9f2c837094c65bfd1cdd52243ca0c38196fd
 exports.AGENT_VALIDATOR_ABI = [
     {

package/src/lib/agentic/contracts/abi/{v5 → v6}/agw-factory.d.ts

@@ -70,6 +70,281 @@ export declare const AGW_FACTORY_ABI: readonly [{
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "createWallet";
+    readonly inputs: readonly [{
+        readonly name: "label";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "rules";
+        readonly type: "tuple[]";
+        readonly internalType: "struct Session[]";
+        readonly components: readonly [{
+            readonly name: "sessionValidator";
+            readonly type: "address";
+            readonly internalType: "contract ISessionValidator";
+        }, {
+            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 outputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "rulesIds";
+        readonly type: "bytes32[]";
+        readonly internalType: "bytes32[]";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "createWalletWithSig";
+    readonly inputs: readonly [{
+        readonly name: "intent";
+        readonly type: "tuple";
+        readonly internalType: "struct OwnerIntent";
+        readonly components: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "wallet";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "executor";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint96";
+            readonly internalType: "uint96";
+        }, {
+            readonly name: "sessionHash";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "mode";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "execCalldataHash";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "nonceKey";
+            readonly type: "uint192";
+            readonly internalType: "uint192";
+        }, {
+            readonly name: "nonceSeq";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "grantNonce";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint48";
+            readonly internalType: "uint48";
+        }, {
+            readonly name: "signerChainId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }, {
+        readonly name: "sig";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "label";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "rules";
+        readonly type: "tuple[]";
+        readonly internalType: "struct Session[]";
+        readonly components: readonly [{
+            readonly name: "sessionValidator";
+            readonly type: "address";
+            readonly internalType: "contract ISessionValidator";
+        }, {
+            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 outputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "rulesIds";
+        readonly type: "bytes32[]";
+        readonly internalType: "bytes32[]";
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "defaultAdmin";
@@ -776,6 +1051,22 @@ export declare const AGW_FACTORY_ABI: readonly [{
         readonly type: "uint256";
         readonly internalType: "uint256";
     }];
+}, {
+    readonly type: "error";
+    readonly name: "IntentGrantNonceNotZero";
+    readonly inputs: readonly [{
+        readonly name: "provided";
+        readonly type: "uint64";
+        readonly internalType: "uint64";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "IntentRulesMismatch";
+    readonly inputs: readonly [{
+        readonly name: "actual";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
 }, {
     readonly type: "error";
     readonly name: "IntentWalletMismatch";
@@ -828,6 +1119,14 @@ export declare const AGW_FACTORY_ABI: readonly [{
         readonly type: "uint48";
         readonly internalType: "uint48";
     }];
+}, {
+    readonly type: "error";
+    readonly name: "TooManyInitialRules";
+    readonly inputs: readonly [{
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
 }, {
     readonly type: "error";
     readonly name: "UUPSUnauthorizedCallContext";