rewrite manager

Author: hayes

packages/wallet-sdk/src/auto-approvals/index.ts

@@ -11,12 +11,5 @@ export {
 // Auto-approval system exports
 export { AutoApprovalManager } from './manager.js';
 export type { AutoApprovalAnalysis } from './manager.js';
-export {
-	type AutoApprovalPolicy,
-	type AutoApprovalRuleSet,
-	type AutoApprovalObjectTypeRule,
-	type CoinBalanceRule,
-	type AllBalancesRule,
-	type AutoApprovalPolicySettings,
-	type ObjectPermissions,
-} from './types/index.js';
+
+export * from './schemas/index.js';

packages/wallet-sdk/src/auto-approvals/manager.ts

@@ -1,30 +1,25 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type {
-	AutoApprovalPolicy,
-	AutoApprovalPolicySettings,
-	AutoApprovalState,
-} from './types/index.js';
 import type { Experimental_SuiClientTypes } from '@mysten/sui/experimental';
 import { parse, safeParse } from 'valibot';
-import {
-	AutoApprovalStateSchema,
-	AutoApprovalPolicySchema,
-	AutoApprovalPolicySettingsSchema,
-} from './schemas.js';
 import type { BaseAnalysis } from '../transaction-analyzer/base.js';
 import type { CoinValueAnalysis, TransactionAnalysisIssue } from '../transaction-analyzer/index.js';
+import type { AutoApprovalState } from './schemas/state.js';
+import { AutoApprovalStateSchema } from './schemas/state.js';
+import type { AutoApprovalSettings } from './schemas/policy.js';
+import { AutoApprovalPolicySchema, AutoApprovalSettingsSchema } from './schemas/policy.js';
 
 export interface AutoApprovalManagerOptions {
+	policy: string;
 	state: string | null;
 	network: string;
 	origin: string;
 }
 
 export interface AutoApprovalAnalysis {
 	results: BaseAnalysis & {
-		coinValue: CoinValueAnalysis;
+		usdValue: CoinValueAnalysis;
 		operationType: string | null;
 	};
 	issues: TransactionAnalysisIssue[];
@@ -34,29 +29,31 @@ export class AutoApprovalManager {
 	#state: AutoApprovalState;
 
 	constructor(options: AutoApprovalManagerOptions) {
-		// Initialize or parse existing state with validation
+		let state: AutoApprovalState | null = null;
+
 		if (options.state) {
 			const parseResult = safeParse(AutoApprovalStateSchema, JSON.parse(options.state));
-			if (!parseResult.success) {
-				throw new Error(
-					`Invalid state: ${parseResult.issues.map((i: any) => i.message).join(', ')}`,
-				);
+			if (parseResult.success) {
+				const providedPolicy = parse(AutoApprovalPolicySchema, JSON.parse(options.policy));
+				const currentPolicy = parseResult.output.policy;
+
+				if (JSON.stringify(currentPolicy) === JSON.stringify(providedPolicy)) {
+					state = parseResult.output;
+				}
 			}
-			this.#state = parseResult.output;
-		} else {
-			this.#state = parse(AutoApprovalStateSchema, {
-				version: '1.0.0',
+		}
+
+		this.#state =
+			state ??
+			parse(AutoApprovalStateSchema, {
+				schemaVersion: '1.0.0',
 				origin: options.origin,
 				network: options.network,
-				approvedAt: null,
-				policy: null,
+				policy: parse(AutoApprovalPolicySchema, JSON.parse(options.policy)),
 				settings: null,
-				balanceChanges: {},
 				createdObjects: {},
-				approvedDigests: [],
 				pendingDigests: [],
-			});
-		}
+			} satisfies AutoApprovalState);
 
 		if (this.#state.network !== options.network) {
 			throw new Error(`Network mismatch: expected ${options.network}, got ${this.#state.network}`);
@@ -67,31 +64,19 @@ export class AutoApprovalManager {
 		}
 	}
 
-	/**
-	 * Check if a transaction analysis can be auto-approved based on policy settings
-	 * This is a fast synchronous operation
-	 *
-	 * @param analysis - The transaction analysis result
-	 * @param policy - Policy to check against (defaults to current state)
-	 * @param settings - Settings to check against (defaults to current state)
-	 * @param ruleSetId - Specific ruleset to check (extracted from analysis if not provided)
-	 */
 	canAutoApprove(analysis: AutoApprovalAnalysis): boolean {
 		if (!this.#state.policy || !this.#state.settings) {
 			return false;
 		}
 
-		// Must have policy enabled (approved)
-		if (!this.#state.approvedAt && !this.#state.settings) {
+		if (analysis.issues.length > 0) {
 			return false;
 		}
 
-		// Must not be expired
 		if (new Date() > new Date(this.#state.settings.expiration)) {
 			return false;
 		}
 
-		// Must have remaining transactions
 		if (
 			this.#state.settings.remainingTransactions !== null &&
 			this.#state.settings.remainingTransactions <= 0
@@ -101,7 +86,7 @@ export class AutoApprovalManager {
 
 		if (
 			!analysis.results.operationType ||
-			!this.#state.settings.approvedRuleSets.includes(analysis.results.operationType)
+			!this.#state.settings.approvedOperations.includes(analysis.results.operationType)
 		) {
 			return false;
 		}
@@ -110,147 +95,111 @@ export class AutoApprovalManager {
 			return false;
 		}
 
-		// All checks passed
+		// TODO: analyze balances and budgets
+
 		return true;
 	}
 
-	commitTransaction(analysis: BaseAnalysis): void {
-		// Update remaining transactions
+	commitTransaction(analysis: AutoApprovalAnalysis): void {
 		if (this.#state.settings?.remainingTransactions !== null && this.#state.settings) {
 			this.#state.settings.remainingTransactions = Math.max(
 				0,
 				this.#state.settings.remainingTransactions - 1,
 			);
 		}
 
-		// Track balance changes
-		for (const outflow of analysis.coinFlows) {
-			const existing = this.#state.balanceChanges[outflow.coinType];
-			const currentBalance = existing ? BigInt(existing.balanceChange) : 0n;
-			const newBalance = currentBalance - outflow.amount;
-
-			this.#state.balanceChanges[outflow.coinType] = {
-				balanceChange: newBalance.toString(),
-				lastUpdated: new Date().toISOString(),
-			};
+		for (const outflow of analysis.results.coinFlows) {
+			const currentBudget = BigInt(this.#state.settings?.coinBudgets[outflow.coinType] ?? '0');
+			const newBalance = currentBudget - outflow.amount;
+
+			if (this.#state.settings) {
+				this.#state.settings.coinBudgets[outflow.coinType] = newBalance.toString();
+			}
 		}
 
-		// Add to pending digests
-		if (analysis.digest) {
-			this.#state.pendingDigests.push(analysis.digest);
+		// TODO: track USD budget
+
+		this.#state.pendingDigests.push(analysis.results.digest);
+	}
+
+	revertTransaction(analysis: AutoApprovalAnalysis): void {
+		this.#removePendingDigest(analysis.results.digest);
+
+		if (this.#state.settings?.remainingTransactions !== null && this.#state.settings) {
+			this.#state.settings.remainingTransactions += 1;
 		}
+
+		this.#revertCoinFlows(analysis.results);
 	}
 
-	applyTransactionEffects(effects: Experimental_SuiClientTypes.TransactionEffects): void {
-		const digest = effects.transactionDigest;
+	#revertCoinFlows(analysis: BaseAnalysis): void {
+		for (const outflow of analysis.coinFlows) {
+			const currentBudget = BigInt(this.#state.settings?.coinBudgets[outflow.coinType] ?? '0');
+			const newBalance = currentBudget + outflow.amount;
 
-		// Move from pending to approved
+			if (this.#state.settings) {
+				this.#state.settings.coinBudgets[outflow.coinType] = newBalance.toString();
+			}
+		}
+
+		// TODO: revert USD budget
+	}
+
+	#removePendingDigest(digest: string): void {
 		const pendingIndex = this.#state.pendingDigests.indexOf(digest);
 		if (pendingIndex >= 0) {
 			this.#state.pendingDigests.splice(pendingIndex, 1);
-			this.#state.approvedDigests.push(digest);
+		} else {
+			throw new Error(`Transaction with digest ${digest} not found in pending digests`);
 		}
+	}
 
-		// Track created objects from changed objects
-		for (const changed of effects.changedObjects) {
+	applyTransactionEffects(
+		analysis: AutoApprovalAnalysis,
+		result: Experimental_SuiClientTypes.TransactionResponse,
+	): void {
+		this.#removePendingDigest(result.digest);
+
+		for (const changed of result.effects.changedObjects) {
 			if (changed.idOperation === 'Created' && changed.outputState === 'ObjectWrite') {
 				this.#state.createdObjects[changed.id] = {
 					objectId: changed.id,
 					version: changed.outputVersion!,
 					digest: changed.outputDigest!,
-					objectType: 'unknown', // Would need object type lookup
+					objectType: analysis.results.objectsById.get(changed.id)?.type || 'unknown',
 				};
 			}
 		}
-	}
 
-	detectChange(newPolicy: AutoApprovalPolicy): boolean {
-		if (!this.#state.policy) {
-			return true;
-		}
-
-		// Normalize both policies through validation to ensure consistent comparison
-		try {
-			const normalizedCurrent = parse(AutoApprovalPolicySchema, this.#state.policy);
-			const normalizedNew = parse(AutoApprovalPolicySchema, newPolicy);
-
-			const currentHash = JSON.stringify(normalizedCurrent);
-			const newHash = JSON.stringify(normalizedNew);
-			return currentHash !== newHash;
-		} catch (error) {
-			// If validation fails, assume change is needed
-			return true;
-		}
-	}
-
-	update(policy: AutoApprovalPolicy, settings: AutoApprovalPolicySettings) {
-		// Validate policy and settings
-		const validatedPolicy = parse(AutoApprovalPolicySchema, policy);
-		const validatedSettings = parse(AutoApprovalPolicySettingsSchema, settings);
-
-		this.reset();
-		this.#state.policy = validatedPolicy;
-		this.#state.settings = validatedSettings;
-	}
-
-	approve() {
-		if (!this.#state.policy) {
-			throw new Error('No policy to approve');
+		// Revert coin flows and use real balance changes instead
+		this.#revertCoinFlows(analysis.results);
+		for (const change of result.balanceChanges) {
+			const currentBudget = BigInt(this.#state.settings?.coinBudgets[change.coinType] ?? '0');
+			const newBalance = currentBudget + BigInt(change.amount);
+			if (this.#state.settings) {
+				this.#state.settings.coinBudgets[change.coinType] = newBalance.toString();
+			}
 		}
 
-		if (!this.#state.settings) {
-			throw new Error('Policy settings have not been set');
-		}
-		const timestamp = new Date().toISOString();
-		this.#state.approvedAt = timestamp;
+		// TODO: track USD budget
 	}
 
 	reset() {
-		this.#state.approvedAt = null;
-		this.#state.balanceChanges = {};
+		this.#state.settings = null;
 		this.#state.createdObjects = {};
-		this.#state.approvedDigests = [];
 		this.#state.pendingDigests = [];
 	}
 
-	applySettings(settings: AutoApprovalPolicySettings) {
-		const validatedSettings = parse(AutoApprovalPolicySettingsSchema, settings);
-		this.#state.settings = validatedSettings;
-	}
-
 	export(): string {
-		// Validate state before exporting
-		const validatedState = parse(AutoApprovalStateSchema, this.#state);
-		return JSON.stringify(validatedState);
-	}
-
-	serialize(): string {
-		return this.export();
-	}
-
-	hasPolicy(): boolean {
-		return this.#state.policy !== null;
-	}
-
-	isPolicyEnabled(): boolean {
-		return this.#state.approvedAt !== null;
+		return JSON.stringify(parse(AutoApprovalStateSchema, this.#state));
 	}
 
-	getCurrentSettings(): AutoApprovalPolicySettings | null {
+	getSettings(): AutoApprovalSettings | null {
 		return this.#state.settings;
 	}
 
-	createPolicy(policy: AutoApprovalPolicy, settings: AutoApprovalPolicySettings): void {
-		this.update(policy, settings);
-	}
-
-	updateSettings(settings: AutoApprovalPolicySettings): void {
-		this.applySettings(settings);
-	}
-
-	clearPolicy(): void {
-		this.#state.policy = null;
-		this.#state.settings = null;
-		this.reset();
+	updateSettings(settings: AutoApprovalSettings): void {
+		const validatedSettings = parse(AutoApprovalSettingsSchema, settings);
+		this.#state.settings = validatedSettings;
 	}
 }