mppx 0.4.11 → 0.5.0

package/src/tempo/internal/fee-payer.test.ts

@@ -70,17 +70,7 @@ describe('validateCalls', () => {
     ).not.toThrow()
   })
 
-  test('error: rejects empty calls', () => {
-    expect(() => validateCalls([], details)).toThrow(FeePayerValidationError)
-  })
-
-  test('error: rejects unknown selector', () => {
-    expect(() => validateCalls([{ data: '0xdeadbeef' as `0x${string}` }], details)).toThrow(
-      'disallowed call pattern',
-    )
-  })
-
-  test('error: rejects extra calls beyond allowed patterns', () => {
+  test('accepts multiple transfers after swap prefix', () => {
     const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
@@ -100,19 +90,48 @@ describe('validateCalls', () => {
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'transfer',
-              args: [bogus, 100n],
+              args: [bogus, 90n],
             }),
           },
           {
             data: encodeFunctionData({
               abi: Abis.tip20,
-              functionName: 'transfer',
-              args: [bogus, 100n],
+              functionName: 'transferWithMemo',
+              args: [
+                '0x0000000000000000000000000000000000000002',
+                10n,
+                '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+              ],
             }),
           },
         ],
         details,
       ),
+    ).not.toThrow()
+  })
+
+  test('error: rejects empty calls', () => {
+    expect(() => validateCalls([], details)).toThrow(FeePayerValidationError)
+  })
+
+  test('error: rejects unknown selector', () => {
+    expect(() => validateCalls([{ data: '0xdeadbeef' as `0x${string}` }], details)).toThrow(
+      'disallowed call pattern',
+    )
+  })
+
+  test('error: rejects more than 11 transfers', () => {
+    expect(() =>
+      validateCalls(
+        Array.from({ length: 12 }, (_, index) => ({
+          data: encodeFunctionData({
+            abi: Abis.tip20,
+            functionName: 'transfer',
+            args: [`0x${(index + 1).toString(16).padStart(40, '0')}`, 100n],
+          }),
+        })),
+        details,
+      ),
     ).toThrow('disallowed call pattern')
   })
 

package/src/tempo/internal/fee-payer.ts

@@ -30,14 +30,29 @@ export function validateCalls(
   calls: readonly { data?: `0x${string}` | undefined; to?: TempoAddress.Address | undefined }[],
   details: Record<string, string>,
 ) {
+  if (calls.length === 0)
+    throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
+
   const callSelectors = calls.map((c) => c.data?.slice(0, 10))
-  const allowed = callScopes.some(
-    (pattern) =>
-      pattern.length === callSelectors.length &&
-      pattern.every((sel, i) => sel === callSelectors[i]),
-  )
-  if (!allowed)
+  const hasSwapPrefix = callSelectors[0] === Selectors.approve
+
+  if (hasSwapPrefix) {
+    if (callSelectors[1] !== Selectors.swapExactAmountOut)
+      throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
+  } else if (callSelectors[0] === Selectors.swapExactAmountOut) {
+    throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
+  }
+
+  const transferSelectors = callSelectors.slice(hasSwapPrefix ? 2 : 0)
+  if (
+    transferSelectors.length === 0 ||
+    transferSelectors.length > 11 ||
+    transferSelectors.some(
+      (selector) => selector !== Selectors.transfer && selector !== Selectors.transferWithMemo,
+    )
+  ) {
     throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
+  }
 
   // Validate approve spender and buy target are the DEX.
   const approveCall = calls.find((c) => c.data?.slice(0, 10) === Selectors.approve)

package/src/tempo/internal/proof.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vp/test'
+
+import * as Proof from './proof.js'
+
+describe('Proof', () => {
+  test('types has Proof with challengeId field', () => {
+    expect(Proof.types).toEqual({
+      Proof: [{ name: 'challengeId', type: 'string' }],
+    })
+  })
+
+  test('domain returns EIP-712 domain with name, version, chainId', () => {
+    const d = Proof.domain(42431)
+    expect(d).toEqual({ name: 'MPP', version: '1', chainId: 42431 })
+  })
+
+  test('domain uses provided chainId', () => {
+    expect(Proof.domain(1).chainId).toBe(1)
+    expect(Proof.domain(99999).chainId).toBe(99999)
+  })
+
+  test('message wraps challengeId', () => {
+    expect(Proof.message('abc123')).toEqual({ challengeId: 'abc123' })
+  })
+
+  test('proofSource constructs did:pkh DID', () => {
+    expect(Proof.proofSource({ address: '0x1234567890abcdef', chainId: 42431 })).toBe(
+      'did:pkh:eip155:42431:0x1234567890abcdef',
+    )
+  })
+
+  test('proofSource preserves address casing', () => {
+    const address = '0xAbCdEf1234567890AbCdEf1234567890AbCdEf12'
+    expect(Proof.proofSource({ address, chainId: 1 })).toBe(`did:pkh:eip155:1:${address}`)
+  })
+})

package/src/tempo/internal/proof.ts

@@ -0,0 +1,19 @@
+/** EIP-712 typed data types for proof credentials. */
+export const types = {
+  Proof: [{ name: 'challengeId', type: 'string' }],
+} as const
+
+/** Constructs the EIP-712 domain for a proof credential. */
+export function domain(chainId: number) {
+  return { name: 'MPP', version: '1', chainId } as const
+}
+
+/** Constructs the EIP-712 message for a proof credential. */
+export function message(challengeId: string) {
+  return { challengeId } as const
+}
+
+/** Constructs the expected `did:pkh` source DID for a proof credential. */
+export function proofSource(parameters: { address: string; chainId: number }): string {
+  return `did:pkh:eip155:${parameters.chainId}:${parameters.address}`
+}