ox 0.14.26 → 0.14.28

package/_types/tempo/index.d.ts

@@ -100,6 +100,32 @@ export * as Channel from './Channel.js';
  * @category Reference
  */
 export * as KeyAuthorization from './KeyAuthorization.js';
+/**
+ * Native multisig account utilities (TIP-1061).
+ *
+ * Derives stable multisig account addresses and permanent config IDs from a weighted
+ * owner configuration, and computes the owner approval digest that owners sign.
+ *
+ * [TIP-1061](https://tips.sh/1061)
+ *
+ * @example
+ * ```ts twoslash
+ * import { MultisigConfig } from 'ox/tempo'
+ *
+ * const config = MultisigConfig.from({
+ *   threshold: 2,
+ *   owners: [
+ *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+ *     { owner: '0x2222222222222222222222222222222222222222', weight: 1 },
+ *   ],
+ * })
+ *
+ * const account = MultisigConfig.getAddress({ config })
+ * ```
+ *
+ * @category Reference
+ */
+export * as MultisigConfig from './MultisigConfig.js';
 /**
  * Utilities for constructing period durations (in seconds) for recurring spending limits.
  *
@@ -150,6 +176,28 @@ export * as Period from './Period.js';
  * @category Reference
  */
 export * as PoolId from './PoolId.js';
