When createx402DelegationProvider, resolve the redeemers as the intersection of specified redeemer addresses, and facilitatorAddresses

- if only one of the two is specified, that value is used

Author: jeffsmale90

packages/smart-accounts-kit/src/experimental/x402DelegationProviderUtils.ts

@@ -34,7 +34,7 @@ type EnsureRedeemerSufficientlyConstrainedParams = {
   redeemerEnforcer: Hex;
   caveats: Caveat[];
   existingDelegations: Delegation[];
-  redeemerAddresses: Hex[];
+  redeemerAddresses: Address[] | undefined;
   requireRedeemers: boolean;
 };
 
@@ -58,6 +58,14 @@ type EnsureExpirySufficientlyConstrainedParams = {
   expirySeconds: number;
 };
 
+/**
+ * Inputs for resolving allowed redeemer addresses.
+ */
+type ResolveRedeemerAddressesParams = {
+  facilitatorAddresses?: Address[];
+  redeemerAddresses?: Address[];
+};
+
 /**
  * Resolved context required to build and sign an x402 delegation.
  */
@@ -236,6 +244,42 @@ export const ensureExpirySufficientlyConstrained = ({
   return [...caveats, timestampCaveat];
 };
 
+/**
+ * Resolves the allowed redeemer addresses from the union of facilitator specified and caller specified redeemer addresses.
+ * If either are undefined, the other is returned.
+ *
+ * @param options - Redeemer address inputs.
+ * @param options.facilitatorAddresses - Optional facilitator addresses from the PaymentRequirements.
+ * @param options.redeemerAddresses - Optional redeemer addresses from the RedeemersConfig.
+ * @returns The allowed redeemer addresses.
+ */
+const resolveRedeemerAddresses = ({
+  facilitatorAddresses,
+  redeemerAddresses,
+}: ResolveRedeemerAddressesParams): Address[] | undefined => {
+  if (!facilitatorAddresses) {
+    if (!redeemerAddresses) {
+      return undefined;
+    }
+    return redeemerAddresses;
+  }
+
+  if (!redeemerAddresses) {
+    return facilitatorAddresses;
+  }
+
+  const normalizedFacilitatorAddresses =
+    facilitatorAddresses.map(normalizeAddress);
+
+  const normalizedRedeemerAddressSet = new Set(
+    redeemerAddresses.map(normalizeAddress),
+  );
+
+  return normalizedFacilitatorAddresses.filter((address) =>
+    normalizedRedeemerAddressSet.has(address),
+  );
+};
+
 /**
  * Ensures caveats include a sufficiently strict redeemer constraint.
  *
@@ -258,9 +302,9 @@ export const ensureRedeemerSufficientlyConstrained = ({
   redeemerAddresses,
   requireRedeemers,
 }: EnsureRedeemerSufficientlyConstrainedParams): Caveat[] => {
-  const redeemerAddressNormalized = normalizeAddress(redeemerEnforcer);
+  const redeemerEnforcerNormalized = normalizeAddress(redeemerEnforcer);
 
-  if (redeemerAddresses.length === 0) {
+  if (!redeemerAddresses || redeemerAddresses.length === 0) {
     if (!requireRedeemers) {
       return caveats;
     }
@@ -269,7 +313,7 @@ export const ensureRedeemerSufficientlyConstrained = ({
       caveats,
       existingDelegations,
       ({ enforcer }) =>
-        normalizeAddress(enforcer) === redeemerAddressNormalized,
+        normalizeAddress(enforcer) === redeemerEnforcerNormalized,
     );
 
     if (!hasExistingRedeemerCaveat) {
@@ -288,7 +332,7 @@ export const ensureRedeemerSufficientlyConstrained = ({
     caveats,
     existingDelegations,
     (caveat) => {
-      if (normalizeAddress(caveat.enforcer) !== redeemerAddressNormalized) {
+      if (normalizeAddress(caveat.enforcer) !== redeemerEnforcerNormalized) {
         return false;
       }
 
@@ -420,17 +464,16 @@ export const resolvex402DelegationCaveats = ({
     isScopeOptional: true,
   });
 
-  const allRedeemerAddresses = new Set(
-    [...(facilitatorAddresses ?? []), ...(redeemerAddresses ?? [])].map(
-      normalizeAddress,
-    ),
-  );
+  const resolvedRedeemerAddresses = resolveRedeemerAddresses({
+    facilitatorAddresses,
+    redeemerAddresses,
+  });
 
   const caveatsWithRedeemer = ensureRedeemerSufficientlyConstrained({
     redeemerEnforcer,
     caveats: initialCaveats,
     existingDelegations,
-    redeemerAddresses: Array.from(allRedeemerAddresses),
+    redeemerAddresses: resolvedRedeemerAddresses,
     requireRedeemers,
   });
 

packages/smart-accounts-kit/test/experimental/x402DelegationProviderUtils.test.ts

@@ -448,15 +448,15 @@ describe('x402DelegationProviderUtils', () => {
       ).toThrow('Expiry seconds must be a positive number');
     });
 
-    it('enforces redeemer caveats from the union of facilitator and configured redeemer addresses', () => {
+    it('enforces redeemer caveats from the intersection of facilitator and configured redeemer addresses', () => {
       const result = resolvex402DelegationCaveats({
         environment: baseEnvironment,
         caveatsConfig: [],
         existingDelegations: [],
-        facilitatorAddresses: [facilitatorA],
+        facilitatorAddresses: [facilitatorA, facilitatorB],
         payee,
         requireRedeemers: true,
-        redeemerAddresses: [facilitatorB],
+        redeemerAddresses: [facilitatorB, facilitatorC],
       });
 
       const redeemerCaveat = result.find(
@@ -467,12 +467,9 @@ describe('x402DelegationProviderUtils', () => {
         throw new Error('Expected redeemer caveat to be present');
       }
 
-      expect(decodeRedeemerTerms(redeemerCaveat.terms).redeemers).toEqual(
-        expect.arrayContaining([facilitatorA, facilitatorB]),
-      );
-      expect(decodeRedeemerTerms(redeemerCaveat.terms).redeemers).toHaveLength(
-        2,
-      );
+      expect(decodeRedeemerTerms(redeemerCaveat.terms).redeemers).toEqual([
+        facilitatorB,
+      ]);
     });
   });