ox 1.0.2 → 1.0.4

package/src/tempo/e2e.test.ts

@@ -14,7 +14,6 @@ import { chain, client, fundAddress, nodeEnv } from '../../test/tempo/config.js'
 import {
   AuthorizationTempo,
   KeyAuthorization,
-  MultisigConfig,
   Period,
   SignatureEnvelope,
 } from './index.js'
@@ -2968,418 +2967,3 @@ describe('behavior: keyAuthorization', () => {
     },
   )
 })
-
-// TODO: unskip once TIP-1061 native multisig is deployed to the standard
-// localnet/testnet nodes. Until then these only pass against the dedicated
-// PR-5178 devnet (run with VITE_TEMPO_RPC_URL pointed at it).
-describe.skip('behavior: multisig (TIP-1061)', () => {
-  // Helper: builds a fresh set of secp256k1 owners + the derived config.
-  function setup(parameters: { count: number; threshold: number }) {
-    const { count, threshold } = parameters
-    const ownerKeys = Array.from({ length: count }, () => {
-      const privateKey = Secp256k1.randomPrivateKey()
-      const address = Address.fromPublicKey(
-        Secp256k1.getPublicKey({ privateKey }),
-      )
-      return { address, privateKey } as const
-    })
-
-    const genesisConfig = MultisigConfig.from({
-      // A fresh random salt yields a distinct account each run, exercising the
-      // salt-inclusive account derivation against the node.
-      salt: Hex.random(32),
-      threshold,
-      owners: ownerKeys.map((key) => ({
-        owner: key.address,
-        weight: 1,
-      })),
-    })
-    const account = MultisigConfig.getAddress(genesisConfig)
-
-    return { account, genesisConfig, ownerKeys } as const
-  }
-
-  // Signs the multisig owner digest with the provided owner keys, returning
-  // primitive approval envelopes ordered strictly ascending by recovered owner
-  // address (required by the node: "recovered owners must be strictly
-  // ascending").
-  function approve(parameters: {
-    genesisConfig: MultisigConfig.Config
-    payload: Hex.Hex
-    signers: readonly { privateKey: Hex.Hex }[]
-  }) {
-    const { genesisConfig, payload, signers } = parameters
-    const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
-    const signatures = signers.map((signer) =>
-      SignatureEnvelope.from(
-        Secp256k1.sign({ payload: digest, privateKey: signer.privateKey }),
-      ),
-    )
-    return SignatureEnvelope.sortMultisigApprovals({
-      genesisConfig,
-      payload,
-      signatures,
-    })
-  }
-
-  test('behavior: bootstrap + spend (2-of-3 secp256k1)', async () => {
-    const { account, genesisConfig, ownerKeys } = setup({
-      count: 3,
-      threshold: 2,
-    })
-
-    // The derived multisig account pays its own fees.
-    await fundAddress(client, { address: account })
-
-    // Bootstrap (first transaction): the bootstrap config travels in the
-    // multisig signature `init`, nonce 0.
-    const bootstrap = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: 0n,
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        // Initialize multisig.
-        init: true,
-        // Approve with 2 of the 3 owners to satisfy the threshold.
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
-          signers: [ownerKeys[0]!, ownerKeys[1]!],
-        }),
-      }),
-    })
-
-    const bootstrap_receipt = (await client
-      .request({
-        method: 'eth_sendRawTransactionSync',
-        params: [bootstrap_signed],
-      })
-      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
-    expect(bootstrap_receipt).toBeDefined()
-    expect(bootstrap_receipt.status).toBe('success')
-    expect(bootstrap_receipt.from).toBe(account)
-
-    {
-      const response = await client
-        .request({
-          method: 'eth_getTransactionByHash',
-          params: [bootstrap_receipt.transactionHash],
-        })
-        .then((tx) => Transaction.fromRpc(tx as any))
-      if (!response) throw new Error()
-      expect(response.from).toBe(account)
-      expect(response.signature?.type).toBe('multisig')
-      // The bootstrap config is carried by the multisig signature `init`.
-      expect(
-        (response.signature as SignatureEnvelope.Multisig | undefined)?.init,
-      ).toEqual(genesisConfig)
-    }
-
-    // Spend (subsequent transaction): no signature `init`, nonce 1, uses the
-    // stored config loaded by the node.
-    const nonce = await getTransactionCount(client, {
-      address: account,
-      blockTag: 'pending',
-    })
-
-    const spend = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: BigInt(nonce),
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const spend_signed = TxEnvelopeTempo.serialize(spend, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        // A different 2-of-3 subset still authorizes the transaction.
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(spend),
-          signers: [ownerKeys[1]!, ownerKeys[2]!],
-        }),
-      }),
-    })
-
-    const spend_receipt = (await client
-      .request({
-        method: 'eth_sendRawTransactionSync',
-        params: [spend_signed],
-      })
-      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
-    expect(spend_receipt).toBeDefined()
-    expect(spend_receipt.status).toBe('success')
-    expect(spend_receipt.from).toBe(account)
-  })
-
-  test('behavior: rejects below-threshold approvals', async () => {
-    const { account, genesisConfig, ownerKeys } = setup({
-      count: 3,
-      threshold: 2,
-    })
-
-    await fundAddress(client, { address: account })
-
-    const bootstrap = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: 0n,
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        // Opt into bootstrap: writes `genesisConfig` into the signature `init`.
-        init: true,
-        // Only one approval — below the threshold of 2.
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
-          signers: [ownerKeys[0]!],
-        }),
-      }),
-    })
-
-    await expect(
-      client.request({
-        method: 'eth_sendRawTransactionSync',
-        params: [serialized_signed],
-      }),
-    ).rejects.toThrow()
-  })
-
-  test('behavior: keychain access key (authorize via AccountKeychain + spend)', async () => {
-    const { account, genesisConfig, ownerKeys } = setup({
-      count: 2,
-      threshold: 2,
-    })
-
-    await fundAddress(client, { address: account })
-
-    // Fresh secp256k1 access key for the multisig account.
-    const access = (() => {
-      const privateKey = Secp256k1.randomPrivateKey()
-      const address = Address.fromPublicKey(
-        Secp256k1.getPublicKey({ privateKey }),
-      )
-      return { address, privateKey } as const
-    })()
-
-    // Bootstrap the multisig (nonce 0).
-    const bootstrap = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: 0n,
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        init: true,
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
-          signers: ownerKeys,
-        }),
-      }),
-    })
-
-    const bootstrap_receipt = (await client
-      .request({
-        method: 'eth_sendRawTransactionSync',
-        params: [bootstrap_signed],
-      })
-      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
-    expect(bootstrap_receipt.status).toBe('success')
-
-    // Authorize the access key (nonce 1): multisig transactions cannot carry
-    // a TIP-1049 `keyAuthorization`, so the multisig account calls the
-    // AccountKeychain precompile's `authorizeKey` directly.
-    const authorizeKey = AbiFunction.from(
-      'function authorizeKey(address keyId, uint8 signatureType, (uint64 expiry, bool enforceLimits, (address token, uint256 amount, uint64 period)[] limits, bool allowAnyCalls, (address target, (bytes4 selector, address[] recipients)[] selectorRules)[] allowedCalls) config)',
-    )
-
-    const authorize = TxEnvelopeTempo.from({
-      calls: [
-        {
-          to: '0xaaaaaaaa00000000000000000000000000000000',
-          data: AbiFunction.encodeData(authorizeKey, [
-            access.address,
-            0, // secp256k1
-            {
-              expiry: 18446744073709551615n, // u64 max (never expires)
-              enforceLimits: false,
-              limits: [],
-              allowAnyCalls: true,
-              allowedCalls: [],
-            },
-          ]),
-        },
-      ],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: 1n,
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const authorize_signed = TxEnvelopeTempo.serialize(authorize, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(authorize),
-          signers: ownerKeys,
-        }),
-      }),
-    })
-
-    const authorize_receipt = (await client
-      .request({
-        method: 'eth_sendRawTransactionSync',
-        params: [authorize_signed],
-      })
-      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
-    expect(authorize_receipt.status).toBe('success')
-    expect(authorize_receipt.from).toBe(account)
-
-    // Spend with the access key (nonce 2): outer keychain signature with the
-    // multisig account as `userAddress` — no owner approvals involved.
-    const nonce = await getTransactionCount(client, {
-      address: account,
-      blockTag: 'pending',
-    })
-
-    const spend = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      nonce: BigInt(nonce),
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const spend_signature = Secp256k1.sign({
-      payload: TxEnvelopeTempo.getSignPayload(spend, { from: account }),
-      privateKey: access.privateKey,
-    })
-
-    const spend_signed = TxEnvelopeTempo.serialize(spend, {
-      signature: SignatureEnvelope.from({
-        userAddress: account,
-        inner: SignatureEnvelope.from(spend_signature),
-        type: 'keychain',
-      }),
-    })
-
-    const spend_receipt = (await client
-      .request({
-        method: 'eth_sendRawTransactionSync',
-        params: [spend_signed],
-      })
-      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
-    expect(spend_receipt.status).toBe('success')
-    expect(spend_receipt.from).toBe(account)
-
-    {
-      const response = await client
-        .request({
-          method: 'eth_getTransactionByHash',
-          params: [spend_receipt.transactionHash],
-        })
-        .then((tx) => Transaction.fromRpc(tx as any))
-      if (!response) throw new Error()
-      expect(response.from).toBe(account)
-      expect(response.signature?.type).toBe('keychain')
-      expect(
-        (response.signature as SignatureEnvelope.Keychain | undefined)
-          ?.userAddress,
-      ).toBe(account)
-    }
-  })
-
-  test('behavior: rejects `keyAuthorization` on multisig transactions', async () => {
-    const { account, genesisConfig, ownerKeys } = setup({
-      count: 1,
-      threshold: 1,
-    })
-
-    await fundAddress(client, { address: account })
-
-    const access = (() => {
-      const privateKey = Secp256k1.randomPrivateKey()
-      const address = Address.fromPublicKey(
-        Secp256k1.getPublicKey({ privateKey }),
-      )
-      return { address, privateKey } as const
-    })()
-
-    // TIP-1049 key authorizations are only valid on primitive/keychain
-    // transactions; multisig accounts must call the AccountKeychain
-    // precompile instead.
-    const keyAuth = KeyAuthorization.from({
-      address: access.address,
-      chainId: BigInt(chainId),
-      type: 'secp256k1',
-    })
-    const keyAuth_signed = KeyAuthorization.from(keyAuth, {
-      signature: SignatureEnvelope.from(
-        Secp256k1.sign({
-          payload: KeyAuthorization.getSignPayload(keyAuth),
-          privateKey: ownerKeys[0]!.privateKey,
-        }),
-      ),
-    })
-
-    const bootstrap = TxEnvelopeTempo.from({
-      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
-      chainId,
-      feeToken: '0x20c0000000000000000000000000000000000001',
-      keyAuthorization: keyAuth_signed,
-      nonce: 0n,
-      gas: 2_000_000n,
-      maxFeePerGas: Value.fromGwei('20'),
-      maxPriorityFeePerGas: Value.fromGwei('10'),
-    })
-
-    const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
-      signature: SignatureEnvelope.from({
-        genesisConfig,
-        init: true,
-        signatures: approve({
-          genesisConfig,
-          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
-          signers: ownerKeys,
-        }),
-      }),
-    })
-
-    await expect(
-      client.request({
-        method: 'eth_sendRawTransactionSync',
-        params: [serialized_signed],
-      }),
-    ).rejects.toThrow()
-  })
-})

package/src/tempo/index.ts

@@ -68,6 +68,28 @@ export * as AuthorizationTempo from './AuthorizationTempo.js'
  * @category Reference
  */
 export * as Channel from './Channel.js'
+/**
+ * Tempo Earn `VaultAdapter` share math: raw vault-share and venue-share conversions
+ * at the anchor rate, the dilution-correct fee-share formula, and the
+ * `minimumOutput` slippage floor.
+ *
+ * Conversions are fee-blind mirrors of the adapter's anchor arithmetic; use the
+ * adapter's `previewRedeem` for user-facing value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const shareAmount = EarnShares.toAmount(
+ *   { engineShares: 3n, shareSupply: 2n },
+ *   7n
+ * )
+ * // @log: 4n
+ * ```
+ *
+ * @category Reference
+ */
+export * as EarnShares from './EarnShares.js'
 /**
  * Tempo key authorization utilities for provisioning and signing access keys.
  *