mppx 0.8.12 → 0.8.14

package/src/internal/types.ts

@@ -277,6 +277,39 @@ export type ExactPartial<type> = {
   [key in keyof type]?: type[key] | undefined
 }
 
+/**
+ * Keys whose values are known to be present and defined.
+ *
+ * This is useful when a factory accepts partial configuration and its return
+ * type needs to distinguish values supplied as defaults from fields that
+ * callers must still provide later. Optional and `undefined`-able properties
+ * are excluded because their runtime values cannot be assumed to be defaults.
+ *
+ * @internal
+ */
+export type DefinedKeys<type> = {
+  [key in keyof type]-?: {} extends Pick<type, key>
+    ? never
+    : undefined extends type[key]
+      ? never
+      : key
+}[keyof type]
+
+/**
+ * Request defaults known to have been configured by a factory caller.
+ *
+ * Optional and `undefined`-able parameters are omitted: their runtime values
+ * are not guaranteed to be usable defaults for a subsequently returned
+ * handler. Factories can intersect this type with values they resolve
+ * unconditionally at runtime.
+ *
+ * @internal
+ */
+export type ConfiguredDefaults<parameters, defaults> = Pick<
+  parameters,
+  Extract<DefinedKeys<parameters>, keyof defaults>
+>
+
 /** @internal */
 export type ExactRequired<type> = {
   [key in keyof type]-?: Exclude<type[key], undefined>

package/src/server/Mppx.test-d.ts

@@ -223,6 +223,8 @@ describe('Mppx type tests', () => {
     const mppx = Mppx.create({ methods: [alphaMethod], realm, secretKey })
 
     expectTypeOf(mppx.verifyCredential).toBeFunction()
+    expectTypeOf(mppx.broadcastCredential).toBeFunction()
+    expectTypeOf(mppx.validateCredential).toBeFunction()
   })
 
   test('server events receive typed method context', () => {
@@ -313,4 +315,46 @@ describe('Mppx type tests', () => {
       }),
     ).toBeFunction()
   })
+
+  test('tempo factories expose resolved currency and decimals as defaults', () => {
+    const charge = Mppx.create({ methods: [tempo.charge()], realm, secretKey })
+    expectTypeOf(charge.tempo.charge({ amount: '1' })).toBeFunction()
+    // @ts-expect-error amount is not supplied by Tempo's runtime defaults.
+    void charge.tempo.charge({})
+
+    const subscription = Mppx.create({
+      methods: [
+        tempo.subscription({
+          recipient: '0x1234567890abcdef1234567890abcdef12345678',
+          resolve: async () => null,
+        }),
+      ],
+      realm,
+      secretKey,
+    })
+    expectTypeOf(
+      subscription.tempo.subscription({
+        amount: '1',
+        periodCount: 1n,
+        periodUnit: 'day',
+        subscriptionExpires: new Date('2026-01-01T00:00:00Z'),
+      }),
+    ).toBeFunction()
+
+    const session = Mppx.create({ methods: [tempo.session()], realm, secretKey })
+    expectTypeOf(session.tempo.session({ amount: '1', unitType: 'request' })).toBeFunction()
+
+    const common = Mppx.create({
+      methods: [
+        tempo.common({
+          amount: '1',
+          recipient: '0x1234567890abcdef1234567890abcdef12345678',
+        }),
+      ],
+      realm,
+      secretKey,
+    })
+    expectTypeOf(common.tempo.charge({})).toBeFunction()
+    expectTypeOf(common.tempo.session({ unitType: 'request' })).toBeFunction()
+  })
 })

package/src/server/Mppx.test.ts

@@ -4872,6 +4872,211 @@ describe('verifyCredential', () => {
     expect(verifyArgs).toBeDefined()
   })
 
