ox 1.4.0 → 1.6.0

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

@@ -0,0 +1,393 @@
+import { Bytes, Engine, Hash, Hex, MlDsa44 } from 'ox'
+import { describe, expect, test } from 'vp/test'
+
+const privateKey = Hex.fromBytes(new Uint8Array(32).fill(7))
+const payload = '0xdeadbeef'
+
+describe('createKeyPair', () => {
+  test('default', () => {
+    const keyPair = MlDsa44.createKeyPair()
+
+    expect(keyPair).toHaveProperty('privateKey')
+    expect(keyPair).toHaveProperty('publicKey')
+    expect(keyPair.privateKey).toMatch(/^0x[0-9a-f]{64}$/)
+    expect(keyPair.publicKey).toMatch(/^0x[0-9a-f]{2624}$/)
+  })
+
+  test('behavior: as Bytes', () => {
+    const keyPair = MlDsa44.createKeyPair({ as: 'Bytes' })
+
+    expect(keyPair.privateKey).toBeInstanceOf(Uint8Array)
+    expect(keyPair.publicKey).toBeInstanceOf(Uint8Array)
+    expect(keyPair.privateKey).toHaveLength(MlDsa44.privateKeySize)
+    expect(keyPair.publicKey).toHaveLength(MlDsa44.publicKeySize)
+  })
+
+  test('behavior: unique keys', () => {
+    const keyPair1 = MlDsa44.createKeyPair()
+    const keyPair2 = MlDsa44.createKeyPair()
+
+    expect(keyPair1.privateKey).not.toBe(keyPair2.privateKey)
+    expect(keyPair1.publicKey).not.toBe(keyPair2.publicKey)
+  })
+
+  test('behavior: public key is derivable from private key', () => {
+    const { privateKey, publicKey } = MlDsa44.createKeyPair()
+
+    expect(MlDsa44.getPublicKey({ privateKey })).toEqual(publicKey)
+  })
+})
+
+describe('fromPrf', () => {
+  test.each([
+    {
+      privateKey:
+        '0x72bd14bc34a4c7ce64bd5dbfe0d432a1ab34cf1c364216c471d68a073d4fbb5b',
+      prf: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    },
+    {
+      privateKey:
+        '0xcc686ddfafe85330d7f270bf2fab31202b499a7e920ddbbd82cbb53759d4925c',
+      prf: '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    },
+  ] as const)('vector: $prf', ({ privateKey, prf }) => {
+    expect(MlDsa44.fromPrf(prf)).toBe(privateKey)
+  })
+
+  test('value: Bytes', () => {
+    const prf = Bytes.fromHex(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    )
+    expect(MlDsa44.fromPrf(prf)).toMatchInlineSnapshot(
+      `"0xcc686ddfafe85330d7f270bf2fab31202b499a7e920ddbbd82cbb53759d4925c"`,
+    )
+  })
+
+  test('options: as', () => {
+    const privateKey = MlDsa44.fromPrf(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+      { as: 'Bytes' },
+    )
+    expect(privateKey).toEqual(
+      Bytes.fromHex(
+        '0xcc686ddfafe85330d7f270bf2fab31202b499a7e920ddbbd82cbb53759d4925c',
+      ),
+    )
+  })
+
+  test('behavior: output signs and verifies', () => {
+    const privateKey = MlDsa44.fromPrf(Bytes.random(32))
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey })
+
+    expect(MlDsa44.verify({ payload, publicKey, signature })).toBe(true)
+  })
+
+  test('behavior: uses versioned label and zero counter', () => {
+    const messages: Hex.Hex[] = []
+    Engine.with(
+      {
+        Hash: {
+          hmacSha256: (_key, message) => {
+            messages.push(Hex.fromBytes(message))
+            return new Uint8Array(32)
+          },
+        },
+      },
+      () =>
+        MlDsa44.fromPrf(
+          '0x0000000000000000000000000000000000000000000000000000000000000000',
+        ),
+    )
+
+    expect(messages).toMatchInlineSnapshot(`
+      [
+        "0x6f782e6d6c64736134342e66726f6d5072662e763100000000",
+      ]
+    `)
+  })
+
+  test('behavior: zeroes intermediate key for Hex output', () => {
+    const candidate = new Uint8Array(32).fill(1)
+    Engine.with(
+      {
+        Hash: {
+          hmacSha256: () => candidate,
+        },
+      },
+      () =>
+        MlDsa44.fromPrf(
+          '0x0000000000000000000000000000000000000000000000000000000000000000',
+        ),
+    )
+
+    expect(candidate).toEqual(new Uint8Array(32))
+  })
+
+  test('error: PRF output is too short', () => {
+    expect(() => MlDsa44.fromPrf(new Uint8Array(31)))
+      .toThrowErrorMatchingInlineSnapshot(`
+        [MlDsa44.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 31 bytes.]
+      `)
+  })
+
+  test('error: PRF output is too long', () => {
+    expect(() => MlDsa44.fromPrf(new Uint8Array(33)))
+      .toThrowErrorMatchingInlineSnapshot(`
+        [MlDsa44.InvalidPrfSizeError: PRF output must be exactly 32 bytes. Received 33 bytes.]
+      `)
+  })
+})
+
+describe('getPublicKey', () => {
+  test('default', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+
+    expect(Hex.size(publicKey)).toBe(MlDsa44.publicKeySize)
+    expect(Hash.keccak256(publicKey)).toMatchInlineSnapshot(
+      `"0xe7b0dd35ffdccafa66d393e2afa66e22f658b9b72cbe63a2f51f25f8b65db4ad"`,
+    )
+  })
+
+  test('behavior: as Bytes', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey, as: 'Bytes' })
+
+    expect(publicKey).toBeInstanceOf(Uint8Array)
+    expect(publicKey).toHaveLength(MlDsa44.publicKeySize)
+  })
+
+  test('error: invalid private key size', () => {
+    expect(() =>
+      MlDsa44.getPublicKey({ privateKey: new Uint8Array(31) }),
+    ).toThrowError()
+  })
+})
+
+describe('randomPrivateKey', () => {
+  test('default', () => {
+    const privateKey = MlDsa44.randomPrivateKey()
+
+    expect(privateKey).toMatch(/^0x[0-9a-f]{64}$/)
+  })
+
+  test('behavior: as Bytes', () => {
+    const privateKey = MlDsa44.randomPrivateKey({ as: 'Bytes' })
+
+    expect(privateKey).toBeInstanceOf(Uint8Array)
+    expect(privateKey).toHaveLength(MlDsa44.privateKeySize)
+  })
+})
+
+describe('sign', () => {
+  test('default', () => {
+    const signature = MlDsa44.sign({ payload, privateKey })
+
+    expect(Hex.size(signature)).toBe(MlDsa44.signatureSize)
+    expect(Hash.keccak256(signature)).toMatchInlineSnapshot(
+      `"0x74ab423fe51d6e0ea20262b692822fcc3acfb25d1999d51254bb495bd5937ee5"`,
+    )
+  })
+
+  test('behavior: deterministic by default', () => {
+    expect(MlDsa44.sign({ payload, privateKey })).toBe(
+      MlDsa44.sign({ payload, privateKey }),
+    )
+  })
+
+  test('behavior: as Bytes', () => {
+    const signature = MlDsa44.sign({ payload, privateKey, as: 'Bytes' })
+
+    expect(signature).toBeInstanceOf(Uint8Array)
+    expect(signature).toHaveLength(MlDsa44.signatureSize)
+  })
+
+  test('behavior: Bytes payload and private key', () => {
+    const signature = MlDsa44.sign({
+      payload: Bytes.fromHex(payload),
+      privateKey: Bytes.fromHex(privateKey),
+    })
+
+    expect(signature).toBe(MlDsa44.sign({ payload, privateKey }))
+  })
+
+  test('behavior: context changes the signature', () => {
+    const signature = MlDsa44.sign({ payload, privateKey, context: '0x0102' })
+
+    expect(Hash.keccak256(signature)).toMatchInlineSnapshot(
+      `"0x3e071d2ce96153573364c0b698796534ca6b527c808dc7b0d67c7e95a5031191"`,
+    )
+    expect(signature).not.toBe(MlDsa44.sign({ payload, privateKey }))
+  })
+
+  test('behavior: extra entropy', () => {
+    const entropy = Hex.fromBytes(new Uint8Array(32).fill(9))
+    const signature = MlDsa44.sign({
+      payload,
+      privateKey,
+      extraEntropy: entropy,
+    })
+
+    expect(Hash.keccak256(signature)).toMatchInlineSnapshot(
+      `"0x10acdef5788ed190658943c03546af20df32064da4d0e795503440e37089d188"`,
+    )
+
+    const hedged1 = MlDsa44.sign({ payload, privateKey, extraEntropy: true })
+    const hedged2 = MlDsa44.sign({ payload, privateKey, extraEntropy: true })
+    expect(hedged1).not.toBe(hedged2)
+
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    expect(MlDsa44.verify({ payload, publicKey, signature: hedged1 })).toBe(
+      true,
+    )
+    expect(MlDsa44.verify({ payload, publicKey, signature: hedged2 })).toBe(
+      true,
+    )
+  })
+
+  test('error: context too large', () => {
+    expect(() =>
+      MlDsa44.sign({ payload, privateKey, context: new Uint8Array(256) }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MlDsa44.InvalidContextSizeError: Context must be at most 255 bytes. Received 256 bytes.]`,
+    )
+  })
+
+  test('error: invalid private key size', () => {
+    expect(() =>
+      MlDsa44.sign({ payload, privateKey: new Uint8Array(33) }),
+    ).toThrowError()
+  })
+})
+
+describe('verify', () => {
+  test('default', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey })
+
+    expect(MlDsa44.verify({ payload, publicKey, signature })).toBe(true)
+  })
+
+  test('behavior: rejects wrong payload', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey })
+
+    expect(
+      MlDsa44.verify({ payload: '0xbeefdead', publicKey, signature }),
+    ).toBe(false)
+  })
+
+  test('behavior: rejects corrupted signature', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey, as: 'Bytes' })
+    signature[0]! ^= 1
+
+    expect(MlDsa44.verify({ payload, publicKey, signature })).toBe(false)
+  })
+
+  test('behavior: rejects malformed signature', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+
+    expect(
+      MlDsa44.verify({ payload, publicKey, signature: '0xdeadbeef' }),
+    ).toBe(false)
+  })
+
+  test('behavior: rejects wrong public key', () => {
+    const signature = MlDsa44.sign({ payload, privateKey })
+    const { publicKey } = MlDsa44.createKeyPair()
+
+    expect(MlDsa44.verify({ payload, publicKey, signature })).toBe(false)
+  })
+
+  test('behavior: context must match', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey, context: '0x0102' })
+
+    expect(
+      MlDsa44.verify({ payload, publicKey, signature, context: '0x0102' }),
+    ).toBe(true)
+    expect(MlDsa44.verify({ payload, publicKey, signature })).toBe(false)
+    expect(
+      MlDsa44.verify({ payload, publicKey, signature, context: '0x0103' }),
+    ).toBe(false)
+  })
+
+  test('error: context too large', () => {
+    const publicKey = MlDsa44.getPublicKey({ privateKey })
+    const signature = MlDsa44.sign({ payload, privateKey })
+
+    expect(() =>
+      MlDsa44.verify({
+        payload,
+        publicKey,
+        signature,
+        context: new Uint8Array(256),
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MlDsa44.InvalidContextSizeError: Context must be at most 255 bytes. Received 256 bytes.]`,
+    )
+  })
+})
+
+describe('engine', () => {
+  test('behavior: routes through installed overrides', () => {
+    const calls: string[] = []
+    const signature = new Uint8Array(MlDsa44.signatureSize).fill(1)
+
+    const result = Engine.with(
+      {
+        MlDsa44: {
+          sign: (payload, privateKey) => {
+            calls.push(`sign:${payload.length}:${privateKey.length}`)
+            return signature
+          },
+          verify: () => {
+            calls.push('verify')
+            return true
+          },
+        },
+      },
+      () => {
+        const signed = MlDsa44.sign({ payload, privateKey, as: 'Bytes' })
+        const verified = MlDsa44.verify({
+          payload,
+          publicKey: new Uint8Array(MlDsa44.publicKeySize),
+          signature: signed,
+        })
+        return { signed, verified }
+      },
+    )
+
+    expect(calls).toEqual(['sign:4:32', 'verify'])
+    expect(result.signed).toEqual(signature)
+    expect(result.verified).toBe(true)
+  })
+
+  test('behavior: overrides clear on reset', () => {
+    Engine.set({ MlDsa44: { getPublicKey: () => new Uint8Array(1312) } })
+    try {
+      expect(MlDsa44.getPublicKey({ privateKey })).toBe(
+        Hex.fromBytes(new Uint8Array(1312)),
+      )
+    } finally {
+      Engine.reset('MlDsa44')
+    }
+    expect(Hash.keccak256(MlDsa44.getPublicKey({ privateKey }))).toBe(
+      '0xe7b0dd35ffdccafa66d393e2afa66e22f658b9b72cbe63a2f51f25f8b65db4ad',
+    )
+  })
+})
+
+describe('constants', () => {
+  test('sizes', () => {
+    expect(MlDsa44.privateKeySize).toBe(32)
+    expect(MlDsa44.publicKeySize).toBe(1312)
+    expect(MlDsa44.signatureSize).toBe(2420)
+    expect(MlDsa44.noble.lengths).toMatchObject({
+      publicKey: 1312,
+      secretKey: 2560,
+      seed: 32,
+      signature: 2420,
+    })
+  })
+})

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

