@debridge-finance/borderless-validation-sdk 0.3.1 → 0.4.1

package/dist/esm/validations/intent-tokens.js

@@ -1,5 +1,6 @@
 import { ViolationCode, ChainEngine, } from "../types/index.js";
-import { detectChainEngine, getChainEngine, isNativeToken, normalizeAddress, } from "../helpers/address.js";
+import { getRequestTradeIndex, } from "./trade-grouping.js";
+import { getChainEngine, isNativeToken, isAddressRepresentationValidForChain, getAddressIdentityKey, } from "../helpers/address.js";
 import { resolveWrappedTokenAddress } from "../helpers/evm-token.js";
 import { resolveChainId } from "../whitelists/subscription-to-chain-id.js";
 import { SPL_NATIVE_MINT } from "../whitelists/solana/programs.js";
@@ -11,6 +12,7 @@ export function validateIntentTokens(ctx, basePath) {
         ...resolution.violations,
         ...validateInputTokens(intent.inputToken, ctx, resolution.expected, `${basePath}.inputToken`),
         ...validateGiveTokens(ctx, `${basePath}.giveToken`),
+        ...validateTakeTokenZeroMode(ctx, `${basePath}.takeToken`),
         ...validateTakeTokens(ctx, `${basePath}.takeToken`),
     ];
 }
@@ -21,7 +23,7 @@ export function validateIntentTokens(ctx, basePath) {
 // so the caller knows which trade is unverifiable.
 function resolveIntentInputTokens(ctx) {
     const group = ctx.tradeGroup;
-    const expected = new Set();
+    const expected = new Map();
     const violations = [];
     for (let i = 0; i < ctx.intentTrades.length; i++) {
         const trade = ctx.intentTrades[i];
@@ -31,12 +33,27 @@ function resolveIntentInputTokens(ctx) {
                 code: ViolationCode.IntentInputTokenWrappedAddressUnknown,
                 message: "cannot resolve wrapped token address: native token on a"
                     + " chain with no WETH mapping in the whitelist",
-                path: `request.trades[${group.tradeIndices[ctx.intentTradeIndices[i]]}].srcChainTokenIn`,
+                path: `request.trades[${getRequestTradeIndex(ctx, i)}].srcChainTokenIn`,
                 actual: trade.srcChainTokenIn,
             });
             continue;
         }
-        expected.add(normalizeAddress(group.realChainId, resolved));
+        const tokenKey = getAddressIdentityKey(group.realChainId, resolved);
+        if (tokenKey === undefined) {
+            violations.push({
+                code: ViolationCode.RequestTradeAddressInvalid,
+                message: "request.trades[].srcChainTokenIn is not a valid address"
+                    + " for srcChainId",
+                path: `request.trades[${getRequestTradeIndex(ctx, i)}].srcChainTokenIn`,
+                expected: {
+                    srcChainId: trade.srcChainId,
+                    realChainId: group.realChainId,
+                },
+                actual: trade.srcChainTokenIn,
+            });
+            continue;
+        }
+        expected.set(tokenKey, resolved);
     }
     return { expected, violations };
 }
