ox 1.0.0-beta.0 → 1.0.0-beta.2

package/src/tempo/MultisigConfig.ts

@@ -3,7 +3,7 @@ import type * as Bytes from '../core/Bytes.js'
 import * as Errors from '../core/Errors.js'
 import * as Hash from '../core/Hash.js'
 import * as Hex from '../core/Hex.js'
-import type { Compute } from '../core/internal/types.js'
+import type { Compute, OneOf } from '../core/internal/types.js'
 
 /** Maximum number of owners allowed in a native multisig config. */
 export const maxOwners = 10
@@ -212,7 +212,7 @@ export function fromTuple(tuple: Tuple): Config {
  * ```ts twoslash
  * import { MultisigConfig } from 'ox/tempo'
  *
- * const config = MultisigConfig.from({
+ * const genesisConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     {
@@ -222,20 +222,47 @@ export function fromTuple(tuple: Tuple): Config {
  *   ]
  * })
  *
- * const address = MultisigConfig.getAddress({ config })
+ * const address = MultisigConfig.getAddress(genesisConfig)
+ * ```
+ *
+ * @example
+ * ### From an genesis config ID
+ *
+ * If you already have the permanent `genesisConfigId`, pass it directly:
+ *
+ * ```ts twoslash
+ * import { MultisigConfig } from 'ox/tempo'
+ *
+ * const genesisConfigId = `0x${'00'.repeat(32)}` as const
+ *
+ * const address = MultisigConfig.getAddress({
+ *   genesisConfigId
+ * })
  * ```
  *
- * @param value - The config or config ID to derive the address from.
+ * @param value - The genesis config (positional) or `{ genesisConfigId }`.
  * @returns The multisig account address.
  */
 export function getAddress(value: getAddress.Value): Address.Address {
-  const id = 'configId' in value ? value.configId : toId(value.config)
+  const id =
+    typeof value === 'object' && 'genesisConfigId' in value
+      ? value.genesisConfigId
+      : toId(value)
   const hash = Hash.keccak256(Hex.concat(Hex.fromString(accountDomain), id))
   return Address.from(Hex.slice(hash, 12, 32))
 }
 
 export declare namespace getAddress {
-  type Value = { config: Config } | { configId: Hex.Hex }
+  type Value =
+    | Config
+    | {
+        /**
+         * The permanent genesis config ID (`MultisigConfig.toId(genesisConfig)`).
+         * Config updates never change this value, so it identifies the
+         * account permanently.
+         */
+        genesisConfigId: Hex.Hex
+      }
 
   type ErrorType =
     | toId.ErrorType
@@ -253,11 +280,16 @@ export declare namespace getAddress {
  * where `inner_digest` is the transaction sign payload
  * ({@link ox#TxEnvelopeTempo.(getSignPayload:function)}).
  *
+ * The digest is always keyed on the permanent `account`/`genesisConfigId`
+ * derived from the genesis (bootstrap) config — config updates never change
+ * these values, so the genesis config is the correct input even for
+ * post-update transactions.
+ *
  * @example
  * ```ts twoslash
  * import { MultisigConfig, TxEnvelopeTempo } from 'ox/tempo'
  *
- * const config = MultisigConfig.from({
+ * const genesisConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     {
@@ -266,8 +298,38 @@ export declare namespace getAddress {
  *     }
  *   ]
  * })
- * const configId = MultisigConfig.toId(config)
- * const account = MultisigConfig.getAddress({ configId })
+ *
+ * const envelope = TxEnvelopeTempo.from({
+ *   chainId: 1,
+ *   calls: []
+ * })
+ *
+ * const digest = MultisigConfig.getSignPayload({
+ *   payload: TxEnvelopeTempo.getSignPayload(envelope),
+ *   genesisConfig
+ * })
+ * ```
+ *
+ * @example
+ * ### From `account` + `genesisConfigId`
+ *
+ * If you already have the permanent `account` and `genesisConfigId` (for
+ * example, recovered from a stored envelope), pass them directly:
+ *
+ * ```ts twoslash
+ * import { MultisigConfig, TxEnvelopeTempo } from 'ox/tempo'
+ *
+ * const genesisConfig = MultisigConfig.from({
+ *   threshold: 1,
+ *   owners: [
+ *     {
+ *       owner: '0x1111111111111111111111111111111111111111',
+ *       weight: 1
+ *     }
+ *   ]
+ * })
+ * const genesisConfigId = MultisigConfig.toId(genesisConfig)
+ * const account = MultisigConfig.getAddress(genesisConfig)
  *
  * const envelope = TxEnvelopeTempo.from({
  *   chainId: 1,
@@ -277,7 +339,7 @@ export declare namespace getAddress {
  * const digest = MultisigConfig.getSignPayload({
  *   payload: TxEnvelopeTempo.getSignPayload(envelope),
  *   account,
- *   configId
+ *   genesisConfigId
  * })
  * ```
  *
@@ -285,13 +347,21 @@ export declare namespace getAddress {
  * @returns The owner approval digest.
  */
 export function getSignPayload(value: getSignPayload.Value): Hex.Hex {
-  const { payload, account, configId } = value
+  const { payload } = value
+  const account =
+    'account' in value && value.account
+      ? value.account
+      : getAddress((value as { genesisConfig: Config }).genesisConfig)
+  const genesisConfigId =
+    'genesisConfigId' in value && value.genesisConfigId
+      ? value.genesisConfigId
+      : toId((value as { genesisConfig: Config }).genesisConfig)
   return Hash.keccak256(
     Hex.concat(
       Hex.fromString(signatureDomain),
       Hex.from(payload),
       account,
-      configId,
+      genesisConfigId,
     ),
   )
 }
@@ -300,13 +370,28 @@ export declare namespace getSignPayload {
   type Value = {
     /** The inner transaction sign payload (`tx.signature_hash()`). */
     payload: Hex.Hex | Bytes.Bytes
-    /** The native multisig account address. */
-    account: Address.Address
-    /** The permanent config ID. */
-    configId: Hex.Hex
-  }
+  } & OneOf<
+    | {
+        /** The native multisig account address. */
+        account: Address.Address
+        /** The permanent config ID. */
+        genesisConfigId: Hex.Hex
+      }
+    | {
+        /**
+         * The initial multisig config (the bootstrap config that derived the
+         * permanent `account` and `genesisConfigId`). Used to derive both values
+         * automatically. Config updates never change `account`/`genesisConfigId`,
+         * so the genesis config is also the correct input for post-update
+         * transactions.
+         */
+        genesisConfig: Config
+      }
+  >
 
   type ErrorType =
+    | getAddress.ErrorType
+    | toId.ErrorType
     | Hash.keccak256.ErrorType
     | Hex.concat.ErrorType
     | Hex.from.ErrorType
@@ -334,7 +419,7 @@ export declare namespace getSignPayload {
  *   ]
  * })
  *
- * const configId = MultisigConfig.toId(config)
+ * const genesisConfigId = MultisigConfig.toId(config)
  * ```
  *
  * @param config - The multisig config.

package/src/tempo/SignatureEnvelope.test.ts

@@ -1113,6 +1113,80 @@ describe('from', () => {
       expect(envelope.keyId).toBe(explicitKeyId)
     })
   })
+
+  describe('multisig', () => {
+    const genesisConfig = MultisigConfig.from({
+      threshold: 1,
+      owners: [
+        {
+          owner: '0x1111111111111111111111111111111111111111',
+          weight: 1,
+        },
+      ],
+    })
+
+    test('behavior: derives `account`/`genesisConfigId` from `genesisConfig`', () => {
+      const envelope = SignatureEnvelope.from({
+        genesisConfig,
+        signatures: [SignatureEnvelope.from(signature_secp256k1)],
+      })
+
+      expect(envelope).toMatchObject({
+        type: 'multisig',
+        account: MultisigConfig.getAddress(genesisConfig),
+        genesisConfigId: MultisigConfig.toId(genesisConfig),
+      })
+      expect('genesisConfig' in envelope).toBe(false)
+      expect((envelope as SignatureEnvelope.Multisig).init).toBeUndefined()
+    })
+
+    test('behavior: `init: true` opts into bootstrap (uses `genesisConfig` as `init`)', () => {
+      const envelope = SignatureEnvelope.from({
+        genesisConfig,
+        signatures: [SignatureEnvelope.from(signature_secp256k1)],
+        init: true,
+      })
+
+      expect((envelope as SignatureEnvelope.Multisig).init).toEqual(
+        genesisConfig,
+      )
+    })
+
+    test('behavior: `init` accepts an explicit config', () => {
+      const otherConfig = MultisigConfig.from({
+        threshold: 1,
+        owners: [
+          {
+            owner: '0x2222222222222222222222222222222222222222',
+            weight: 1,
+          },
+        ],
+      })
+      const envelope = SignatureEnvelope.from({
+        genesisConfig,
+        signatures: [SignatureEnvelope.from(signature_secp256k1)],
+        init: otherConfig,
+      })
+
+      expect((envelope as SignatureEnvelope.Multisig).init).toEqual(otherConfig)
+    })
+
+    test('behavior: `{account, genesisConfigId}` form still works', () => {
+      const account = MultisigConfig.getAddress(genesisConfig)
+      const genesisConfigId = MultisigConfig.toId(genesisConfig)
+      const envelope = SignatureEnvelope.from({
+        account,
+        genesisConfigId,
+        signatures: [SignatureEnvelope.from(signature_secp256k1)],
+      })
+
+      expect(envelope).toMatchObject({
+        type: 'multisig',
+        account,
+        genesisConfigId,
+      })
+    })
+  })
 })
 
 describe('getType', () => {
@@ -1722,33 +1796,40 @@ describe('serialize', () => {
 })
 
 describe('sortMultisigApprovals', () => {
-  const account = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as const
-  const configId = `0x${'11'.repeat(32)}` as const
-  const payload = `0x${'42'.repeat(32)}` as const
-  const digest = MultisigConfig.getSignPayload({
-    account,
-    configId,
-    payload,
-  })
-
-  const owners = Array.from({ length: 3 }, () => {
+  // Build owner key pairs first so we can construct a real genesis config
+  // whose owner set matches the keys that produce the approvals below.
+  const ownerKeys = Array.from({ length: 3 }, () => {
     const privateKey = Secp256k1.randomPrivateKey()
     const address = Address.fromPublicKey(
       Secp256k1.getPublicKey({ privateKey }),
     )
-    const signature = SignatureEnvelope.from(
-      Secp256k1.sign({ payload: digest, privateKey }),
-    )
-    return { address, signature } as const
+    return { address, privateKey } as const
   })
-  const ascending = [...owners].sort((a, b) =>
+  const ascendingOwners = [...ownerKeys].sort((a, b) =>
     Hex.toBigInt(a.address) < Hex.toBigInt(b.address) ? -1 : 1,
   )
 
+  const genesisConfig = MultisigConfig.from({
+    threshold: 2,
+    owners: ascendingOwners.map((o) => ({ owner: o.address, weight: 1 })),
+  })
+  const payload = `0x${'42'.repeat(32)}` as const
+  const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
+
+  const owners = ownerKeys.map((owner) => ({
+    address: owner.address,
+    signature: SignatureEnvelope.from(
+      Secp256k1.sign({ payload: digest, privateKey: owner.privateKey }),
+    ),
+  }))
+  const ascending = ascendingOwners.map((o) => ({
+    address: o.address,
+    signature: owners.find((x) => x.address === o.address)!.signature,
+  }))
+
   test('behavior: orders approvals ascending by recovered owner address', () => {
     const ordered = SignatureEnvelope.sortMultisigApprovals({
-      account,
-      configId,
+      genesisConfig,
       payload,
       // Provide approvals in reverse of the canonical order.
       signatures: [...ascending].reverse().map((owner) => owner.signature),
@@ -1760,8 +1841,7 @@ describe('sortMultisigApprovals', () => {
     const signatures = ascending.map((owner) => owner.signature)
     expect(
       SignatureEnvelope.sortMultisigApprovals({
-        account,
-        configId,
+        genesisConfig,
         payload,
         signatures,
       }),
@@ -1770,8 +1850,7 @@ describe('sortMultisigApprovals', () => {
 
   test('behavior: recovered order matches the config owner order', () => {
     const ordered = SignatureEnvelope.sortMultisigApprovals({
-      account,
-      configId,
+      genesisConfig,
       payload,
       signatures: owners.map((owner) => owner.signature),
     })
@@ -1780,6 +1859,25 @@ describe('sortMultisigApprovals', () => {
     )
     expect(recovered).toEqual(ascending.map((owner) => owner.address))
   })
+
+  test('behavior: `genesisConfig` and `{account, genesisConfigId}` produce identical ordering', () => {
+    const account = MultisigConfig.getAddress(genesisConfig)
+    const genesisConfigId = MultisigConfig.toId(genesisConfig)
+    const signatures = owners.map((owner) => owner.signature)
+
+    const fromConfig = SignatureEnvelope.sortMultisigApprovals({
+      genesisConfig,
+      payload,
+      signatures,
+    })
+    const fromIds = SignatureEnvelope.sortMultisigApprovals({
+      account,
+      genesisConfigId,
+      payload,
+      signatures,
+    })
+    expect(fromConfig).toEqual(fromIds)
+  })
 })
 
 describe('validate', () => {
@@ -2785,7 +2883,7 @@ describe('CoercionError', () => {
 
 describe('multisig', () => {
   const account = '0x8ba6d26ff5c4e82ba0c8caf8c8ca794e1489a7ae'
-  const configId =
+  const genesisConfigId =
     '0x01781fe551182476f2422c759e82d81c92e3263737afbbad57def6e8b69d21f5'
 
   // P256 signatures do not carry `yParity` in the wire format, so use a clean
@@ -2799,7 +2897,7 @@ describe('multisig', () => {
   const envelope = SignatureEnvelope.from({
     type: 'multisig',
     account,
-    configId,
+    genesisConfigId,
     signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
   })
 
@@ -2853,7 +2951,7 @@ describe('multisig', () => {
     const bootstrapEnvelope = SignatureEnvelope.from({
       type: 'multisig',
       account,
-      configId,
+      genesisConfigId,
       signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
       init,
     })
@@ -2869,7 +2967,7 @@ describe('multisig', () => {
       const salted = SignatureEnvelope.from({
         type: 'multisig',
         account,
-        configId,
+        genesisConfigId,
         signatures: [SignatureEnvelope.from(signature_secp256k1), innerP256],
         init: { ...init, salt: `0x${'42'.repeat(32)}` },
       })
@@ -2923,7 +3021,7 @@ describe('multisig', () => {
         SignatureEnvelope.assert({
           type: 'multisig',
           account,
-          configId,
+          genesisConfigId,
           signatures: [],
           init: { threshold: 1, owners: [] },
         } as never),