@mysten-incubation/sui-agent-pass 0.0.0 → 0.1.0

package/deployments/mainnet.json

@@ -0,0 +1,65 @@
+{
+	"network": "mainnet",
+	"grpcUrl": "https://fullnode.mainnet.sui.io:443",
+	"chainIdentifier": "4btiuiMPvEENsttpZC7CZ53DruC3MAgfznDbASZ7DR6S",
+	"packageId": "0x4c9010b0be6022e8a4bd91219d5174edc36d524b42d4790784035f424e01f403",
+	"publishedAt": "0x08d82880b61c531ffbe9eb9eccf3c025d6182ec50f7f61e1f6095a6b81a1f744",
+	"configId": "0xf7b33e20564b26c0685b8d86669345a0121ff6b290911a04f1ff37fcd1f5716d",
+	"siteUrl": "https://sui-agent-pass.vercel.app",
+	"coins": [
+		{
+			"type": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+			"symbol": "SUI",
+			"decimals": 9
+		},
+		{
+			"type": "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+			"symbol": "USDC",
+			"decimals": 6
+		}
+	],
+	"pools": [
+		{
+			"venue": "deepbook",
+			"poolId": "0xe05dafb5133bcffb8d59f4e12465dc0e9faeaa05e3e342a08fe135800e3e4407",
+			"coinA": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+			"coinB": "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC"
+		},
+		{
+			"venue": "cetus",
+			"poolId": "0xb8d7d9e66a60c239e7a60110efcf8de6c705580ed924d0dde141f4a0e2c90105",
+			"coinA": "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+			"coinB": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+		}
+	],
+	"protocols": {
+		"deepbook": {
+			"packageId": "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809",
+			"publishedAt": "0x0e735f8c93a95722efd73521aca7a7652c0bb71ed1daf41b26dfd7d1ff71f748"
+		},
+		"cetus": {
+			"packageId": "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb",
+			"publishedAt": "0x260693ec785a6e6c9d81d58c7d2ff72f1288ae0fa6a9725abe05a6478b11f084",
+			"configId": "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f"
+		},
+		"navi": {
+			"packageId": "0x66c91a8560cd64d73d93dd1ec7b61f3f21ad2f66553dd3d7038ca69255479bb7",
+			"publishedAt": "0x512f28261c1a293f49416d8885b8d5d32bde6dd68a99a0be36fe42b248e6833a",
+			"oraclePackageId": "0xca441b44943c16be0e6e23c5a955bb971537ea3289ae8016fbf33fffe1fd210f",
+			"storageId": "0xbb4e2f4b6205c2e2a2db47aeb4f830796ec7c005f88537ee775986639bc442fe",
+			"oracleId": "0x1568865ed9a0b5ec414220e8f79b3d04c77acc82358f6e5ae4635687392ffbef",
+			"incentiveV2Id": "0xf87a8acb8b81d14307894d12595541a73f19933f88e1326d5be349c7a6f7559c",
+			"incentiveV3Id": "0x62982dad27fb10bb314b3384d5de8d2ac2d72ab2dbeae5d801dbdb9efa816c80",
+			"reserves": {
+				"0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI": {
+					"poolId": "0x96df0fce3c471489f4debaaa762cf960b3d97820bd1f3f025ff8190730e958c5",
+					"assetId": 0
+				},
+				"0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC": {
+					"poolId": "0xa3582097b4c57630046c0c49a88bfc6b202a3ec0a9db5597c31765f7563755a8",
+					"assetId": 10
+				}
+			}
+		}
+	}
+}

package/deployments/testnet.json

@@ -0,0 +1,69 @@
+{
+	"network": "testnet",
+	"grpcUrl": "https://fullnode.testnet.sui.io:443",
+	"chainIdentifier": "69WiPg3DAQiwdxfncX6wYQ2siKwAe6L9BZthQea3JNMD",
+	"packageId": "0xfea0b9f60c752e98e950c1994a3805ba28c5f559e3ea72da2ac3d68b90728b11",
+	"publishedAt": "0xfea0b9f60c752e98e950c1994a3805ba28c5f559e3ea72da2ac3d68b90728b11",
+	"configId": "0x3bb796cd3fe0d9b85b1db972478616e717fe5bdbd1ff864615a3995f4e1c1c60",
+	"coins": [
+		{
+			"type": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+			"symbol": "SUI",
+			"decimals": 9
+		},
+		{
+			"type": "0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa::usdc::USDC",
+			"symbol": "USDC",
+			"decimals": 6
+		}
+	],
+	"pools": [
+		{
+			"venue": "deepbook",
+			"poolId": "0xf95b10ec49e92a4afaa81ff679ebfd8b7e9371984d8c214b26783d9fdfc02a29",
+			"coinA": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+			"coinB": "0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa::usdc::USDC"
+		},
+		{
+			"venue": "cetus",
+			"poolId": "0x3c779cab1582156a06aca223690bcd23f781ff3fbdda99747659ebddc2059e88",
+			"coinA": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+			"coinB": "0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa::usdc::USDC"
+		}
+	],
+	"demoFaucet": {
+		"packageId": "0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa",
+		"faucetId": "0x14d07fd3eff80c868c0bab116cbc2f65c8903c77fcb41721ad6db4ba0c6480cf",
+		"coin": "0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa::usdc::USDC"
+	},
+	"protocols": {
+		"deepbook": {
+			"packageId": "0xfe5ce722543b1e3056aba9f44fd0ac69238c97baae9ac96d0bc1594dfe8ef7b1",
+			"publishedAt": "0xfe5ce722543b1e3056aba9f44fd0ac69238c97baae9ac96d0bc1594dfe8ef7b1"
+		},
+		"cetus": {
+			"packageId": "0x23200a7f55d23555844bca491e5422e495d1a9082f4fb39b868d95440655a8d9",
+			"publishedAt": "0x23200a7f55d23555844bca491e5422e495d1a9082f4fb39b868d95440655a8d9",
+			"configId": "0x9e4115923d7ba4405a9c918a1d517325a9491b7e2eb3f1e469debae3ceb690cd"
+		},
+		"navi": {
+			"packageId": "0xd75f91c29ae9b0597f82ff636940199e5004089d17991fafbabb9a180f51b5f7",
+			"publishedAt": "0xd75f91c29ae9b0597f82ff636940199e5004089d17991fafbabb9a180f51b5f7",
+			"oraclePackageId": "0x9d2c0e390e32e75b2c6be7a33d12319c912caae11874fcf6e1d79ae8b594e9a6",
+			"storageId": "0xc8b3b4882625279ce505b94902a33e4cf0364bd1ee2f52563e66f9a42de7af26",
+			"oracleId": "0xc962d8795540426c4dce1fea621d89f12f00766a6d4b0d00087fde6fefb2d343",
+			"incentiveV2Id": "0x679e3525405bb43ba27b0839dcaae2469d59225856cd6c2e8318a094efe593c5",
+			"incentiveV3Id": "0x9488d70edbfd67babcc72b8eb1f3fbf60dd47f080d830e2af27abcecdd6771c6",
+			"reserves": {
+				"0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI": {
+					"poolId": "0x3bdcd67ca6465324f0977d7912dbfb7a25cad759e03744aa760e0fa5baa31812",
+					"assetId": 0
+				},
+				"0x7ffc375a2bebedcec3753cfe4687f3bb104074eb55b014f8185ccc8ee8bf47fa::usdc::USDC": {
+					"poolId": "0x7f05ed3b912e6e1b573f8d3095cf3c437fb0fcf78d09669c504c66bceb3bf9a3",
+					"assetId": 1
+				}
+			}
+		}
+	}
+}

package/dist/activation.js

@@ -0,0 +1,287 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+/** A wallet callback is a hint, never proof. Confirm the actual chain effects. */
+import { isDeepStrictEqual } from 'node:util';
+import { normalizeStructTag, normalizeSuiAddress, parseStructTag } from '@mysten/sui/utils';
+import { allowanceCoin, appType, assertChain, clientFor, discoverAllowances, readAllowance, readAllowanceCapTarget, readAuthorization, readControl, receiptType, } from './chain.js';
+import { AGENT_GAS_NAME, healthFactorRay, SUI, } from './domain.js';
+/** The policies the reviewed setup should have produced, in the chain reader's shape. */
+export function expectedPolicies(d, p) {
+    const usage = { usedToday: '0', resetsAtMs: 0 };
+    const norm = (t) => normalizeStructTag(t);
+    const byType = (a, b) => a.coinType.localeCompare(b.coinType);
+    return {
+        transfers: p.transfers
+            .map((t) => ({
+            coinType: norm(t.coin),
+            recipients: [...t.recipients]
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((r) => ({ name: r.name, address: r.address })),
+            perTransfer: t.perTransfer,
+            daily: t.daily,
+            usage,
+        }))
+            .sort(byType),
+        swaps: p.swaps
+            .map((s) => ({
+            coinIn: norm(s.coinIn),
+            coinOut: norm(s.coinOut),
+            venues: s.pools,
+            perTrade: s.perTrade,
+            daily: s.daily,
+            minPrice: s.minPrice,
+            usage,
+        }))
+            .sort((a, b) => (a.coinIn + a.coinOut).localeCompare(b.coinIn + b.coinOut)),
+        lending: p.lending
+            .map((l) => {
+            const reserve = d.protocols.navi.reserves[norm(l.coin)];
+            if (!reserve)
+                throw new Error(`NAVI has no reserve for ${l.coin} in this deployment`);
+            return {
+                coinType: norm(l.coin),
+                poolId: reserve.poolId,
+                asset: reserve.assetId,
+                allowBorrow: l.allowBorrow,
+                perAction: l.perAction,
+                daily: l.daily,
+                minHealthFactor: healthFactorRay(l.minHealthFactor),
+                usage,
+            };
+        })
+            .sort(byType),
+        staking: p.staking
+            ? [
+                {
+                    validators: p.staking.validators,
+                    perStake: p.staking.perStake,
+                    daily: p.staking.daily,
+                    usage,
+                },
+            ]
+            : [],
+    };
+}
+/** Zeroes reset times, which depend on when the reader ran, before comparing rules. */
+function rulesOnly(p) {
+    const strip = (x) => ({
+        ...x,
+        usage: { ...x.usage, resetsAtMs: 0 },
+    });
+    return {
+        transfers: p.transfers.map(strip),
+        swaps: p.swaps.map(strip),
+        lending: p.lending.map(strip),
+        staking: p.staking.map(strip),
+    };
+}
+function checkControl(control, d, setup, owner, session) {
+    if (control.owner !== owner ||
+        control.agent !== session ||
+        control.name !== setup.name ||
+        control.agentExpiresMs !== String(setup.expiresMs) ||
+        Number(control.agentExpiresMs) <= control.chainTimeMs)
+        throw new Error('On-chain owner, agent or term does not match the reviewed setup');
+    if (!isDeepStrictEqual(rulesOnly(control.policies), expectedPolicies(d, setup.policy)))
+        throw new Error('On-chain policies do not match the reviewed setup');
+    // The agent's lending runs on the pass's NAVI account; it exists exactly when reviewed.
+    if (setup.policy.lending.length > 0 !== !!control.naviPosition)
+        throw new Error("The pass's NAVI account does not match the reviewed lending rules");
+}
+/** The allowances and revoke caps the authorization created, grouped by coin. */
+function allowanceObjects(objects, owner) {
+    const allowances = {}, caps = [];
+    for (const o of objects) {
+        const coin = allowanceCoin(o.type);
+        if (coin && o.shared)
+            (allowances[coin] ??= []).push(o.id);
+        const tag = parseStructTag(o.type);
+        if (tag.address === normalizeSuiAddress('0x2') &&
+            tag.module === 'allowance' &&
+            tag.name === 'AllowanceCap' &&
+            !o.shared &&
+            o.owner === owner)
+            caps.push(o.id);
+    }
+    return { allowances, caps };
+}
+function checkAllowance(a, expected) {
+    if (!a)
+        throw new Error('Allowance is not on chain');
+    const ok = a.funder === expected.funder &&
+        a.spender === expected.spender &&
+        a.app === (expected.app && normalizeStructTag(expected.app)) &&
+        a.name === expected.name &&
+        a.lifetimeCap === expected.lifetimeCap &&
+        a.expirationMs === String(expected.expirationMs) &&
+        a.startMs === null &&
+        a.currentSpend === '0' &&
+        (expected.dailyLimit === null
+            ? a.rateLimit === null
+            : a.rateLimit?.limit === expected.dailyLimit && a.rateLimit.periodMs === '86400000');
+    if (!ok || Number(a.expirationMs) <= a.chainTimeMs)
+        throw new Error(`On-chain allowance for ${a.coinType} does not match the reviewed setup`);
+}
+/**
+ * Everything the authorization transaction must have created, checked against the setup: one
+ * pass-bound allowance per reviewed coin, the gas allowance, a revoke cap for each, nothing
+ * more, the receipt in the owner's wallet, and the control with exactly the reviewed policies.
+ */
+async function verifySession(store, tx, owner, digest) {
+    const { deployment: d, setup, sessionAddress } = store.state, client = clientFor(d);
+    const raw = allowanceObjects(tx.objects, owner);
+    const views = Object.fromEntries(await Promise.all(Object.entries(raw.allowances).map(async ([coin, ids]) => [
+        coin,
+        await Promise.all(ids.map((id) => readAllowance(client, id, coin))),
+    ])));
+    const capTargets = await Promise.all(raw.caps.map((id) => readAllowanceCapTarget(client, id)));
+    const capFor = (allowanceId) => {
+        const i = capTargets.findIndex((t) => t === allowanceId);
+        if (i < 0)
+            throw new Error(`No revoke cap found for allowance ${allowanceId}`);
+        return raw.caps[i];
+    };
+    const common = { funder: owner, spender: sessionAddress, expirationMs: setup.expiresMs };
+    const app = normalizeStructTag(appType(d));
+    // The gas allowance is the SUI one with no app binding and its fixed name.
+    const gasView = (views[SUI] ?? []).find((v) => v?.name === AGENT_GAS_NAME && v.app === null);
+    if (!gasView)
+        throw new Error('The authorization created no gas allowance');
+    checkAllowance(gasView, {
+        ...common,
+        app: null,
+        name: AGENT_GAS_NAME,
+        lifetimeCap: setup.gasCap,
+        dailyLimit: setup.gasDaily,
+    });
+    const allowances = {};
+    for (const [coin, cap] of Object.entries(setup.allowances)) {
+        const bound = (views[normalizeStructTag(coin)] ?? []).filter((v) => v?.app === app);
+        if (bound.length !== 1 || !bound[0])
+            throw new Error(`Expected exactly one pass-bound ${coin} allowance for this owner`);
+        checkAllowance(bound[0], {
+            ...common,
+            app: appType(d),
+            name: setup.name,
+            dailyLimit: null,
+            lifetimeCap: cap,
+        });
+        allowances[normalizeStructTag(coin)] = {
+            allowance: bound[0].id,
+            revokeCap: capFor(bound[0].id),
+        };
+    }
+    const expectedCount = Object.keys(setup.allowances).length + 1;
+    if (Object.values(views).flat().length !== expectedCount || raw.caps.length !== expectedCount)
+        throw new Error('Authorization created an allowance the reviewed setup did not include');
+    const ids = { allowances, gasAllowance: gasView.id, gasRevokeCap: capFor(gasView.id) };
+    const created = tx.passes.filter((c) => c.owner === owner && c.agent === sessionAddress);
+    if (created.length !== 1)
+        throw new Error('Expected one new pass for this session in the transaction');
+    const { id: passId, receiptId } = created[0];
+    const issued = tx.issued.filter((i) => i.passId === passId);
+    const issuedFor = (coin, cap) => issued.some((i) => i.coinType === normalizeStructTag(coin) &&
+        i.lifetimeCap === cap &&
+        i.expiresMs === String(setup.expiresMs));
+    if (issued.length !== Object.keys(setup.allowances).length ||
+        !Object.entries(setup.allowances).every(([coin, cap]) => issuedFor(coin, cap)))
+        throw new Error('Issued allowances do not match the reviewed setup');
+    // The receipt the pass named must exist, be ours, and sit in the owner's wallet.
+    const receipt = tx.objects.find((o) => o.id === receiptId);
+    if (!receipt || receipt.type !== normalizeStructTag(receiptType(d)) || receipt.owner !== owner)
+        throw new Error('The pass receipt did not reach the owner');
+    const control = await readControl(client, d, passId);
+    checkControl(control, d, setup, owner, sessionAddress);
+    return { passId, receiptId, owner, ...ids, authorizationDigest: digest };
+}
+/**
+ * Whether the chain now holds the rules a session proposed for its pass. Nothing is sent back
+ * from the page, so this reads the pass, its policies and the owner's allowances as they are,
+ * and once they all equal the pending setup the session adopts it: new rules, and the allowance
+ * ids now bound to the pass. Lifetime spend on a kept allowance is whatever it was.
+ */
+export async function applyPendingChange(store) {
+    const { deployment: d, pendingChange: next, active, sessionAddress } = store.state;
+    if (!next || !active)
+        return false;
+    const client = clientFor(d);
+    const control = await readControl(client, d, active.passId);
+    if (control.owner !== active.owner ||
+        control.agent !== sessionAddress ||
+        control.agentExpiresMs !== String(next.expiresMs) ||
+        !isDeepStrictEqual(rulesOnly(control.policies), expectedPolicies(d, next.policy)) ||
+        (next.policy.lending.length > 0 && !control.naviPosition))
+        return false;
+    const found = await discoverAllowances(client, d, { owner: active.owner, agent: sessionAddress });
+    if (!found.gas)
+        return false;
+    const caps = Object.fromEntries(Object.entries(next.allowances).map(([c, cap]) => [normalizeStructTag(c), cap]));
+    const want = Object.keys(caps);
+    if (want.length !== Object.keys(found.allowances).length ||
+        !want.every((c) => c in found.allowances))
+        return false;
+    const fits = (v, cap, daily) => !!v &&
+        v.funder === active.owner &&
+        v.spender === sessionAddress &&
+        v.lifetimeCap === cap &&
+        v.expirationMs === String(next.expiresMs) &&
+        (daily === null ? v.rateLimit === null : v.rateLimit?.limit === daily);
+    for (const coin of want) {
+        const v = await readAllowance(client, found.allowances[coin].allowance, coin);
+        if (!fits(v, next.allowances[coin] ??
+            next.allowances[Object.keys(next.allowances).find((c) => normalizeStructTag(c) === coin)], null) ||
+            v.app !== normalizeStructTag(appType(d)))
+            return false;
+    }
+    const gas = await readAllowance(client, found.gas.allowance, SUI);
+    if (!fits(gas, next.gasCap, next.gasDaily) || gas.app !== null)
+        return false;
+    await store.applyChange(next, {
+        ...active,
+        allowances: found.allowances,
+        gasAllowance: found.gas.allowance,
+        gasRevokeCap: found.gas.revokeCap,
+    });
+    return true;
+}
+export async function activate(store, digest, ownerInput) {
+    const { deployment: d, setup, sessionAddress } = store.state;
+    const owner = normalizeSuiAddress(ownerInput), client = clientFor(d);
+    await assertChain(client, d);
+    const tx = await readAuthorization(client, d, digest);
+    if (tx.sender !== owner)
+        throw new Error('Authorization sender does not match connected wallet');
+    const active = await verifySession(store, tx, owner, digest);
+    assertOnlyReviewedGrants(tx.objects, active);
+    assertExactStipend(tx.balanceChanges, sessionAddress, SUI, setup.gasAmount);
+    await store.activate(active);
+    return active;
+}
+/**
+ * The review page builds the PTB and the wallet signs whatever it was handed, so the transaction
+ * may carry grants the owner never reviewed. Refuse any allowance or revoke cap this session does
+ * not account for.
+ */
+function assertOnlyReviewedGrants(objects, active) {
+    const reviewed = new Set([
+        ...Object.values(active.allowances).flatMap((a) => [a.allowance, a.revokeCap]),
+        active.gasAllowance,
+        active.gasRevokeCap,
+    ]);
+    for (const o of objects) {
+        const tag = parseStructTag(o.type);
+        const isGrant = tag.address === normalizeSuiAddress('0x2') &&
+            tag.module === 'allowance' &&
+            (tag.name === 'Allowance' || tag.name === 'AllowanceCap');
+        if (isGrant && !reviewed.has(o.id))
+            throw new Error('Authorization created an allowance the reviewed setup did not include');
+    }
+}
+/** The session must receive exactly the reviewed gas stipend in SUI and nothing else. */
+function assertExactStipend(changes, session, sui, gasAmount) {
+    const credits = changes.filter((c) => c.address === session);
+    if (credits.length !== 1 ||
+        credits[0].coinType !== normalizeStructTag(sui) ||
+        BigInt(credits[0].amount) !== BigInt(gasAmount))
+        throw new Error('Session address must receive exactly the reviewed gas stipend and nothing else');
+}