@@ -48,11 +65,21 @@ function validateInputTokens(inputTokens, ctx, expectedTokens, basePath) {
     const group = ctx.tradeGroup;
     const actual = inputTokens ?? [];
     const violations = [];
-    const actualAddresses = actual.map(t => normalizeAddress(group.realChainId, t.address));
     const firstOccurrence = new Map();
-    for (let i = 0; i < actualAddresses.length; i++) {
-        const address = actualAddresses[i];
-        const earlier = firstOccurrence.get(address);
+    for (let i = 0; i < actual.length; i++) {
+        const addressKey = getAddressIdentityKey(group.realChainId, actual[i].address);
+        if (addressKey === undefined) {
+            violations.push({
+                code: ViolationCode.IntentInputTokenAddressMismatch,
+                message: "intent.inputToken[].address is not a valid address for"
+                    + " the intent source chain",
+                path: `${basePath}[${i}].address`,
+                expected: Array.from(expectedTokens.values()),
+                actual: actual[i].address,
+            });
+            continue;
+        }
+        const earlier = firstOccurrence.get(addressKey);
         if (earlier !== undefined) {
             violations.push({
                 code: ViolationCode.IntentInputTokenDuplicate,
@@ -60,38 +87,38 @@ function validateInputTokens(inputTokens, ctx, expectedTokens, basePath) {
                     + `${earlier} — each srcChainTokenIn (or its wrapped `
                     + `equivalent) must appear once`,
                 path: `${basePath}[${i}].address`,
-                actual: address,
+                actual: actual[i].address,
             });
         }
         else {
-            firstOccurrence.set(address, i);
+            firstOccurrence.set(addressKey, i);
         }
     }
-    for (const expectedToken of expectedTokens) {
-        if (!firstOccurrence.has(expectedToken)) {
+    for (const [expectedKey, expectedAddress] of expectedTokens) {
+        if (!firstOccurrence.has(expectedKey)) {
             violations.push({
                 code: ViolationCode.IntentInputTokenMissing,
                 message: "an expected srcChainTokenIn address (or its wrapped "
                     + "equivalent) is missing from intent.inputToken[]",
                 path: basePath,
-                expected: expectedToken,
+                expected: expectedAddress,
             });
         }
     }
     // Validate each unique entry (duplicates were already reported above)
-    for (const [address, i] of firstOccurrence) {
-        if (!expectedTokens.has(address)) {
+    for (const [addressKey, i] of firstOccurrence) {
+        if (!expectedTokens.has(addressKey)) {
             violations.push({
                 code: ViolationCode.IntentInputTokenAddressMismatch,
                 message: "intent.inputToken[].address does not match any request"
                     + " srcChainTokenIn (including native-to-wrapped resolution)",
                 path: `${basePath}[${i}].address`,
-                expected: Array.from(expectedTokens),
-                actual: address,
+                expected: Array.from(expectedTokens.values()),
+                actual: actual[i].address,
             });
             continue;
         }
-        violations.push(...validateConstraintBudget(actual[i], ctx, address, `${basePath}[${i}]`));
+        violations.push(...validateConstraintBudget(actual[i], ctx, addressKey, `${basePath}[${i}]`));
     }
     return violations;
 }
@@ -105,7 +132,7 @@ function validateInputTokens(inputTokens, ctx, expectedTokens, basePath) {
 //
 // Sanity bounds on `response.srcChainTokenIn.amount` itself live in
 // `validateTrades`.
-function validateConstraintBudget(inputToken, ctx, normalizedAddress, basePath) {
+function validateConstraintBudget(inputToken, ctx, addressKey, basePath) {
     // MEDIUM: exact per-intent trade subset is unverifiable for partial quote
     // groups because the public response strips the hidden grouping keys.
     if (ctx.quoteTradeSubsetUnverifiable)
@@ -116,10 +143,11 @@ function validateConstraintBudget(inputToken, ctx, normalizedAddress, basePath)
         .filter(({ trade }) => {
         const resolved = resolveWrappedTokenAddress(trade.srcChainTokenIn, realChainId);
         // Safe skip: unresolved input tokens are already reported by
-        // `resolveGroupInputTokens`.
+        // `resolveIntentInputTokens`.
         if (resolved === undefined)
             return false;
-        return normalizeAddress(realChainId, resolved) === normalizedAddress;
+        const tradeTokenKey = getAddressIdentityKey(realChainId, resolved);
+        return tradeTokenKey !== undefined && tradeTokenKey === addressKey;
     });
     // Safe skip: missing response trade at a contributing index is reported
     // by `validateTrades` as `TradeCountMismatch`; computing a partial sum here
@@ -189,32 +217,29 @@ function validateGiveTokens(ctx, basePath) {
         return [];
     }
     const violations = [];
-    const expectedFormat = getChainEngine(group.realChainId);
+    const expectedEngine = getChainEngine(group.realChainId);
     for (let i = 0; i < giveTokens.length; i++) {
-        const normalized = normalizeAddress(group.realChainId, giveTokens[i].inputTokenAddress);
-        if (!allowed.has(normalized)) {
+        const addressKey = getAddressIdentityKey(group.realChainId, giveTokens[i].inputTokenAddress);
+        if (addressKey === undefined || !allowed.has(addressKey)) {
             violations.push({
                 code: ViolationCode.IntentGiveTokenInputAddressMismatch,
                 message: "intent.giveToken[].inputTokenAddress must equal one of"
                     + " intent.inputToken[].address used by a cross-chain"
                     + " trade in the group",
                 path: `${basePath}[${i}].inputTokenAddress`,
-                expected: Array.from(allowed),
+                expected: Array.from(allowed.values()),
                 actual: giveTokens[i].inputTokenAddress,
             });
         }
         // CRITICAL: giveTokenAddress is a bridge token in src chain — its value
         // is API-determined and unpredictable, but its format must match the
         // intent chain's engine.
-        const actualFormat = detectChainEngine(giveTokens[i].giveTokenAddress);
-        if (actualFormat !== expectedFormat) {
+        if (!isAddressRepresentationValidForChain(group.realChainId, giveTokens[i].giveTokenAddress)) {
             violations.push({
                 code: ViolationCode.IntentGiveTokenAddressFormatMismatch,
-                message: `intent.giveToken[].giveTokenAddress format (${ChainEngine[actualFormat]})`
-                    + ` does not match the intent chain engine`
-                    + ` (${ChainEngine[expectedFormat]})`,
+                message: "intent.giveToken[].giveTokenAddress does not use a supported"
+                    + ` format for the intent chain engine (${ChainEngine[expectedEngine]})`,
                 path: `${basePath}[${i}].giveTokenAddress`,
-                expected: ChainEngine[expectedFormat],
                 actual: giveTokens[i].giveTokenAddress,
             });
         }
@@ -226,43 +251,168 @@ function validateGiveTokens(ctx, basePath) {
 function collectInputAddressesForCrossChainTrades(ctx) {
     const intent = ctx.intentPayload.intent;
     const group = ctx.tradeGroup;
-    const inputAddresses = new Set((intent.inputToken ?? []).map(t => normalizeAddress(group.realChainId, t.address)));
-    const result = new Set();
+    const inputAddresses = new Map();
+    for (const inputToken of intent.inputToken ?? []) {
+        const inputTokenKey = getAddressIdentityKey(group.realChainId, inputToken.address);
+        if (inputTokenKey !== undefined) {
+            inputAddresses.set(inputTokenKey, inputToken.address);
+        }
+    }
+    const result = new Map();
     for (const trade of ctx.intentTrades) {
         if (!isCrossChain(trade))
             continue;
         const resolved = resolveWrappedTokenAddress(trade.srcChainTokenIn, group.realChainId);
         // Safe skip: unresolved input tokens are already reported by
-        // resolveGroupInputTokens.
+        // `resolveIntentInputTokens`.
         if (resolved === undefined)
             continue;
-        const normalized = normalizeAddress(group.realChainId, resolved);
-        if (inputAddresses.has(normalized)) {
-            result.add(normalized);
-        }
+        const addressKey = getAddressIdentityKey(group.realChainId, resolved);
+        if (addressKey === undefined)
+            continue;
+        const inputAddress = inputAddresses.get(addressKey);
+        if (inputAddress !== undefined)
+            result.set(addressKey, inputAddress);
     }
     return result;
 }
 function isCrossChain(trade) {
     return trade.srcChainId !== trade.dstChainId;
 }
-// CRITICAL: intent.takeToken[] must cover the unique destination
-// (dstChainId, dstChainTokenOut) pairs from this concrete intent's trades. The
-// API keys actual take-token entries by source/from token plus destination token,
-// so duplicate detection uses the full
-// (fromTokenAddress, takeTokenChainId, takeTokenAddress) identity.
+// CRITICAL: trades folded into one intent must not mix zero and non-zero
+// destination amounts for the same source/destination token pair. The intent
+// stores one exchange ratio per pair, so mixing modes would collapse the
+// signed ratio to zero for every trade in that pair.
+function validateTakeTokenZeroMode(ctx, basePath) {
+    const modes = new Map();
+    const reportedPairs = new Set();
+    const violations = [];
+    for (let i = 0; i < ctx.intentResponseTrades.length; i++) {
+        const requestTrade = ctx.intentTrades[i];
+        const responseTrade = ctx.intentResponseTrades[i];
+        if (requestTrade === undefined || responseTrade === undefined) {
+            // Safe skip: missing trade pairs are reported by trade count and matching checks.
+            continue;
+        }
+        const entry = getTakeTokenZeroModeEntry(requestTrade, responseTrade);
+        if (entry === undefined)
+            continue;
+        const existing = modes.get(entry.key);
+        if (existing === undefined) {
+            modes.set(entry.key, {
+                fromChainId: entry.fromChainId,
+                fromTokenAddress: entry.fromTokenAddress,
+                takeChainId: entry.takeChainId,
+                takeTokenAddress: entry.takeTokenAddress,
+                isDestinationAmountZero: entry.isDestinationAmountZero,
+                amounts: [entry.amount],
+            });
+            continue;
+        }
+        existing.amounts.push(entry.amount);
+        if (existing.isDestinationAmountZero === entry.isDestinationAmountZero)
+            continue;
+        if (reportedPairs.has(entry.key))
+            continue;
+        reportedPairs.add(entry.key);
+        violations.push(createTakeTokenZeroModeViolation(existing, basePath));
+    }
+    return violations;
+}
+function getTakeTokenZeroModeEntry(requestTrade, responseTrade) {
+    let amount;
+    try {
+        amount = parseIntegerString(responseTrade.dstChainTokenOut.amount);
+    }
+    catch {
+        // Safe skip: malformed destination amounts are reported by the trade-level checks.
+        return undefined;
+    }
+    if (amount < 0n) {
+        // Safe skip: legacy Solana negative outputs are validated separately.
+        return undefined;
+    }
+    const pair = resolveTakeTokenPairIdentity(requestTrade, responseTrade);
+    if (pair === undefined) {
+        // Safe skip: unknown chains, malformed token addresses, and native
+        // mapping gaps are reported by the dedicated trade/intent validators.
+        return undefined;
+    }
+    return {
+        ...pair,
+        amount: responseTrade.dstChainTokenOut.amount,
+        isDestinationAmountZero: amount === 0n,
+    };
+}
+function createTakeTokenZeroModeViolation(mode, basePath) {
+    return {
+        code: ViolationCode.IntentTakeTokenZeroModeMismatch,
+        message: "trades represented by one intent must not mix zero and non-zero"
+            + " destination amounts for the same token pair",
+        path: basePath,
+        actual: {
+            fromChainId: mode.fromChainId,
+            fromTokenAddress: mode.fromTokenAddress,
+            takeChainId: mode.takeChainId,
+            takeTokenAddress: mode.takeTokenAddress,
+            destinationAmounts: [...mode.amounts],
+        },
+    };
+}
+function resolveTakeTokenPairIdentity(requestTrade, responseTrade) {
+    const fromRealChainId = resolveChainId(requestTrade.srcChainId);
+    const takeRealChainId = resolveChainId(requestTrade.dstChainId);
+    if (fromRealChainId === undefined || takeRealChainId === undefined)
+        return undefined;
+    const fromToken = responseTrade.srcChainTokenOut ?? responseTrade.srcChainTokenIn;
+    const canonicalFromTokenAddress = fromRealChainId === takeRealChainId
+        ? resolveWrappedTokenAddress(fromToken.address, fromRealChainId)
+        : fromToken.address;
+    if (canonicalFromTokenAddress === undefined)
+        return undefined;
+    const takeTokenAddress = responseTrade.dstChainTokenOut.address;
+    const fromTokenKey = getAddressIdentityKey(fromRealChainId, canonicalFromTokenAddress);
+    const takeTokenKey = getAddressIdentityKey(takeRealChainId, takeTokenAddress);
+    if (fromTokenKey === undefined || takeTokenKey === undefined)
+        return undefined;
+    return {
+        key: [
+            fromRealChainId,
+            fromTokenKey,
+            takeRealChainId,
+            takeTokenKey,
+        ].join(":"),
+        fromChainId: fromRealChainId,
+        fromTokenAddress: canonicalFromTokenAddress,
+        takeChainId: takeRealChainId,
+        takeTokenAddress,
+    };
+}
+// CRITICAL: intent.takeToken[] must cover every unique
+// (fromTokenAddress, takeTokenChainId, takeTokenAddress) identity represented
+// by this concrete intent's trades. Missing and duplicate checks use the same
+// full identity so one source token cannot borrow another source token's output
+// constraint merely because both trades share a destination token.
 // CRITICAL: fromTokenAddress must be in inputToken[] (same-chain) or giveToken[]
 // (cross-chain).
 function validateTakeTokens(ctx, basePath) {
     const intent = ctx.intentPayload.intent;
     const group = ctx.tradeGroup;
     const violations = [];
-    const expectedDestinations = buildExpectedTakeTokenDestinations(ctx);
+    const expectedResult = buildExpectedTakeTokens(ctx);
+    const expectedIdentities = expectedResult.identities;
+    const expectedDestinations = expectedResult.destinations;
+    violations.push(...expectedResult.violations);
     const actualKeys = intent.takeToken.map(takeToken => buildTakeTokenIdentityKey(takeToken, group.realChainId));
-    const actualDestinations = new Set(intent.takeToken.map(takeToken => buildTakeTokenDestinationKey(takeToken)));
+    const actualIdentityKeys = new Set(actualKeys.flatMap(key => key === undefined ? [] : [key]));
     const firstOccurrence = new Map();
+    const uniqueIndices = [];
     for (let i = 0; i < actualKeys.length; i++) {
         const key = actualKeys[i];
+        if (key === undefined) {
+            uniqueIndices.push(i);
+            continue;
+        }
         const earlier = firstOccurrence.get(key);
         if (earlier !== undefined) {
             violations.push({
@@ -271,57 +421,110 @@ function validateTakeTokens(ctx, basePath) {
                     + ` index ${earlier} — each (fromTokenAddress,`
                     + ` takeTokenChainId, takeTokenAddress) tuple must appear once`,
                 path: `${basePath}[${i}]`,
-                actual: key,
+                actual: {
+                    fromTokenAddress: intent.takeToken[i].fromTokenAddress,
+                    takeTokenChainId: intent.takeToken[i].takeTokenChainId,
+                    takeTokenAddress: intent.takeToken[i].takeTokenAddress,
+                },
             });
         }
         else {
             firstOccurrence.set(key, i);
+            uniqueIndices.push(i);
         }
     }
-    for (const expectedTakeToken of expectedDestinations) {
-        if (!actualDestinations.has(expectedTakeToken)) {
+    for (const [expectedKey, expectedTakeToken] of expectedIdentities) {
+        if (!actualIdentityKeys.has(expectedKey)) {
             violations.push({
                 code: ViolationCode.IntentTakeTokenMissing,
-                message: "an expected (dstChainId, dstChainTokenOut) pair is"
-                    + " missing from intent.takeToken[]",
+                message: "an expected (fromTokenAddress, takeTokenChainId,"
+                    + " takeTokenAddress) identity is missing from"
+                    + " intent.takeToken[]",
                 path: basePath,
                 expected: expectedTakeToken,
             });
         }
     }
     // Validate each unique entry (duplicates are already reported above)
-    for (const [, i] of firstOccurrence) {
+    for (const i of uniqueIndices) {
         violations.push(...validateSingleTakeToken(intent, intent.takeToken[i], group, expectedDestinations, `${basePath}[${i}]`));
     }
     return violations;
 }
-// Single source of truth for the "chainId:normalizedAddress" key format used
-// to compare takeToken entries as a set. If realChainId is unknown we skip
-// normalization so the function can still produce a deterministic key for
-// duplicate detection; the chainId mismatch is flagged separately.
+// Single source of truth for the "chainId:canonicalAddress" key format used
+// to compare takeToken entries as a set. Unknown chains and malformed
+// addresses have no comparable identity.
 function buildChainTokenKey(chainId, realChainId, address) {
-    const normalized = realChainId !== undefined
-        ? normalizeAddress(realChainId, address)
-        : address;
-    return `${chainId}:${normalized}`;
+    if (realChainId === undefined)
+        return undefined;
+    const addressKey = getAddressIdentityKey(realChainId, address);
+    if (addressKey === undefined)
+        return undefined;
+    return `${chainId}:${addressKey}`;
 }
 function buildTakeTokenDestinationKey(takeToken) {
     return buildChainTokenKey(takeToken.takeTokenChainId, resolveChainId(takeToken.takeTokenChainId), takeToken.takeTokenAddress);
 }
 function buildTakeTokenIdentityKey(takeToken, sourceRealChainId) {
-    const fromKey = normalizeAddress(sourceRealChainId, takeToken.fromTokenAddress);
-    const destinationKey = buildTakeTokenDestinationKey(takeToken);
-    return `${fromKey}->${destinationKey}`;
+    const destinationRealChainId = resolveChainId(takeToken.takeTokenChainId);
+    if (destinationRealChainId === undefined)
+        return undefined;
+    return buildResolvedTakeTokenIdentityKey(sourceRealChainId, takeToken.fromTokenAddress, destinationRealChainId, takeToken.takeTokenAddress);
 }
-function buildExpectedTakeTokenDestinations(ctx) {
-    const set = new Set();
-    for (const trade of ctx.intentTrades) {
+function buildResolvedTakeTokenIdentityKey(sourceRealChainId, fromTokenAddress, destinationRealChainId, takeTokenAddress) {
+    const fromKey = getAddressIdentityKey(sourceRealChainId, fromTokenAddress);
+    const takeKey = getAddressIdentityKey(destinationRealChainId, takeTokenAddress);
+    if (fromKey === undefined || takeKey === undefined)
+        return undefined;
+    return [
+        sourceRealChainId,
+        fromKey,
+        destinationRealChainId,
+        takeKey,
+    ].join(":");
+}
+function buildExpectedTakeTokens(ctx) {
+    const identities = new Map();
+    const destinations = new Map();
+    const violations = [];
+    for (let i = 0; i < ctx.intentTrades.length; i++) {
+        const trade = ctx.intentTrades[i];
+        const responseTrade = ctx.intentResponseTrades[i];
         const dstRealChainId = resolveChainId(trade.dstChainId);
         // Safe skip: unknown subscriptionId for dstChainId is reported elsewhere
         // (validateTrades reports UnknownSubscriptionId for dstChainId)
         if (dstRealChainId === undefined)
             continue;
-        set.add(buildChainTokenKey(trade.dstChainId, dstRealChainId, trade.dstChainTokenOut));
+        const destinationKey = buildChainTokenKey(trade.dstChainId, dstRealChainId, trade.dstChainTokenOut);
+        if (destinationKey === undefined) {
+            violations.push({
+                code: ViolationCode.RequestTradeAddressInvalid,
+                message: "request.trades[].dstChainTokenOut is not a valid address"
+                    + " for dstChainId",
+                path: `request.trades[${getRequestTradeIndex(ctx, i)}].dstChainTokenOut`,
+                expected: {
+                    dstChainId: trade.dstChainId,
+                    realChainId: dstRealChainId,
+                },
+                actual: trade.dstChainTokenOut,
+            });
+        }
+        else {
+            destinations.set(destinationKey, {
+                takeTokenChainId: trade.dstChainId,
+                takeTokenAddress: trade.dstChainTokenOut,
+            });
+        }
+        const pair = responseTrade === undefined
+            ? undefined
+            : resolveTakeTokenPairIdentity(trade, responseTrade);
+        if (pair !== undefined) {
+            identities.set(pair.key, {
+                fromTokenAddress: pair.fromTokenAddress,
+                takeTokenChainId: trade.dstChainId,
+                takeTokenAddress: pair.takeTokenAddress,
+            });
+        }
         // CRITICAL: same-chain Solana with native dst — API also emits a wSOL
         // takeToken[] entry alongside the native one because Solana DLN
         // settlement operates on SPL tokens. Both entries are legitimate and
@@ -329,27 +532,57 @@ function buildExpectedTakeTokenDestinations(ctx) {
         if (trade.srcChainId === trade.dstChainId
             && getChainEngine(dstRealChainId) === ChainEngine.Solana
             && isNativeToken(trade.dstChainTokenOut, dstRealChainId)) {
-            set.add(buildChainTokenKey(trade.dstChainId, dstRealChainId, SPL_NATIVE_MINT));
+            const wrappedDestinationKey = buildChainTokenKey(trade.dstChainId, dstRealChainId, SPL_NATIVE_MINT);
+            if (wrappedDestinationKey !== undefined) {
+                destinations.set(wrappedDestinationKey, {
+                    takeTokenChainId: trade.dstChainId,
+                    takeTokenAddress: SPL_NATIVE_MINT,
+                });
+            }
+            if (pair !== undefined) {
+                const wrappedIdentityKey = buildResolvedTakeTokenIdentityKey(pair.fromChainId, pair.fromTokenAddress, pair.takeChainId, SPL_NATIVE_MINT);
+                if (wrappedIdentityKey !== undefined) {
+                    identities.set(wrappedIdentityKey, {
+                        fromTokenAddress: pair.fromTokenAddress,
+                        takeTokenChainId: trade.dstChainId,
+                        takeTokenAddress: SPL_NATIVE_MINT,
+                    });
+                }
+            }
         }
     }
-    return set;
+    return { identities, destinations, violations };
 }
 function validateSingleTakeToken(intent, takeToken, group, expected, basePath) {
     const violations = [];
     const dstRealChainId = resolveChainId(takeToken.takeTokenChainId);
-    // Safe skip: unknown subscriptionId for dstChainId is reported elsewhere
-    // (validateTrades reports UnknownSubscriptionId for dstChainId)
-    if (dstRealChainId !== undefined) {
+    if (dstRealChainId === undefined) {
+        violations.push({
+            code: ViolationCode.IntentTakeTokenAddressMismatch,
+            message: "intent.takeToken[].takeTokenChainId is not a known"
+                + " destination subscriptionId",
+            path: `${basePath}.takeTokenChainId`,
+            expected: Array.from(expected.values()),
+            actual: {
+                takeTokenChainId: takeToken.takeTokenChainId,
+                takeTokenAddress: takeToken.takeTokenAddress,
+            },
+        });
+    }
+    else {
         const key = buildChainTokenKey(takeToken.takeTokenChainId, dstRealChainId, takeToken.takeTokenAddress);
-        if (!expected.has(key)) {
+        if (key === undefined || !expected.has(key)) {
             violations.push({
                 code: ViolationCode.IntentTakeTokenAddressMismatch,
                 message: "intent.takeToken[] (takeTokenChainId, takeTokenAddress)"
                     + " pair does not match any request (dstChainId,"
                     + " dstChainTokenOut) pair in the trade group",
                 path: basePath,
-                expected: Array.from(expected),
-                actual: key,
+                expected: Array.from(expected.values()),
+                actual: {
+                    takeTokenChainId: takeToken.takeTokenChainId,
+                    takeTokenAddress: takeToken.takeTokenAddress,
+                },
             });
         }
     }
@@ -358,11 +591,18 @@ function validateSingleTakeToken(intent, takeToken, group, expected, basePath) {
 }
 function validateTakeTokenFromAddress(intent, takeToken, group, basePath) {
     const isSameChain = takeToken.takeTokenChainId === group.srcChainId;
-    const normalized = normalizeAddress(group.realChainId, takeToken.fromTokenAddress);
-    const allowedSet = isSameChain
-        ? new Set((intent.inputToken ?? []).map(t => normalizeAddress(group.realChainId, t.address)))
-        : new Set((intent.giveToken ?? []).map(t => normalizeAddress(group.realChainId, t.giveTokenAddress)));
-    if (!allowedSet.has(normalized)) {
+    const addressKey = getAddressIdentityKey(group.realChainId, takeToken.fromTokenAddress);
+    const allowedAddresses = isSameChain
+        ? (intent.inputToken ?? []).map(t => t.address)
+        : (intent.giveToken ?? []).map(t => t.giveTokenAddress);
+    const allowedByIdentity = new Map();
+    for (const address of allowedAddresses) {
+        const allowedAddressKey = getAddressIdentityKey(group.realChainId, address);
+        if (allowedAddressKey !== undefined) {
+            allowedByIdentity.set(allowedAddressKey, address);
+        }
+    }
+    if (addressKey === undefined || !allowedByIdentity.has(addressKey)) {
         return [{
                 code: ViolationCode.IntentTakeTokenFromAddressInvalid,
                 message: isSameChain
@@ -371,7 +611,7 @@ function validateTakeTokenFromAddress(intent, takeToken, group, basePath) {
                     : "intent.takeToken[].fromTokenAddress must be present"
                         + " in intent.giveToken[].giveTokenAddress for cross-chain trades",
                 path: `${basePath}.fromTokenAddress`,
-                expected: Array.from(allowedSet),
+                expected: Array.from(allowedByIdentity.values()),
                 actual: takeToken.fromTokenAddress,
             }];
     }