@@ -48,6 +48,7 @@ test('exports', () => {
       "Keystore",
       "Kzg",
       "Log",
+      "MlDsa44",
       "Mnemonic",
       "P256",
       "PersonalMessage",

package/src/core/internal/engine.ts

@@ -158,6 +158,51 @@ export type Eddsa = {
     | undefined
 }
 
+/**
+ * Module-lattice digital signatures (ML-DSA, FIPS 204). Used by the `MlDsa44`
+ * slot.
+ *
+ * Private keys cross this boundary in their 32-byte seed form (`ξ`), never as
+ * the expanded secret key -- the seed is the canonical interchange form, and an
+ * engine expands it internally.
+ *
+ * @internal
+ */
+export type MlDsa = {
+  /** Derives the public key from a 32-byte private-key seed. */
+  getPublicKey?: ((privateKey: Uint8Array) => Uint8Array) | undefined
+  /** Generates a random 32-byte private-key seed. */
+  randomSecretKey?: (() => Uint8Array) | undefined
+  /** Signs a payload. */
+  sign?:
+    | ((
+        payload: Uint8Array,
+        privateKey: Uint8Array,
+        options: {
+          /** Context string for domain separation, at most 255 bytes. */
+          context?: Uint8Array | undefined
+          /**
+           * Extra entropy for hedged signing: exactly 32 bytes, `true` for 32
+           * random bytes, or `false` for the deterministic variant.
+           */
+          extraEntropy: boolean | Uint8Array
+        },
+      ) => Uint8Array)
+    | undefined
+  /** Verifies a signature. */
+  verify?:
+    | ((
+        signature: Uint8Array,
+        payload: Uint8Array,
+        publicKey: Uint8Array,
+        options: {
+          /** Context string for domain separation, at most 255 bytes. */
+          context?: Uint8Array | undefined
+        },
+      ) => boolean)
+    | undefined
+}
+
 /**
  * Montgomery-curve key agreement (X25519).
  *
@@ -305,6 +350,8 @@ export type Engine = {
   Hash?: Hash | undefined
   /** Implementation for [`Keystore`](/api/Keystore). */
   Keystore?: Keystore | undefined
+  /** Implementation for [`MlDsa44`](/api/MlDsa44). */
+  MlDsa44?: MlDsa | undefined
   /** Implementation for [`Mnemonic`](/api/Mnemonic). */
   Mnemonic?: Mnemonic | undefined
   /** Implementation for [`P256`](/api/P256). */
@@ -338,6 +385,7 @@ export const slots = [
   'Ed25519',
   'Hash',
   'Keystore',
+  'MlDsa44',
   'Mnemonic',
   'P256',
   'Secp256k1',
@@ -385,6 +433,7 @@ export const primitives = {
     'scrypt',
     'scryptAsync',
   ],
+  MlDsa44: ['getPublicKey', 'randomSecretKey', 'sign', 'verify'],
   Mnemonic: ['toSeed'],
   P256: [
     'getPublicKey',

package/src/core/internal/mlDsa44.ts

@@ -0,0 +1,74 @@
+import { ml_dsa44 } from '@noble/post-quantum/ml-dsa.js'
+import { randomBytes } from '@noble/post-quantum/utils.js'
+import { type Complete, type MlDsa, overrides } from './engine.js'
+
+/**
+ * Resolvers for the `MlDsa44` slot, and ox's defaults for it, backed by
+ * `@noble/post-quantum`.
+ *
+ * Declaring the defaults against the slot contract is what keeps them honest: a
+ * default that goes missing, or whose signature drifts, fails to compile rather
+ * than failing at the call site.
+ */
+
+const getPublicKeyDefault: Complete<MlDsa>['getPublicKey'] = (privateKey) => {
+  const { publicKey, secretKey } = ml_dsa44.keygen(privateKey)
+  secretKey.fill(0)
+  return publicKey
+}
+
+const randomSecretKeyDefault: Complete<MlDsa>['randomSecretKey'] = () =>
+  randomBytes(32)
+
+const signDefault: Complete<MlDsa>['sign'] = (payload, privateKey, options) => {
+  const { context, extraEntropy } = options
+  const { secretKey } = ml_dsa44.keygen(privateKey)
+  try {
+    // `true` is noble's default (fresh 32 random bytes), spelled by omission.
+    return ml_dsa44.sign(payload, secretKey, {
+      ...(context ? { context } : {}),
+      ...(extraEntropy === true ? {} : { extraEntropy }),
+    })
+  } finally {
+    secretKey.fill(0)
+  }
+}
+
+const verifyDefault: Complete<MlDsa>['verify'] = (
+  signature,
+  payload,
+  publicKey,
+  options,
+) =>
+  ml_dsa44.verify(
+    signature,
+    payload,
+    publicKey,
+    options.context ? { context: options.context } : {},
+  )
+
+/** @internal */
+export const getPublicKey: Complete<MlDsa>['getPublicKey'] = (privateKey) =>
+  (overrides.MlDsa44?.getPublicKey ?? getPublicKeyDefault)(privateKey)
+
+/** @internal */
+export const randomSecretKey: Complete<MlDsa>['randomSecretKey'] = () =>
+  (overrides.MlDsa44?.randomSecretKey ?? randomSecretKeyDefault)()
+
+/** @internal */
+export const sign: Complete<MlDsa>['sign'] = (payload, privateKey, options) =>
+  (overrides.MlDsa44?.sign ?? signDefault)(payload, privateKey, options)
+
+/** @internal */
+export const verify: Complete<MlDsa>['verify'] = (
+  signature,
+  payload,
+  publicKey,
+  options,
+) =>
+  (overrides.MlDsa44?.verify ?? verifyDefault)(
+    signature,
+    payload,
+    publicKey,
+    options,
+  )

package/src/index.ts

@@ -1915,6 +1915,47 @@ export * as Kzg from './core/Kzg.js'
  * @category Execution Spec
  */
 export * as Log from './core/Log.js'
+
+/**
+ * Utilities for working with ML-DSA-44 signatures and key pairs, as defined in [FIPS 204](https://csrc.nist.gov/pubs/fips/204/final).
+ *
+ * ML-DSA is a post-quantum digital signature scheme, standardized by NIST as the
+ * primary quantum-resistant replacement for elliptic-curve signatures. The `44`
+ * parameter set targets NIST security category 2 (128-bit classical security).
+ *
+ * Private keys are the 32-byte FIPS 204 seed. Public keys are 1,312 bytes and
+ * signatures are 2,420 bytes.
+ *
+ * @example
+ * ### Creating Key Pairs
+ *
+ * ```ts twoslash
+ * import { MlDsa44 } from 'ox'
+ *
+ * const { privateKey, publicKey } = MlDsa44.createKeyPair()
+ * ```
+ *
+ * @example
+ * ### Signing & Verifying
+ *
+ * ```ts twoslash
+ * import { MlDsa44 } from 'ox'
+ *
+ * const { privateKey, publicKey } = MlDsa44.createKeyPair()
+ * const payload = '0xdeadbeef'
+ *
+ * const signature = MlDsa44.sign({ payload, privateKey })
+ * const isValid = MlDsa44.verify({
+ *   payload,
+ *   publicKey,
+ *   signature
+ * })
+ * ```
+ *
+ * @category Post Quantum
+ */
+export * as MlDsa44 from './core/MlDsa44.js'
+
 /**
  * Utility functions for generating and working with [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) mnemonics.
  *

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

@@ -0,0 +1,13 @@
+import type { Hex } from 'ox'
+import { WithdrawalSenderTag } from 'ox/tempo'
+import { expectTypeOf, test } from 'vp/test'
+
+test('from', () => {
+  expectTypeOf(
+    WithdrawalSenderTag.from({
+      sender: '0x1234567890abcdef1234567890abcdef12345678',
+      transactionHash:
+        '0xabababababababababababababababababababababababababababababababab',
+    }),
+  ).toEqualTypeOf<Hex.Hex>()
+})

package/src/tempo/WithdrawalSenderTag.test.ts

@@ -0,0 +1,22 @@
+import { WithdrawalSenderTag } from 'ox/tempo'
+import { expect, test } from 'vp/test'
+
+test('from', () => {
+  const senderTag = WithdrawalSenderTag.from({
+    sender: '0x1234567890abcdef1234567890abcdef12345678',
+    transactionHash:
+      '0xabababababababababababababababababababababababababababababababab',
+  })
+  expect(senderTag).toMatchInlineSnapshot(
+    `"0x3362fade7333b56b9f3582089ec5915b8a6f6ac13e73a7f90c169e3eb81d8a5e"`,
+  )
+})
+
+test('deterministic', () => {
+  const value = {
+    sender: '0x1234567890abcdef1234567890abcdef12345678',
+    transactionHash:
+      '0xabababababababababababababababababababababababababababababababab',
+  } as const
+  expect(WithdrawalSenderTag.from(value)).toBe(WithdrawalSenderTag.from(value))
+})

package/src/tempo/WithdrawalSenderTag.ts

@@ -0,0 +1,47 @@
+import * as AbiParameters from '../core/AbiParameters.js'
+import * as Address from '../core/Address.js'
+import * as Hash from '../core/Hash.js'
+import * as Hex from '../core/Hex.js'
+
+/**
+ * Derives the sender tag that identifies the indexed parent-chain
+ * `WithdrawalProcessed` event for a Zone withdrawal.
+ *
+ * The `transactionHash` is the Zone transaction containing the
+ * `ZoneOutbox.requestWithdrawal` call. The protocol defines the sender tag as
+ * `keccak256(abi.encodePacked(sender, transactionHash))`.
+ *
+ * [Authenticated Withdrawals Specification](https://github.com/tempoxyz/zones/blob/main/specs/spec.md#authenticated-withdrawals)
+ *
+ * @example
+ * ```ts twoslash
+ * import { WithdrawalSenderTag } from 'ox/tempo'
+ *
+ * const senderTag = WithdrawalSenderTag.from({
+ *   sender: '0x1234567890abcdef1234567890abcdef12345678',
+ *   transactionHash:
+ *     '0xabababababababababababababababababababababababababababababababab'
+ * })
+ * ```
+ *
+ * @param value - Withdrawal sender and Zone transaction hash.
+ * @returns The sender tag.
+ */
+export function from(value: from.Value): Hex.Hex {
+  const { sender, transactionHash } = value
+  return Hash.keccak256(
+    AbiParameters.encodePacked(
+      ['address', 'bytes32'],
+      [sender, transactionHash],
+    ),
+  )
+}
+
+export declare namespace from {
+  export type Value = {
+    /** Address that requested the withdrawal. */
+    sender: Address.Address
+    /** Hash of the Zone transaction containing `ZoneOutbox.requestWithdrawal`. */
+    transactionHash: Hex.Hex
+  }
+}