+/**
+ * TIP-1028 receive-policy claim receipt utilities.
+ *
+ * When an inbound transfer or mint violates the recipient's receive policy, the
+ * funds are redirected to the `ReceivePolicyGuard` and a `ClaimReceiptV1`
+ * witness is emitted. This module decodes those witnesses (required to later
+ * `claim` or `burn` the blocked funds) from raw bytes or transaction receipts.
+ *
+ * [TIP-1028](https://docs.tempo.xyz/protocol/tips/tip-1028)
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { ReceivePolicyReceipt } from 'ox/tempo'
+ *
+ * const receipts = ReceivePolicyReceipt.fromTransactionReceipt(receipt)
+ * const decoded = ReceivePolicyReceipt.decode('0x...')
+ * ```
+ *
+ * @category Reference
+ */
+export * as ReceivePolicyReceipt from './ReceivePolicyReceipt.js';
 /**
  * Union of all JSON-RPC Methods for the `tempo_` namespace.
  *

package/_types/tempo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,oBAAoB,MAAM,2BAA2B,CAAA;AACjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.26";
+export declare const version = "0.14.28";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.26",
+  "version": "0.14.28",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -513,6 +513,11 @@
       "import": "./_esm/tempo/KeyAuthorization.js",
       "default": "./_cjs/tempo/KeyAuthorization.js"
     },
+    "./tempo/MultisigConfig": {
+      "types": "./_types/tempo/MultisigConfig.d.ts",
+      "import": "./_esm/tempo/MultisigConfig.js",
+      "default": "./_cjs/tempo/MultisigConfig.js"
+    },
     "./tempo/Period": {
       "types": "./_types/tempo/Period.d.ts",
       "import": "./_esm/tempo/Period.js",
@@ -523,6 +528,11 @@
       "import": "./_esm/tempo/PoolId.js",
       "default": "./_cjs/tempo/PoolId.js"
     },
+    "./tempo/ReceivePolicyReceipt": {
+      "types": "./_types/tempo/ReceivePolicyReceipt.d.ts",
+      "import": "./_esm/tempo/ReceivePolicyReceipt.js",
+      "default": "./_cjs/tempo/ReceivePolicyReceipt.js"
+    },
     "./tempo/RpcSchemaTempo": {
       "types": "./_types/tempo/RpcSchemaTempo.d.ts",
       "import": "./_esm/tempo/RpcSchemaTempo.js",

package/tempo/MultisigConfig/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/MultisigConfig.d.ts",
+  "main": "../../_cjs/tempo/MultisigConfig.js",
+  "module": "../../_esm/tempo/MultisigConfig.js"
+}

package/tempo/MultisigConfig.test.ts

@@ -0,0 +1,227 @@
+import { MultisigConfig } from 'ox/tempo'
+import { describe, expect, test } from 'vitest'
+
+// Ground-truth vectors independently computed via `cast keccak` over the exact
+// preimages defined by TIP-1061 / the Tempo reference implementation.
+const owner1 = '0x1111111111111111111111111111111111111111'
+const owner2 = '0x2222222222222222222222222222222222222222'
+
+const singleOwnerConfig = {
+  threshold: 1,
+  owners: [{ owner: owner1, weight: 1 }],
+} as const
+
+describe('from', () => {
+  test('sorts owners ascending by address', () => {
+    const config = MultisigConfig.from({
+      threshold: 2,
+      owners: [
+        { owner: owner2, weight: 1 },
+        { owner: owner1, weight: 1 },
+      ],
+    })
+    expect(config.owners.map((o) => o.owner)).toEqual([owner1, owner2])
+  })
+
+  test('asserts validity', () => {
+    expect(() =>
+      MultisigConfig.from({ threshold: 0, owners: [] }),
+    ).toThrowError()
+  })
+})
+
+describe('configId', () => {
+  test('matches independent ground truth', () => {
+    expect(MultisigConfig.toId(singleOwnerConfig)).toMatchInlineSnapshot(
+      `"0xd1f20e1a5bfdd89488f57f68db5bd1aae9a51b510f4a042b2604b57a0b7b471d"`,
+    )
+  })
+
+  test('is stable across calls', () => {
+    expect(MultisigConfig.toId(singleOwnerConfig)).toBe(
+      MultisigConfig.toId(singleOwnerConfig),
+    )
+  })
+
+  test('differs for a different salt', () => {
+    expect(MultisigConfig.toId(singleOwnerConfig)).not.toBe(
+      MultisigConfig.toId({
+        ...singleOwnerConfig,
+        salt: `0x${'42'.repeat(32)}`,
+      }),
+    )
+  })
+
+  test('throws on invalid config', () => {
+    expect(() =>
+      MultisigConfig.toId({
+        threshold: 5,
+        owners: singleOwnerConfig.owners,
+      }),
+    ).toThrowError()
+  })
+})
+
+describe('getAddress', () => {
+  test('matches independent ground truth', () => {
+    expect(
+      MultisigConfig.getAddress({ config: singleOwnerConfig }),
+    ).toMatchInlineSnapshot(`"0x6ca655065b1de473d903eebd50e5cb4996e10468"`)
+  })
+
+  test('derives from config or configId identically', () => {
+    const configId = MultisigConfig.toId(singleOwnerConfig)
+    expect(MultisigConfig.getAddress({ configId })).toBe(
+      MultisigConfig.getAddress({ config: singleOwnerConfig }),
+    )
+  })
+
+  test('config ID and address are chain-independent', () => {
+    // Derivation does not include chain ID; identical config → identical id/address.
+    const a = MultisigConfig.toId(singleOwnerConfig)
+    const b = MultisigConfig.toId(MultisigConfig.from(singleOwnerConfig))
+    expect(a).toBe(b)
+  })
+})
+
+describe('getSignPayload', () => {
+  test('matches independent ground truth', () => {
+    const configId = MultisigConfig.toId(singleOwnerConfig)
+    const account = MultisigConfig.getAddress({ configId })
+    expect(
+      MultisigConfig.getSignPayload({
+        payload: `0x${'42'.repeat(32)}`,
+        account,
+        configId,
+      }),
+    ).toMatchInlineSnapshot(
+      `"0xe3d66f6118b89a67c71c8137c46abf0c829056a46ee6a038a1b42c84529fc17e"`,
+    )
+  })
+})
+
+describe('toTuple / fromTuple', () => {
+  test('round-trips', () => {
+    const config = MultisigConfig.from({
+      threshold: 3,
+      owners: [
+        { owner: owner1, weight: 1 },
+        { owner: owner2, weight: 2 },
+      ],
+    })
+    const tuple = MultisigConfig.toTuple(config)
+    expect(MultisigConfig.fromTuple(tuple)).toEqual(config)
+  })
+
+  test('encodes each owner as `[owner, weight]`', () => {
+    const [, , owners] = MultisigConfig.toTuple(singleOwnerConfig)
+    expect(owners[0]).toEqual([owner1, '0x1'])
+  })
+
+  test('encodes salt as a full 32-byte string (first element)', () => {
+    const [salt] = MultisigConfig.toTuple(singleOwnerConfig)
+    expect(salt).toBe(MultisigConfig.zeroSalt)
+  })
+
+  test('round-trips a non-zero salt', () => {
+    const config = MultisigConfig.from({
+      ...singleOwnerConfig,
+      salt: `0x${'42'.repeat(32)}`,
+    })
+    const tuple = MultisigConfig.toTuple(config)
+    expect(tuple[0]).toBe(`0x${'42'.repeat(32)}`)
+    expect(MultisigConfig.fromTuple(tuple)).toEqual(config)
+  })
+})
+
+describe('assert / validate', () => {
+  test('valid config', () => {
+    expect(MultisigConfig.validate(singleOwnerConfig)).toBe(true)
+  })
+
+  test('empty owners', () => {
+    expect(MultisigConfig.validate({ threshold: 1, owners: [] })).toBe(false)
+  })
+
+  test('too many owners', () => {
+    const owners = Array.from({ length: 11 }, (_, i) => ({
+      owner: `0x${(i + 1).toString(16).padStart(40, '0')}` as `0x${string}`,
+      weight: 1,
+    }))
+    expect(MultisigConfig.validate({ threshold: 1, owners })).toBe(false)
+  })
+
+  test('zero threshold', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 0,
+        owners: singleOwnerConfig.owners,
+      }),
+    ).toBe(false)
+  })
+
+  test('threshold exceeds total weight', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 2,
+        owners: singleOwnerConfig.owners,
+      }),
+    ).toBe(false)
+  })
+
+  test('zero owner weight', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1,
+        owners: [{ owner: owner1, weight: 0 }],
+      }),
+    ).toBe(false)
+  })
+
+  test('zero owner address', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1,
+        owners: [
+          {
+            owner: '0x0000000000000000000000000000000000000000',
+            weight: 1,
+          },
+        ],
+      }),
+    ).toBe(false)
+  })
+
+  test('unsorted owners', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1,
+        owners: [
+          { owner: owner2, weight: 1 },
+          { owner: owner1, weight: 1 },
+        ],
+      }),
+    ).toBe(false)
+  })
+
+  test('duplicate owners', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1,
+        owners: [
+          { owner: owner1, weight: 1 },
+          { owner: owner1, weight: 1 },
+        ],
+      }),
+    ).toBe(false)
+  })
+
+  test('invalid salt size', () => {
+    expect(
+      MultisigConfig.validate({
+        ...singleOwnerConfig,
+        salt: '0x42',
+      }),
+    ).toBe(false)
+  })
+})