ensure from and nonce = 0 for AssignDeposit intentions

Author: dkuthoore

src/proposer.ts

@@ -36,7 +36,7 @@ import {
 	getVaultsForController,
 	updateVaultControllers,
 } from './utils/vaults.js'
-import { PROPOSER_VAULT_ID, SEED_CONFIG } from './config/seedingConfig.js'
+import { SEED_CONFIG } from './config/seedingConfig.js'
 import {
 	validateIntention,
 	validateAddress,
@@ -364,6 +364,7 @@ async function getLatestNonce(): Promise<number> {
  * Retrieves the latest nonce for a specific vault from the database.
  * Returns 0 if no nonce is found for the vault.
  */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function getVaultNonce(vaultId: number | string): Promise<number> {
 	const result = await pool.query('SELECT nonce FROM vaults WHERE vault = $1', [
 		String(vaultId),
@@ -587,7 +588,7 @@ async function saveBundleData(
 				continue
 			}
 
-			// Skip nonce updates if from is 0 (edge case safety)
+			// Skip nonce updates for protocol-level actions (from=0, e.g., AssignDeposit)
 			if (execution.from === 0) {
 				continue
 			}
@@ -921,17 +922,13 @@ async function createAndSubmitSeedingIntention(
 		return
 	}
 
-	const submitterVaultId = PROPOSER_VAULT_ID.value
-	const currentNonce = await getVaultNonce(submitterVaultId)
-	const nextNonce = currentNonce + 1
-
 	// Build token summary for logging
 	const tokenSummary = SEED_CONFIG.map(
 		(token) => `${token.amount} ${token.symbol || token.address}`
 	).join(', ')
 
 	logger.info(
-		`Seeding requested for vault ${newVaultId}: controller=${PROPOSER_ADDRESS}, submitterVaultId=${submitterVaultId}, nonce=${nextNonce}, tokens=[${tokenSummary}]`
+		`Seeding requested for vault ${newVaultId}: controller=${PROPOSER_ADDRESS}, protocol-level AssignDeposit (nonce=0, from=0), tokens=[${tokenSummary}]`
 	)
 
 	const inputs: IntentionInput[] = []
@@ -957,7 +954,7 @@ async function createAndSubmitSeedingIntention(
 
 	const intention: Intention = {
 		action: 'AssignDeposit',
-		nonce: nextNonce,
+		nonce: 0, // Protocol-level action: nonce=0 (protocol vault)
 		expiry: Math.floor(Date.now() / 1000) + 300, // 5 minute expiry
 		inputs,
 		outputs,
@@ -974,7 +971,7 @@ async function createAndSubmitSeedingIntention(
 	await handleIntention(intention, signature, PROPOSER_ADDRESS)
 
 	logger.info(
-		`Successfully submitted AssignDeposit seeding intention for vault ${newVaultId} (nonce: ${nextNonce}, submitter vault: ${submitterVaultId}).`
+		`Successfully submitted AssignDeposit seeding intention for vault ${newVaultId} (protocol-level: nonce=0, from=0).`
 	)
 }
 
@@ -1083,7 +1080,6 @@ async function handleIntention(
 				discoverAndIngestEthDeposits,
 				findDepositWithSufficientRemaining,
 				validateVaultIdOnChain,
-				getVaultsForController,
 				logger,
 				diagnostic,
 			},

src/utils/intentionHandlers/AssignDeposit.ts

@@ -7,11 +7,8 @@
  * - Discovers deposits from on-chain events (ERC20 or ETH)
  * - Selects deposits with sufficient remaining balance
  * - Supports partial deposit assignments (can combine multiple deposits)
- * - Determines submitter vault for nonce tracking:
- *   - If inputs have `from` field: uses that vault ID
- *   - If no `from` field: queries vaults controlled by the controller
- *   - If no vaults found: uses from=0 (no nonce update)
- * - Sets execution.from to the submitter vault ID for proper nonce tracking
+ * - AssignDeposit is a protocol-level action: always sets execution.from = 0 (protocol vault)
+ * - Nonces are not relevant for AssignDeposit; conflicts resolved by bundle inclusion order
  *
  * At publish time, deposits are assigned and balances are credited to destination vaults.
  * If a selected deposit is exhausted, the system automatically falls back to combining
@@ -45,7 +42,6 @@ type AssignDepositContext = {
 		minAmount: string
 	}) => Promise<{ id: number; remaining: string } | null>
 	validateVaultIdOnChain: (vaultId: number) => Promise<void>
-	getVaultsForController: (controller: string) => Promise<string[]>
 	logger: { info: (...args: unknown[]) => void }
 	diagnostic: { info: (...args: unknown[]) => void }
 }
@@ -60,41 +56,9 @@ export async function handleAssignDeposit(params: {
 
 	await context.validateAssignDepositStructure(intention)
 
-	// Determine submitter vault for nonce tracking
-	// 1. If inputs have `from` field, use that (all inputs must have the same `from` value per validator)
-	// 2. If no `from` field, determine from controller by querying vaults
-	let submitterVaultId: number | 0 = 0
-	const inputsWithFrom = intention.inputs.filter(
-		(input) => input.from !== undefined
-	)
-	if (inputsWithFrom.length > 0) {
-		// All inputs should have the same `from` value per validator, but double-check
-		const fromValues = new Set(inputsWithFrom.map((input) => input.from))
-		if (fromValues.size > 1) {
-			throw new Error(
-				'AssignDeposit requires all inputs to have the same `from` vault ID'
-			)
-		}
-		submitterVaultId = inputsWithFrom[0].from as number
-	} else {
-		// No `from` field in inputs, determine from controller
-		const vaults = await context.getVaultsForController(validatedController)
-		if (vaults.length === 1) {
-			submitterVaultId = parseInt(vaults[0])
-		} else if (vaults.length > 1) {
-			// Multiple vaults controlled by this controller - use the first one
-			context.logger.info(
-				`Controller ${validatedController} controls multiple vaults, using first vault ${vaults[0]} for nonce tracking`
-			)
-			submitterVaultId = parseInt(vaults[0])
-		} else {
-			// No vaults found - cannot determine submitter vault, use 0 (no nonce update)
-			context.logger.info(
-				`Controller ${validatedController} does not control any vaults, using from=0 (no nonce update)`
-			)
-			submitterVaultId = 0
-		}
-	}
+	// AssignDeposit is a protocol-level action: always use from=0 (protocol vault)
+	// Nonces are not relevant for AssignDeposit; conflicts resolved by bundle inclusion order
+	const PROTOCOL_VAULT_ID = 0
 
 	const zeroAddress = '0x0000000000000000000000000000000000000000'
 	const proof: unknown[] = []
@@ -156,17 +120,17 @@ export async function handleAssignDeposit(params: {
 	context.diagnostic.info('AssignDeposit intention processed', {
 		controller: validatedController,
 		count: intention.inputs.length,
-		submitterVaultId,
+		protocolVault: PROTOCOL_VAULT_ID,
 	})
 	context.logger.info(
-		`AssignDeposit cached with proof count: ${proof.length}, submitter vault: ${submitterVaultId}`
+		`AssignDeposit cached with proof count: ${proof.length}, protocol-level action (from=0)`
 	)
 
 	return {
 		execution: [
 			{
 				intention,
-				from: submitterVaultId,
+				from: PROTOCOL_VAULT_ID,
 				proof,
 				signature: validatedSignature,
 			},

test/integration/seeding.assignDeposit.test.ts

@@ -271,7 +271,7 @@ describe('AssignDeposit seeding flow (DB)', () => {
 		expect(errorThrown).toBe(true)
 	})
 
-	test('Nonce tracking: AssignDeposit updates submitter vault nonce at publish', async () => {
+	test('Nonce tracking: AssignDeposit does not update vault nonces (protocol-level action)', async () => {
 		// Create deposit
 		await insertDepositIfMissing({
 			tx_hash: TEST_TX,
@@ -290,12 +290,10 @@ describe('AssignDeposit seeding flow (DB)', () => {
 			'SELECT nonce FROM vaults WHERE vault = $1',
 			[String(PROPOSER_VAULT_ID)]
 		)
-		expect(initialNonce.rows[0].nonce).toBe(0)
+		const initialNonceValue = initialNonce.rows[0].nonce
 
-		// Simulate AssignDeposit intention with nonce = currentNonce + 1
-		const intentionNonce = initialNonce.rows[0].nonce + 1
-
-		// Simulate assignment and nonce update at publish
+		// AssignDeposit is protocol-level: intention has nonce=0 and from=0
+		// Simulate assignment (deposit assignment happens, but nonce should not be updated)
 		const deposit = await findNextDepositWithAnyRemaining({
 			depositor: PROPOSER_CONTROLLER,
 			token: TOKEN,
@@ -308,19 +306,16 @@ describe('AssignDeposit seeding flow (DB)', () => {
 			String(NEW_VAULT_ID)
 		)
 
-		// Update nonce (simulating publishBundle behavior)
-		await pool.query('UPDATE vaults SET nonce = $2 WHERE vault = $1', [
-			String(PROPOSER_VAULT_ID),
-			intentionNonce,
-		])
+		// AssignDeposit with from=0 should NOT update any vault nonce
+		// (saveBundleData skips nonce updates when execution.from === 0)
 
-		// Verify nonce was updated
-		const updatedNonce = await pool.query(
+		// Verify nonce was NOT updated (should remain unchanged)
+		const finalNonce = await pool.query(
 			'SELECT nonce FROM vaults WHERE vault = $1',
 			[String(PROPOSER_VAULT_ID)]
 		)
-		expect(updatedNonce.rows[0].nonce).toBe(intentionNonce)
-		expect(updatedNonce.rows[0].nonce).toBe(1)
+		expect(finalNonce.rows[0].nonce).toBe(initialNonceValue)
+		expect(finalNonce.rows[0].nonce).toBe(0)
 	})
 
 	test('findNextDepositWithAnyRemaining: Returns oldest deposit first', async () => {