ox 1.7.0 → 1.7.2

package/src/core/Siwe.ts

@@ -23,6 +23,36 @@ export const prefixRegex =
 export const suffixRegex =
   /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/
 
+const siweDateTimeRegex =
+  /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])[Tt]([01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:[Zz]|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/
+
+function parseSiweDateTime(value: string): Date {
+  const match = value.match(siweDateTimeRegex)
+  if (!match) return new Date(Number.NaN)
+
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  const days = [
+    31,
+    year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31,
+  ]
+  const daysInMonth = days[month - 1]
+  if (!daysInMonth || day > daysInMonth) return new Date(Number.NaN)
+
+  return new Date(value.toUpperCase())
+}
+
 /** [EIP-4361](https://eips.ethereum.org/EIPS/eip-4361) message fields. */
 export type Message = {
   /**
@@ -388,9 +418,11 @@ export function parseMessage(message: string): ExactPartial<Message> {
     ...prefix,
     ...suffix,
     ...(chainId ? { chainId: Number(chainId) } : {}),
-    ...(expirationTime ? { expirationTime: new Date(expirationTime) } : {}),
-    ...(issuedAt ? { issuedAt: new Date(issuedAt) } : {}),
-    ...(notBefore ? { notBefore: new Date(notBefore) } : {}),
+    ...(expirationTime
+      ? { expirationTime: parseSiweDateTime(expirationTime) }
+      : {}),
+    ...(issuedAt ? { issuedAt: parseSiweDateTime(issuedAt) } : {}),
+    ...(notBefore ? { notBefore: parseSiweDateTime(notBefore) } : {}),
     ...(requestId ? { requestId } : {}),
     ...(resources ? { resources } : {}),
     ...(scheme ? { scheme } : {}),
@@ -431,8 +463,16 @@ export function validateMessage(value: validateMessage.Value): boolean {
   if (nonce && message.nonce !== nonce) return false
   if (scheme && message.scheme !== scheme) return false
 
-  if (message.expirationTime && time >= message.expirationTime) return false
-  if (message.notBefore && time < message.notBefore) return false
+  if (Number.isNaN(time.getTime())) return false
+
+  if (message.expirationTime) {
+    if (Number.isNaN(message.expirationTime.getTime())) return false
+    if (time >= message.expirationTime) return false
+  }
+  if (message.notBefore) {
+    if (Number.isNaN(message.notBefore.getTime())) return false
+    if (time < message.notBefore) return false
+  }
 
   try {
     if (!message.address) return false

package/src/core/_test/Hash.test.ts

@@ -762,6 +762,21 @@ describe('validate', () => {
     expect(
       Hash.validate('a5cc3c03994db5b0d9a5eEdD10Cabab0813678ac'),
     ).toBeFalsy()
+    expect(
+      Hash.validate(
+        '0xgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg',
+      ),
+    ).toBeFalsy()
+    expect(
+      Hash.validate(
+        '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72f',
+      ),
+    ).toBeFalsy()
+    expect(
+      Hash.validate(
+        '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe0',
+      ),
+    ).toBeFalsy()
     expect(
       Hash.validate(
         '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',

package/src/core/_test/Siwe.test.ts

@@ -546,6 +546,81 @@ Expiration Time: 2022-02-04T00:00:00.000Z`
     )
   })
 
+  test.each([
+    ['never', '2023-02-01T00:00:00Z'],
+    ['2023-02-29T00:00:00Z', '2023-02-28T12:00:00Z'],
+    ['2023-04-31T00:00:00Z', '2023-04-30T12:00:00Z'],
+    ['2023-02-01T24:00:00Z', '2023-02-01T12:00:00Z'],
+  ])(
+    'behavior: invalid RFC 3339 expirationTime `%s`',
+    (expirationTime, time) => {
+      const message = `https://example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Expiration Time: ${expirationTime}`
+      const parsed = Siwe.parseMessage(message)
+      expect({
+        invalid: Number.isNaN(parsed.expirationTime?.getTime()),
+        valid: Siwe.validateMessage({
+          message: parsed,
+          time: new Date(time),
+        }),
+      }).toMatchInlineSnapshot(`
+        {
+          "invalid": true,
+          "valid": false,
+        }
+      `)
+    },
+  )
+
+  test.each([
+    '2030-02-04t00:00:00Z',
+    '2030-02-04T00:00:00z',
+    '2030-02-04t00:00:00z',
+  ])('behavior: lowercase RFC 3339 expirationTime `%s`', (expirationTime) => {
+    const message = `https://example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Expiration Time: ${expirationTime}`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.expirationTime).toMatchInlineSnapshot(
+      '2030-02-04T00:00:00.000Z',
+    )
+    expect(
+      Siwe.validateMessage({
+        message: parsed,
+        time: new Date('2029-02-04T00:00:00Z'),
+      }),
+    ).toBeTruthy()
+  })
+
+  test('behavior: leap-year expirationTime', () => {
+    const message = `https://example.com wants you to sign in with your Ethereum account:
+0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+
+URI: https://example.com/path
+Version: 1
+Chain ID: 1
+Nonce: foobarbaz
+Issued At: 2023-02-01T00:00:00.000Z
+Expiration Time: 2032-02-29T00:00:00Z`
+    const parsed = Siwe.parseMessage(message)
+    expect(parsed.expirationTime).toMatchInlineSnapshot(
+      '2032-02-29T00:00:00.000Z',
+    )
+  })
+
   test('behavior: with notBefore', () => {
     const message = `https://example.com wants you to sign in with your Ethereum account:
 0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
@@ -730,6 +805,29 @@ describe('validateMessage', () => {
     ).toBeFalsy()
   })
 
+  test.each(['expirationTime', 'notBefore'] as const)(
+    'behavior: invalid %s',
+    (field) => {
+      expect(
+        Siwe.validateMessage({
+          message: {
+            ...message,
+            [field]: new Date('never'),
+          },
+        }),
+      ).toBeFalsy()
+    },
+  )
+
+  test('behavior: invalid time', () => {
+    expect(
+      Siwe.validateMessage({
+        message,
+        time: new Date('never'),
+      }),
+    ).toBeFalsy()
+  })
+
   test('behavior: time is before notBefore', () => {
     vi.useFakeTimers()
     vi.setSystemTime(new Date(Date.UTC(2023, 1, 1)))

package/src/tempo/KeyAuthorization.test-d.ts

@@ -1,6 +1,7 @@
 import { expectTypeOf, test } from 'vp/test'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as SignatureEnvelope from './SignatureEnvelope.js'
+import * as MultisigConfig from './MultisigConfig.js'
+import type * as SignatureEnvelope from './SignatureEnvelope.js'
 
 const authorization = {
   address: '0x1111111111111111111111111111111111111111',
@@ -19,6 +20,16 @@ const signature = {
 
 const multisig = {
   account: '0x2222222222222222222222222222222222222222',
+  config: MultisigConfig.from({
+    owners: [
+      {
+        owner: '0x1111111111111111111111111111111111111111',
+        weight: 1,
+      },
+    ],
+    threshold: 1,
+    version: 1n,
+  }),
   signatures: [signature],
   type: 'multisig',
 } as const satisfies SignatureEnvelope.Multisig
@@ -46,6 +57,7 @@ test('accepts multisig signatures', () => {
 
   const multisigRpc = {
     account: multisig.account,
+    config: MultisigConfig.toRpc(multisig.config),
     signatures: [
       {
         r: '0x01',

package/src/tempo/KeyAuthorization.test.ts

@@ -9,6 +9,7 @@ import {
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
 import * as KeyAuthorization from './KeyAuthorization.js'
+import * as MultisigConfig from './MultisigConfig.js'
 import * as Period from './Period.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
@@ -55,6 +56,16 @@ const signature_webauthn = SignatureEnvelope.from({
 
 const signature_multisig = {
   account: address,
+  config: MultisigConfig.from({
+    owners: [
+      {
+        owner: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        weight: 1,
+      },
+    ],
+    threshold: 1,
+    version: 1n,
+  }),
   signatures: [SignatureEnvelope.from(signature_secp256k1)],
   type: 'multisig',
 } as const satisfies SignatureEnvelope.Multisig
@@ -1071,6 +1082,60 @@ describe('getSignPayload', () => {
 })
 
 describe('deserialize', () => {
+  test('example: matches the frozen multisig witness vector', () => {
+    const serialized =
+      '0xf8f1f85382107980941eff47bc3a10a45d4b230b5d10e37751fe6aa718808080a0535353535353535353535353535353535353535353535353535353535353535380949dba7f426b711d4893c11611eacf7cc334e7146bb89a05f897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b8412cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e21451b' as const
+    const authorization = KeyAuthorization.deserialize(serialized)
+
+    expect(authorization).toMatchInlineSnapshot(`
+      {
+        "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+        "address": "0x1eff47bc3a10a45d4b230b5d10e37751fe6aa718",
+        "chainId": 4217n,
+        "isAdmin": false,
+        "signature": {
+          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+          "config": {
+            "owners": [
+              {
+                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "threshold": 1,
+            "version": 0n,
+          },
+          "signatures": [
+            {
+              "signature": {
+                "r": "0x2cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8",
+                "s": "0x359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e2145",
+                "yParity": 0,
+              },
+              "type": "secp256k1",
+            },
+          ],
+          "type": "multisig",
+        },
+        "type": "secp256k1",
+        "witness": "0x5353535353535353535353535353535353535353535353535353535353535353",
+      }
+    `)
+    expect(KeyAuthorization.serialize(authorization)).toBe(serialized)
+  })
+
+  test('multisig', () => {
+    const serialized = Rlp.fromHex([
+      ['0x1', '0x', address],
+      SignatureEnvelope.serialize(signature_multisig),
+    ])
+
+    expect(KeyAuthorization.deserialize(serialized).signature).toEqual(
+      signature_multisig,
+    )
+  })
+
   test('default', () => {
     const authorization = KeyAuthorization.from({
       address,

package/src/tempo/KeyAuthorization.ts

@@ -151,7 +151,7 @@ type SignatureValue =
   | UnionPartialBy<Signature, 'prehash' | 'type'>
   | SignatureEnvelope.Secp256k1Flat
   | SignatureEnvelope.Serialized
-  | SignatureEnvelope.from.MultisigFromInitialConfig
+  | SignatureEnvelope.from.MultisigFromConfig
 
 type BaseTuple = readonly [
   chainId: Hex.Hex,

package/src/tempo/MultisigConfig.test-d.ts

@@ -0,0 +1,52 @@
+import { expectTypeOf, test } from 'vp/test'
+import * as MultisigConfig from './MultisigConfig.js'
+
+const input = {
+  owners: [
+    {
+      owner: '0x1111111111111111111111111111111111111111',
+      weight: 1,
+    },
+  ],
+  threshold: 1,
+} as const satisfies MultisigConfig.Input
+
+test('from returns a complete configuration', () => {
+  const config = MultisigConfig.from(input)
+  const numeric = MultisigConfig.from({ ...input, version: 1 })
+  const zero = MultisigConfig.from({ ...input, version: 0 })
+
+  expectTypeOf(config).toMatchTypeOf<MultisigConfig.Config>()
+  expectTypeOf(config.version).toEqualTypeOf<0n>()
+  expectTypeOf(numeric.version).toEqualTypeOf<bigint>()
+  expectTypeOf(zero.version).toEqualTypeOf<0n>()
+})
+
+test('RPC configurations use hexadecimal versions', () => {
+  const rpc = MultisigConfig.toRpc(MultisigConfig.from(input))
+
+  expectTypeOf(rpc).toEqualTypeOf<MultisigConfig.Rpc>()
+  expectTypeOf(rpc.version).toEqualTypeOf<`0x${string}`>()
+})
+
+test('complete configurations require a version', () => {
+  // @ts-expect-error Complete configurations include their version.
+  const config: MultisigConfig.Config = input
+
+  expectTypeOf(config).toEqualTypeOf<MultisigConfig.Config>()
+})
+
+test('sign payloads take the version from config', () => {
+  MultisigConfig.getSignPayload({
+    account: '0x2222222222222222222222222222222222222222',
+    config: { version: 1 },
+    payload: '0x1234',
+  })
+
+  MultisigConfig.getSignPayload({
+    account: '0x2222222222222222222222222222222222222222',
+    // @ts-expect-error A configuration version is required.
+    config: {},
+    payload: '0x1234',
+  })
+})