ox 0.9.16 → 0.10.0

package/core/{TransactionEnvelopeLegacy.ts → TxEnvelopeLegacy.ts}

@@ -11,9 +11,9 @@ import type {
 } from './internal/types.js'
 import * as Rlp from './Rlp.js'
 import * as Signature from './Signature.js'
-import * as TransactionEnvelope from './TransactionEnvelope.js'
+import * as TransactionEnvelope from './TxEnvelope.js'
 
-export type TransactionEnvelopeLegacy<
+export type TxEnvelopeLegacy<
   signed extends boolean = boolean,
   bigintType = bigint,
   numberType = number,
@@ -28,7 +28,7 @@ export type TransactionEnvelopeLegacy<
   }
 >
 
-export type Rpc<signed extends boolean = boolean> = TransactionEnvelopeLegacy<
+export type Rpc<signed extends boolean = boolean> = TxEnvelopeLegacy<
   signed,
   Hex.Hex,
   Hex.Hex,
@@ -37,19 +37,19 @@ export type Rpc<signed extends boolean = boolean> = TransactionEnvelopeLegacy<
 
 export type Serialized = Branded<`0x${string}`, 'legacy'>
 
-export type Signed = TransactionEnvelopeLegacy<true>
+export type Signed = TxEnvelopeLegacy<true>
 
 export const type = 'legacy'
 export type Type = typeof type
 
 /**
- * Asserts a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} is valid.
+ * Asserts a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy} is valid.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { TxEnvelopeLegacy, Value } from 'ox'
  *
- * TransactionEnvelopeLegacy.assert({
+ * TxEnvelopeLegacy.assert({
  *   gasPrice: 2n ** 256n - 1n + 1n,
  *   chainId: 1,
  *   to: '0x0000000000000000000000000000000000000000',
@@ -62,7 +62,7 @@ export type Type = typeof type
  *
  * @param envelope - The transaction envelope to assert.
  */