+  test('validateCredential uses pure method validation without broadcast', async () => {
+    const calls: string[] = []
+    const splitServer = Method.toServer(mockCharge, {
+      async validate({ credential, request }) {
+        calls.push('validate')
+        return {
+          challenge: credential.challenge,
+          credential,
+          details: { token: credential.payload.token },
+          intent: 'charge',
+          method: 'alpha',
+          request,
+          source: credential.source,
+        }
+      },
+      async broadcast() {
+        calls.push('broadcast')
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    const validation = await mppx.validateCredential(credential)
+
+    expect(validation.details).toEqual({ token: 'valid' })
+    expect(calls).toEqual(['validate'])
+  })
+
+  test('broadcastCredential revalidates and uses method broadcast', async () => {
+    const calls: string[] = []
+    const splitServer = Method.toServer(mockCharge, {
+      async validate({ credential, request }) {
+        calls.push('validate')
+        return {
+          challenge: credential.challenge,
+          credential,
+          details: {},
+          intent: 'charge',
+          method: 'alpha',
+          request,
+          source: credential.source,
+        }
+      },
+      async broadcast() {
+        calls.push('broadcast')
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    const receipt = await mppx.broadcastCredential(credential)
+
+    expect(receipt.method).toBe('broadcast')
+    expect(calls).toEqual(['validate', 'broadcast'])
+  })
+
+  test('verifyCredential remains a legacy alias for broadcast', async () => {
+    const calls: string[] = []
+    const splitServer = Method.toServer(mockCharge, {
+      async validate({ credential, request }) {
+        calls.push('validate')
+        return {
+          challenge: credential.challenge,
+          credential,
+          details: {},
+          intent: 'charge',
+          method: 'alpha',
+          request,
+          source: credential.source,
+        }
+      },
+      async broadcast() {
+        calls.push('broadcast')
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    const receipt = await mppx.verifyCredential(credential)
+
+    expect(receipt.method).toBe('broadcast')
+    expect(calls).toEqual(['validate', 'broadcast'])
+  })
+
+  test('validateCredential rejects legacy-only methods without emitting payment failure', async () => {
+    const events: string[] = []
+    const mppx = Mppx.create({ methods: [alphaChargeServer], realm, secretKey })
+    mppx.onPaymentFailed((context) => {
+      events.push(context.error.name)
+    })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    await expect(mppx.validateCredential(credential)).rejects.toThrow(
+      'does not support non-mutating credential validation',
+    )
+
+    expect(events).toEqual([])
+  })
+
+  test('validateCredential enforces supplied route requirements', async () => {
+    const splitServer = Method.toServer(mockCharge, {
+      async validate({ credential, request }) {
+        return {
+          challenge: credential.challenge,
+          credential,
+          details: { amount: request.amount },
+          intent: 'charge',
+          method: 'alpha',
+          request,
+          source: credential.source,
+        }
+      },
+      async broadcast() {
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    const validation = await mppx.validateCredential(credential, { request: challengeOpts })
+    expect(validation.details).toEqual({ amount: '1000' })
+
+    await expect(
+      mppx.validateCredential(credential, {
+        request: {
+          ...challengeOpts,
+          amount: '2000',
+        },
+      }),
+    ).rejects.toThrow('credential amount does not match this route')
+  })
+
+  test('broadcastCredential emits payment failure when split validation fails', async () => {
+    const calls: string[] = []
+    const events: string[] = []
+    const splitServer = Method.toServer(mockCharge, {
+      async validate() {
+        calls.push('validate')
+        throw new Errors.VerificationFailedError({ reason: 'risk denied' })
+      },
+      async broadcast() {
+        calls.push('broadcast')
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    mppx.onPaymentFailed((context) => {
+      events.push(context.error.name)
+    })
+    const challenge = await mppx.challenge.alpha.charge(challengeOpts)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+
+    await expect(mppx.broadcastCredential(credential)).rejects.toThrow('risk denied')
+
+    expect(calls).toEqual(['validate'])
+    expect(events).toEqual(['VerificationFailedError'])
+  })
+
+  test('route handlers revalidate before broadcast for split methods', async () => {
+    const calls: string[] = []
+    const splitServer = Method.toServer(mockCharge, {
+      async validate({ credential, request }) {
+        calls.push('validate')
+        return {
+          challenge: credential.challenge,
+          credential,
+          details: {},
+          intent: 'charge',
+          method: 'alpha',
+          request,
+          source: credential.source,
+        }
+      },
+      async broadcast() {
+        calls.push('broadcast')
+        return mockReceipt('broadcast')
+      },
+    })
+    const mppx = Mppx.create({ methods: [splitServer], realm, secretKey })
+    const firstResult = await mppx.charge(challengeOpts)(
+      new Request('https://api.example.com/resource'),
+    )
+    expect(firstResult.status).toBe(402)
+    if (firstResult.status !== 402) throw new Error()
+
+    const challenge = Challenge.fromResponse(firstResult.challenge)
+    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
+    const result = await mppx.charge(challengeOpts)(
+      new Request('https://api.example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(result.status).toBe(200)
+    expect(calls).toEqual(['validate', 'broadcast'])
+  })
+
   test('verifies a parsed Credential object (charge)', async () => {
     verifyArgs = undefined
     const mppx = Mppx.create({