-export function assert(envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>) {
+export function assert(envelope: PartialBy<TxEnvelopeLegacy, 'type'>) {
   const { chainId, gasPrice, to } = envelope
   if (to) Address.assert(to, { strict: false })
   if (typeof chainId !== 'undefined' && chainId <= 0)
@@ -80,13 +80,13 @@ export declare namespace assert {
 }
 
 /**
- * Deserializes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} from its serialized form.
+ * Deserializes a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy} from its serialized form.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeLegacy } from 'ox'
+ * import { TxEnvelopeLegacy } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.deserialize('0x01ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
+ * const envelope = TxEnvelopeLegacy.deserialize('0x01ef0182031184773594008477359400809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c0')
  * // @log: {
  * // @log:   type: 'legacy',
  * // @log:   nonce: 785n,
@@ -100,9 +100,7 @@ export declare namespace assert {
  * @param serialized - The serialized transaction.
  * @returns Deserialized Transaction Envelope.
  */
-export function deserialize(
-  serialized: Hex.Hex,
-): Compute<TransactionEnvelopeLegacy> {
+export function deserialize(serialized: Hex.Hex): Compute<TxEnvelopeLegacy> {
   const tuple = Rlp.toHex(serialized)
 
   const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] =
@@ -131,7 +129,7 @@ export function deserialize(
 
   const transaction = {
     type,
-  } as TransactionEnvelopeLegacy
+  } as TxEnvelopeLegacy
   if (Hex.validate(to) && to !== '0x') transaction.to = to
   if (Hex.validate(gas) && gas !== '0x') transaction.gas = BigInt(gas)
   if (Hex.validate(data) && data !== '0x') transaction.data = data
@@ -177,9 +175,9 @@ export declare namespace deserialize {
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { TxEnvelopeLegacy, Value } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   gasPrice: Value.fromGwei('10'),
  *   to: '0x0000000000000000000000000000000000000000',
  *   value: Value.fromEther('1'),
@@ -192,9 +190,9 @@ export declare namespace deserialize {
  * It is possible to attach a `signature` to the transaction envelope.
  *
  * ```ts twoslash
- * import { Secp256k1, TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { Secp256k1, TxEnvelopeLegacy, Value } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   chainId: 1,
  *   gasPrice: Value.fromGwei('10'),
  *   to: '0x0000000000000000000000000000000000000000',
@@ -202,11 +200,11 @@ export declare namespace deserialize {
  * })
  *
  * const signature = Secp256k1.sign({
- *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope),
  *   privateKey: '0x...',
  * })
  *
- * const envelope_signed = TransactionEnvelopeLegacy.from(envelope, { // [!code focus]
+ * const envelope_signed = TxEnvelopeLegacy.from(envelope, { // [!code focus]
  *   signature, // [!code focus]
  * }) // [!code focus]
  * // @log: {
@@ -225,12 +223,12 @@ export declare namespace deserialize {
  * @example
  * ### From Serialized
  *
- * It is possible to instantiate an legacy Transaction Envelope from a {@link ox#TransactionEnvelopeLegacy.Serialized} value.
+ * It is possible to instantiate an legacy Transaction Envelope from a {@link ox#TxEnvelopeLegacy.Serialized} value.
  *
  * ```ts twoslash
- * import { TransactionEnvelopeLegacy } from 'ox'
+ * import { TxEnvelopeLegacy } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from('0xf858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
+ * const envelope = TxEnvelopeLegacy.from('0xf858018203118502540be4008504a817c800809470997970c51812dc3a010c7d01b50e0d17dc79c8880de0b6b3a764000080c08477359400e1a001627c687261b0e7f8638af1112efa8a77e23656f6e7945275b19e9deed80261')
  * // @log: {
  * // @log:   chainId: 1,
  * // @log:   gasPrice: 10000000000n,
@@ -245,22 +243,17 @@ export declare namespace deserialize {
  * @returns A legacy Transaction Envelope.
  */
 export function from<
-  const envelope extends
-    | UnionPartialBy<TransactionEnvelopeLegacy, 'type'>
-    | Hex.Hex,
+  const envelope extends UnionPartialBy<TxEnvelopeLegacy, 'type'> | Hex.Hex,
   const signature extends Signature.Signature | undefined = undefined,
 >(
-  envelope:
-    | envelope
-    | UnionPartialBy<TransactionEnvelopeLegacy, 'type'>
-    | Hex.Hex,
+  envelope: envelope | UnionPartialBy<TxEnvelopeLegacy, 'type'> | Hex.Hex,
   options: from.Options<signature> = {},
 ): from.ReturnType<envelope, signature> {
   const { signature } = options
 
   const envelope_ = (
     typeof envelope === 'string' ? deserialize(envelope) : envelope
-  ) as TransactionEnvelopeLegacy
+  ) as TxEnvelopeLegacy
 
   assert(envelope_)
 
@@ -285,13 +278,13 @@ export declare namespace from {
     }
 
   type ReturnType<
-    envelope extends
-      | UnionPartialBy<TransactionEnvelopeLegacy, 'type'>
-      | Hex.Hex = TransactionEnvelopeLegacy | Hex.Hex,
+    envelope extends UnionPartialBy<TxEnvelopeLegacy, 'type'> | Hex.Hex =
+      | TxEnvelopeLegacy
+      | Hex.Hex,
     signature extends Signature.Signature | undefined = undefined,
   > = Compute<
     envelope extends Hex.Hex
-      ? TransactionEnvelopeLegacy
+      ? TxEnvelopeLegacy
       : Assign<
           envelope,
           (signature extends Signature.Signature
@@ -313,7 +306,7 @@ export declare namespace from {
 }
 
 /**
- * Returns the payload to sign for a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}.
+ * Returns the payload to sign for a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy}.
  *
  * @example
  * The example below demonstrates how to compute the sign payload which can be used
@@ -321,9 +314,9 @@ export declare namespace from {
  *
  * ```ts twoslash
  * // @noErrors
- * import { Secp256k1, TransactionEnvelopeLegacy } from 'ox'
+ * import { Secp256k1, TxEnvelopeLegacy } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   nonce: 0n,
  *   gasPrice: 1000000000n,
  *   gas: 21000n,
@@ -331,7 +324,7 @@ export declare namespace from {
  *   value: 1000000000000000000n,
  * })
  *
- * const payload = TransactionEnvelopeLegacy.getSignPayload(envelope) // [!code focus]
+ * const payload = TxEnvelopeLegacy.getSignPayload(envelope) // [!code focus]
  * // @log: '0x...'
  *
  * const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
@@ -341,7 +334,7 @@ export declare namespace from {
  * @returns The sign payload.
  */
 export function getSignPayload(
-  envelope: TransactionEnvelopeLegacy<false>,
+  envelope: TxEnvelopeLegacy<false>,
 ): getSignPayload.ReturnType {
   return hash(envelope, { presign: true })
 }
@@ -353,13 +346,13 @@ export declare namespace getSignPayload {
 }
 
 /**
- * Hashes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}. This is the "transaction hash".
+ * Hashes a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy}. This is the "transaction hash".
  *
  * @example
  * ```ts twoslash
- * import { Secp256k1, TransactionEnvelopeLegacy } from 'ox'
+ * import { Secp256k1, TxEnvelopeLegacy } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   chainId: 1,
  *   nonce: 0n,
  *   gasPrice: 1000000000n,
@@ -369,13 +362,13 @@ export declare namespace getSignPayload {
  * })
  *
  * const signature = Secp256k1.sign({
- *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope),
  *   privateKey: '0x...'
  * })
  *
- * const envelope_signed = TransactionEnvelopeLegacy.from(envelope, { signature })
+ * const envelope_signed = TxEnvelopeLegacy.from(envelope, { signature })
  *
- * const hash = TransactionEnvelopeLegacy.hash(envelope_signed) // [!code focus]
+ * const hash = TxEnvelopeLegacy.hash(envelope_signed) // [!code focus]
  * ```
  *
  * @param envelope - The Legacy Transaction Envelope to hash.
@@ -383,7 +376,7 @@ export declare namespace getSignPayload {
  * @returns The hash of the transaction envelope.
  */
 export function hash<presign extends boolean = false>(
-  envelope: TransactionEnvelopeLegacy<presign extends true ? false : true>,
+  envelope: TxEnvelopeLegacy<presign extends true ? false : true>,
   options: hash.Options<presign> = {},
 ): hash.ReturnType {
   const { presign } = options
@@ -417,21 +410,21 @@ export declare namespace hash {
 }
 
 /**
- * Serializes a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}.
+ * Serializes a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy}.
  *
  * @example
  * ```ts twoslash
  * // @noErrors
- * import { TransactionEnvelopeLegacy } from 'ox'
+ * import { TxEnvelopeLegacy } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   chainId: 1,
  *   gasPrice: Value.fromGwei('10'),
  *   to: '0x0000000000000000000000000000000000000000',
  *   value: Value.fromEther('1'),
  * })
  *
- * const serialized = TransactionEnvelopeLegacy.serialize(envelope) // [!code focus]
+ * const serialized = TxEnvelopeLegacy.serialize(envelope) // [!code focus]
  * ```
  *
  * @example
@@ -441,9 +434,9 @@ export declare namespace hash {
  *
  * ```ts twoslash
  * // @noErrors
- * import { Secp256k1, TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { Secp256k1, TxEnvelopeLegacy, Value } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   chainId: 1,
  *   gasPrice: Value.fromGwei('10'),
  *   to: '0x0000000000000000000000000000000000000000',
@@ -451,11 +444,11 @@ export declare namespace hash {
  * })
  *
  * const signature = Secp256k1.sign({
- *   payload: TransactionEnvelopeLegacy.getSignPayload(envelope),
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope),
  *   privateKey: '0x...',
  * })
  *
- * const serialized = TransactionEnvelopeLegacy.serialize(envelope, { // [!code focus]
+ * const serialized = TxEnvelopeLegacy.serialize(envelope, { // [!code focus]
  *   signature, // [!code focus]
  * }) // [!code focus]
  *
@@ -467,7 +460,7 @@ export declare namespace hash {
  * @returns The serialized Transaction Envelope.
  */
 export function serialize(
-  envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>,
+  envelope: PartialBy<TxEnvelopeLegacy, 'type'>,
   options: serialize.Options = {},
 ): Serialized {
   const { chainId = 0, gas, data, input, nonce, to, value, gasPrice } = envelope
@@ -547,13 +540,13 @@ export declare namespace serialize {
 }
 
 /**
- * Converts an {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy} to an {@link ox#TransactionEnvelopeLegacy.Rpc}.
+ * Converts an {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy} to an {@link ox#TxEnvelopeLegacy.Rpc}.
  *
  * @example
  * ```ts twoslash
- * import { RpcRequest, TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { RpcRequest, TxEnvelopeLegacy, Value } from 'ox'
  *
- * const envelope = TransactionEnvelopeLegacy.from({
+ * const envelope = TxEnvelopeLegacy.from({
  *   chainId: 1,
  *   nonce: 0n,
  *   gas: 21000n,
@@ -561,7 +554,7 @@ export declare namespace serialize {
  *   value: Value.fromEther('1'),
  * })
  *
- * const envelope_rpc = TransactionEnvelopeLegacy.toRpc(envelope) // [!code focus]
+ * const envelope_rpc = TxEnvelopeLegacy.toRpc(envelope) // [!code focus]
  *
  * const request = RpcRequest.from({
  *   id: 0,
@@ -573,7 +566,7 @@ export declare namespace serialize {
  * @param envelope - The legacy transaction envelope to convert.
  * @returns An RPC-formatted legacy transaction envelope.
  */
-export function toRpc(envelope: Omit<TransactionEnvelopeLegacy, 'type'>): Rpc {
+export function toRpc(envelope: Omit<TxEnvelopeLegacy, 'type'>): Rpc {
   const signature = Signature.extract(envelope)!
 
   return {
@@ -610,13 +603,13 @@ export declare namespace toRpc {
 }
 
 /**
- * Validates a {@link ox#TransactionEnvelopeLegacy.TransactionEnvelopeLegacy}. Returns `true` if the envelope is valid, `false` otherwise.
+ * Validates a {@link ox#TxEnvelopeLegacy.TxEnvelopeLegacy}. Returns `true` if the envelope is valid, `false` otherwise.
  *
  * @example
  * ```ts twoslash
- * import { TransactionEnvelopeLegacy, Value } from 'ox'
+ * import { TxEnvelopeLegacy, Value } from 'ox'
  *
- * const valid = TransactionEnvelopeLegacy.assert({
+ * const valid = TxEnvelopeLegacy.assert({
  *   gasPrice: 2n ** 256n - 1n + 1n,
  *   chainId: 1,
  *   to: '0x0000000000000000000000000000000000000000',
@@ -627,9 +620,7 @@ export declare namespace toRpc {
  *
  * @param envelope - The transaction envelope to validate.
  */
-export function validate(
-  envelope: PartialBy<TransactionEnvelopeLegacy, 'type'>,
-) {
+export function validate(envelope: PartialBy<TxEnvelopeLegacy, 'type'>) {
   try {
     assert(envelope)
     return true

package/core/WebAuthnP256.ts

@@ -254,7 +254,8 @@ export function getCredentialCreationOptions(
     publicKey: {
       attestation,
       authenticatorSelection,
-      challenge,
+      challenge:
+        typeof challenge === 'string' ? Bytes.fromHex(challenge) : challenge,
       ...(excludeCredentialIds
         ? {
             excludeCredentials: excludeCredentialIds?.map((id) => ({
@@ -301,6 +302,7 @@ export declare namespace getCredentialCreationOptions {
      * An `ArrayBuffer`, `TypedArray`, or `DataView` used as a cryptographic challenge.
      */
     challenge?:
+      | Hex.Hex
       | internal.PublicKeyCredentialCreationOptions['challenge']
       | undefined
     /**

package/erc8021/Attribution.ts

@@ -31,12 +31,19 @@ export type AttributionSchemaId0 = {
 export type AttributionSchemaId1 = {
   /** Attribution codes identifying entities involved in the transaction. */
   codes: readonly string[]
-  /** Address of the custom code registry contract. */
-  codeRegistryAddress: Address.Address
+  /* The custom code registry contract. */
+  codeRegistry: AttributionSchemaId1Registry
   /** Schema identifier (1 for custom registry). */
   id?: 1 | undefined
 }
 
+export type AttributionSchemaId1Registry = {
+  /** Address of the custom code registry contract. */
+  address: Address.Address
+  /** Chain Id of the chain the custom code registry contract is deployed on. */
+  chainId: number
+}
+
 /**
  * Attribution schema identifier.
  *
@@ -71,7 +78,10 @@ export const ercSuffixSize = /*#__PURE__*/ Hex.size(ercSuffix)
  *
  * const schemaId2 = Attribution.getSchemaId({
  *   codes: ['baseapp'],
- *   codeRegistryAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
+ *   codeRegistry: {
+ *      address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+ *      chainId: 8453,
+ *   }
  * })
  * // @log: 1
  * ```
@@ -80,7 +90,7 @@ export const ercSuffixSize = /*#__PURE__*/ Hex.size(ercSuffix)
  * @returns The schema ID (0 for canonical registry, 1 for custom registry).
  */
 export function getSchemaId(attribution: Attribution): SchemaId {
-  if ('codeRegistryAddress' in attribution) return 1
+  if ('codeRegistry' in attribution) return 1
   return 0
 }
 
@@ -111,7 +121,10 @@ export declare namespace getSchemaId {
  *
  * const suffix = Attribution.toDataSuffix({
  *   codes: ['baseapp'],
- *   codeRegistryAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
+ *   codeRegistry: {
+ *      address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+ *      chainId: 8453,
+ *   }
  * })
  * ```
  *
@@ -133,15 +146,17 @@ export function toDataSuffix(attribution: Attribution): Hex.Hex {
   const schemaIdHex = Hex.fromNumber(schemaId, { size: 1 })
 
   // Build the suffix based on schema
-  if (schemaId === 1)
-    // Schema 1: codeRegistryAddress ∥ codes ∥ codesLength ∥ schemaId ∥ ercSuffix
+  if (schemaId === 1) {
+    const schema1 = attribution as AttributionSchemaId1
+    // Schema 1: codeRegistryAddress (20 bytes) ∥ chainId ∥ chainIdLength (1 byte) ∥ codes ∥ codesLength (1 byte) ∥ schemaId (1 byte) ∥ ercSuffix
     return Hex.concat(
-      attribution.codeRegistryAddress!.toLowerCase() as Address.Address,
+      registryToData(schema1.codeRegistry),
       codesHex,
       codesLengthHex,
       schemaIdHex,
       ercSuffix,
     )
+  }
 
   // Schema 0: codes ∥ codesLength ∥ schemaId ∥ ercSuffix
   return Hex.concat(codesHex, codesLengthHex, schemaIdHex, ercSuffix)
@@ -179,11 +194,14 @@ export declare namespace toDataSuffix {
  * import { Attribution } from 'ox/erc8021'
  *
  * const attribution = Attribution.fromData(
- *   '0xddddddddcccccccccccccccccccccccccccccccccccccccc626173656170702c6d6f7270686f0e0180218021802180218021802180218021'
+ *   '0xddddddddcccccccccccccccccccccccccccccccccccccccc210502626173656170702C6D6F7270686F0E0180218021802180218021802180218021'
  * )
  * // @log: {
  * // @log:   codes: ['baseapp', 'morpho'],
- * // @log:   codeRegistryAddress: '0xcccccccccccccccccccccccccccccccccccccccc',
+ * // @log:   registry: {
+ * // @log:       address: '0xcccccccccccccccccccccccccccccccccccccccc`
+ * // @log:       chainId: 8453,
+ * // @log:   }
  * // @log:   id: 1
  * // @log: }
  * ```
@@ -225,7 +243,7 @@ export function fromData(data: Hex.Hex): Attribution | undefined {
   }
 
   // Schema 1: Custom registry
-  // Format: codeRegistryAddress (20 bytes) ∥ codes ∥ codesLength (1 byte) ∥ schemaId (1 byte) ∥ ercSuffix
+  // Format: codeRegistryAddress (20 bytes) ∥ chainId ∥ chainIdLength (1 byte) ∥ codes ∥ codesLength (1 byte) ∥ schemaId (1 byte) ∥ ercSuffix
   if (schemaId === 1) {
     // Extract codes length (1 byte before schema ID)
     const codesLengthHex = Hex.slice(
@@ -242,13 +260,13 @@ export function fromData(data: Hex.Hex): Attribution | undefined {
     const codesString = Hex.toString(codesHex)
     const codes = codesString.length > 0 ? codesString.split(',') : []
 
-    // Extract registry address (20 bytes before codes)
-    const registryStart = codesStart - 20
-    const codeRegistryAddress = Hex.slice(data, registryStart, codesStart)
+    // Extract registry by reading backwards from just before codes
+    const codeRegistry = registryFromData(Hex.slice(data, 0, codesStart))
+    if (codeRegistry === undefined) return undefined
 
     return {
       codes,
-      codeRegistryAddress,
+      codeRegistry,
       id: 1,
     }
   }
@@ -257,6 +275,50 @@ export function fromData(data: Hex.Hex): Attribution | undefined {
   return undefined
 }
 
+function registryFromData(
+  data: Hex.Hex,
+): AttributionSchemaId1Registry | undefined {
+  // Expect at least: address (20 bytes) + chainIdLen (1 byte)
+  const minRegistrySize = 20 + 1
+  if (Hex.size(data) < minRegistrySize) return undefined
+
+  // Read chainId length from the last byte of the registry segment
+  const chainIdLenHex = Hex.slice(data, -1)
+  const chainIdLen = Hex.toNumber(chainIdLenHex)
+
+  if (chainIdLen === 0) return undefined
+
+  // Validate we have enough bytes to cover address + chainId + chainIdLen
+  const totalRegistrySize = 20 + chainIdLen + 1
+  if (Hex.size(data) < totalRegistrySize) return undefined
+
+  // Address is located immediately before chainId and chainIdLen (read from back)
+  const addressStart = -(chainIdLen + 1 + 20)
+  const addressEnd = -(chainIdLen + 1)
+  const addressHex = Hex.slice(data, addressStart, addressEnd)
+  // Chain ID occupies the bytes preceding the final length byte (read from back)
+  const chainIdHex = Hex.slice(data, -(chainIdLen + 1), -1)
+
+  const codeRegistry: AttributionSchemaId1Registry = {
+    address: addressHex as Address.Address,
+    chainId: Hex.toNumber(chainIdHex),
+  }
+
+  return codeRegistry
+}
+
+function registryToData(registry: AttributionSchemaId1Registry): Hex.Hex {
+  const chainIdAsHex = Hex.fromNumber(registry.chainId)
+  const chainIdLen = Hex.size(chainIdAsHex)
+  // Need to padleft because the output of size may not be a full byte (1 -> 0x1 vs 0x01)
+  const paddedChainId = Hex.padLeft(chainIdAsHex, chainIdLen)
+  return Hex.concat(
+    registry.address as Hex.Hex,
+    paddedChainId,
+    Hex.fromNumber(chainIdLen, { size: 1 }),
+  )
+}
+
 export declare namespace fromData {
   type ErrorType =
     | Hex.slice.ErrorType

package/index.docs.ts

@@ -7,3 +7,4 @@ export * from './erc6492/index.js'
 export * from './erc7821/index.js'
 export * from './erc8010/index.js'
 export * from './erc8021/index.js'
+export * from './tempo/index.js'