ox 1.0.2 → 1.0.4

package/dist/zod/tempo/TxEnvelopeTempo.d.ts

@@ -189,24 +189,6 @@ export declare const TxEnvelopeTempo: z.ZodMiniObject<{
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
@@ -258,24 +240,6 @@ export declare const TxEnvelopeTempo: z.ZodMiniObject<{
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
@@ -470,24 +434,6 @@ export declare const Signed: z.ZodMiniObject<{
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
@@ -539,24 +485,6 @@ export declare const Signed: z.ZodMiniObject<{
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
@@ -751,24 +679,6 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
@@ -820,24 +730,6 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
                 s: z.ZodMiniTemplateLiteral<`0x${string}`>;
             }, z.core.$strip>;
             type: z.ZodMiniLiteral<"webAuthn">;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            inner: z.ZodMiniLazy<z.ZodMiniType<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown, z.core.$ZodTypeInternals<import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>, unknown>>>;
-            keyId: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-            type: z.ZodMiniLiteral<"keychain">;
-            userAddress: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
-        }, z.core.$strip>, z.ZodMiniObject<{
-            account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            init: z.ZodMiniOptional<z.ZodMiniObject<{
-                salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
-                threshold: z.ZodMiniNumber<number>;
-                owners: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniObject<{
-                    owner: z.ZodMiniTemplateLiteral<`0x${string}`>;
-                    weight: z.ZodMiniNumber<number>;
-                }, z.core.$strip>>>;
-            }, z.core.$strip>>;
-            signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
-            type: z.ZodMiniLiteral<"multisig">;
         }, z.core.$strip>]>;
         type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"secp256k1">, z.ZodMiniLiteral<"p256">, z.ZodMiniLiteral<"webAuthn">]>;
         witness: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;

package/dist/zod/tempo/TxEnvelopeTempo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TxEnvelopeTempo.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/TxEnvelopeTempo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAY7B,8CAA8C;AAC9C,eAAO,MAAM,IAAI,2BAAqB,CAAA;AAEtC,qCAAqC;AACrC,eAAO,MAAM,IAAI;;;;iBAIf,CAAA;AAqBF,yCAAyC;AACzC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjB,CAAA;AAEF,yFAAyF;AACzF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASrB,CAAA"}
+{"version":3,"file":"TxEnvelopeTempo.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/TxEnvelopeTempo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAY7B,8CAA8C;AAC9C,eAAO,MAAM,IAAI,2BAAqB,CAAA;AAEtC,qCAAqC;AACrC,eAAO,MAAM,IAAI;;;;iBAIf,CAAA;AAqBF,yCAAyC;AACzC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjB,CAAA;AAEF,yFAAyF;AACzF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASrB,CAAA"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "./dist/index.js",
   "sideEffects": false,
   "license": "MIT",
@@ -520,6 +520,11 @@
       "types": "./dist/tempo/Channel.d.ts",
       "default": "./dist/tempo/Channel.js"
     },
+    "./tempo/EarnShares": {
+      "src": "./src/tempo/EarnShares.ts",
+      "types": "./dist/tempo/EarnShares.d.ts",
+      "default": "./dist/tempo/EarnShares.js"
+    },
     "./tempo/KeyAuthorization": {
       "src": "./src/tempo/KeyAuthorization.ts",
       "types": "./dist/tempo/KeyAuthorization.d.ts",

package/src/tempo/EarnShares.test.ts

@@ -0,0 +1,120 @@
+import { EarnShares } from 'ox/tempo'
+import { describe, expect, test } from 'vite-plus/test'
+
+const anchor = { engineShares: 3n, shareSupply: 2n } as const
+
+describe('toAmount', () => {
+  test('default', () => {
+    expect(EarnShares.toAmount(anchor, 7n)).toBe(4n)
+  })
+
+  test('behavior: rounds down', () => {
+    expect(EarnShares.toAmount({ engineShares: 3n, shareSupply: 1n }, 2n)).toBe(
+      0n,
+    )
+  })
+})
+
+describe('toAmountUp', () => {
+  test('default', () => {
+    expect(EarnShares.toAmountUp(anchor, 7n)).toBe(5n)
+  })
+
+  test('behavior: exact conversions do not round up', () => {
+    expect(EarnShares.toAmountUp(anchor, 3n)).toBe(2n)
+  })
+})
+
+describe('toVenueAmount', () => {
+  test('default', () => {
+    expect(EarnShares.toVenueAmount(anchor, 7n)).toBe(10n)
+  })
+
+  test('behavior: identity at the initial 1:1 anchor', () => {
+    expect(
+      EarnShares.toVenueAmount({ engineShares: 1n, shareSupply: 1n }, 12_345n),
+    ).toBe(12_345n)
+  })
+})
+
+describe('feeShares', () => {
+  test('default', () => {
+    expect(
+      EarnShares.feeShares({
+        activeAssets: 1_100n,
+        shareSupply: 1_000n,
+        totalFeeAssets: 100n,
+      }),
+    ).toBe(100n)
+  })
+
+  test('behavior: zero fee mints nothing', () => {
+    expect(
+      EarnShares.feeShares({
+        activeAssets: 1_100n,
+        shareSupply: 1_000n,
+        totalFeeAssets: 0n,
+      }),
+    ).toBe(0n)
+  })
+
+  test('behavior: fee at or above active assets mints nothing', () => {
+    expect(
+      EarnShares.feeShares({
+        activeAssets: 100n,
+        shareSupply: 1_000n,
+        totalFeeAssets: 100n,
+      }),
+    ).toBe(0n)
+  })
+
+  test('behavior: rounds down', () => {
+    expect(
+      EarnShares.feeShares({
+        activeAssets: 1_000n,
+        shareSupply: 999n,
+        totalFeeAssets: 100n,
+      }),
+    ).toBe(111n)
+  })
+})
+
+describe('minimumOutput', () => {
+  test('default', () => {
+    expect(EarnShares.minimumOutput(1_000_000n, 50)).toBe(995_000n)
+  })
+
+  test('behavior: zero slippage returns the expected output', () => {
+    expect(EarnShares.minimumOutput(1_000_000n, 0)).toBe(1_000_000n)
+  })
+
+  test('behavior: floors to 1n', () => {
+    expect(EarnShares.minimumOutput(1n, 9_999)).toBe(1n)
+  })
+
+  test('error: non-positive expected output', () => {
+    expect(() =>
+      EarnShares.minimumOutput(0n, 50),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[EarnShares.InvalidExpectedOutputError: Expected output \`0\` must be greater than zero.]`,
+    )
+  })
+
+  test('error: out-of-range slippage', () => {
+    expect(() => EarnShares.minimumOutput(1_000_000n, 10_000))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [EarnShares.InvalidSlippageError: Slippage tolerance \`10000\` is invalid.
+
+      Slippage must be a whole number from 0 through 9999 basis points.]
+    `)
+  })
+
+  test('error: non-integer slippage', () => {
+    expect(() => EarnShares.minimumOutput(1_000_000n, 0.5))
+      .toThrowErrorMatchingInlineSnapshot(`
+      [EarnShares.InvalidSlippageError: Slippage tolerance \`0.5\` is invalid.
+
+      Slippage must be a whole number from 0 through 9999 basis points.]
+    `)
+  })
+})

package/src/tempo/EarnShares.ts

@@ -0,0 +1,235 @@
+import * as Errors from '../core/Errors.js'
+
+/** Basis-point denominator used by slippage bounds. */
+export const basisPointScale = 10_000
+
+/**
+ * Tempo Earn `VaultAdapter` conversion anchor.
+ *
+ * The adapter prices vault shares against venue shares through this pair:
+ * `engineShares` venue shares are worth `shareSupply` vault shares. It is initialised
+ * 1:1 and restated on `contribute` and `migrateEngine`.
+ *
+ * These conversions are raw and fee-blind; they ignore pending fee dilution
+ * and are unsuitable for user-facing value (use the adapter's `previewRedeem`).
+ */
+export type Anchor = {
+  /** Venue shares held by the engine at the anchor point. */
+  engineShares: bigint
+  /** Vault share supply at the anchor point. */
+  shareSupply: bigint
+}
+
+/**
+ * Converts venue shares to a vault share amount at the anchor rate, rounding down.
+ *
+ * Mirrors `VaultAdapter.sharesToTokens`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const shareAmount = EarnShares.toAmount(
+ *   { engineShares: 3n, shareSupply: 2n },
+ *   7n
+ * )
+ * // @log: 4n
+ * ```
+ *
+ * @param anchor - The conversion anchor.
+ * @param venueShareAmount - Venue share amount, base units.
+ * @returns Vault share amount, rounded down.
+ */
+export function toAmount(anchor: Anchor, venueShareAmount: bigint): bigint {
+  return (venueShareAmount * anchor.shareSupply) / anchor.engineShares
+}
+
+export declare namespace toAmount {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Converts venue shares to a vault share amount at the anchor rate, rounding up.
+ *
+ * Mirrors the adapter's ceiling conversion used by exact-asset exits.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const shareAmount = EarnShares.toAmountUp(
+ *   { engineShares: 3n, shareSupply: 2n },
+ *   7n
+ * )
+ * // @log: 5n
+ * ```
+ *
+ * @param anchor - The conversion anchor.
+ * @param venueShareAmount - Venue share amount, base units.
+ * @returns Vault share amount, rounded up.
+ */
+export function toAmountUp(anchor: Anchor, venueShareAmount: bigint): bigint {
+  const { engineShares, shareSupply } = anchor
+  return (venueShareAmount * shareSupply + engineShares - 1n) / engineShares
+}
+
+export declare namespace toAmountUp {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Converts a vault share amount to venue shares at the anchor rate, rounding down.
+ *
+ * Mirrors `VaultAdapter.tokensToShares`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const venueShareAmount = EarnShares.toVenueAmount(
+ *   { engineShares: 3n, shareSupply: 2n },
+ *   7n
+ * )
+ * // @log: 10n
+ * ```
+ *
+ * @param anchor - The conversion anchor.
+ * @param shareAmount - Vault share amount, base units.
+ * @returns Venue share amount, rounded down.
+ */
+export function toVenueAmount(anchor: Anchor, shareAmount: bigint): bigint {
+  return (shareAmount * anchor.engineShares) / anchor.shareSupply
+}
+
+export declare namespace toVenueAmount {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Computes the dilution-correct vault shares minted for an asset-denominated fee.
+ *
+ * Mirrors `FeeMath`:
+ * `feeShares = floor(fee * shareSupply / (activeAssets - fee))`, zero when the
+ * fee is zero or not smaller than the active assets. Minting this amount to the
+ * fee ledger prices the fee at post-mint value per share.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const shares = EarnShares.feeShares({
+ *   activeAssets: 1_100n,
+ *   shareSupply: 1_000n,
+ *   totalFeeAssets: 100n
+ * })
+ * // @log: 100n
+ * ```
+ *
+ * @param options - Fee accrual inputs.
+ * @returns Vault shares to mint for the fee, rounded down.
+ */
+export function feeShares(options: feeShares.Options): bigint {
+  const { activeAssets, shareSupply, totalFeeAssets } = options
+  if (totalFeeAssets === 0n || totalFeeAssets >= activeAssets) return 0n
+  return (totalFeeAssets * shareSupply) / (activeAssets - totalFeeAssets)
+}
+
+export declare namespace feeShares {
+  export type Options = {
+    /** Assets backing the active (non-queued) supply, base units. */
+    activeAssets: bigint
+    /** Active vault share supply, base units. */
+    shareSupply: bigint
+    /** Total fee liability in asset units. */
+    totalFeeAssets: bigint
+  }
+  export type ErrorType = Errors.GlobalErrorType
+}
+
+/**
+ * Lowers an expected output by a basis-point slippage tolerance, flooring to `1n`.
+ *
+ * Suitable for lower bounds such as a deposit's minimum shares or a redeem's
+ * minimum assets; not for upper bounds such as an exact withdrawal's maximum
+ * shares.
+ *
+ * @example
+ * ```ts twoslash
+ * import { EarnShares } from 'ox/tempo'
+ *
+ * const minimumShares = EarnShares.minimumOutput(
+ *   1_000_000n,
+ *   50
+ * )
+ * // @log: 995_000n
+ * ```
+ *
+ * @param expectedAmount - Expected output in base units.
+ * @param slippageBps - Allowed slippage in basis points from `0` through `9_999`.
+ * @returns The minimum accepted output, floored to `1n`.
+ * @throws `InvalidExpectedOutputError` when `expectedAmount` is not positive.
+ * @throws `InvalidSlippageError` when `slippageBps` is outside its valid range.
+ */
+export function minimumOutput(
+  expectedAmount: bigint,
+  slippageBps: number,
+): bigint {
+  if (expectedAmount <= 0n)
+    throw new InvalidExpectedOutputError({ expectedAmount })
+  if (
+    !Number.isInteger(slippageBps) ||
+    slippageBps < 0 ||
+    slippageBps >= basisPointScale
+  )
+    throw new InvalidSlippageError({ slippageBps })
+  const scale = BigInt(basisPointScale)
+  const bounded = (expectedAmount * (scale - BigInt(slippageBps))) / scale
+  return bounded === 0n ? 1n : bounded
+}
+
+export declare namespace minimumOutput {
+  type ErrorType =
+    | InvalidExpectedOutputError
+    | InvalidSlippageError
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Error thrown when an expected output is not positive.
+ */
+export class InvalidExpectedOutputError extends Errors.BaseError {
+  override readonly name = 'EarnShares.InvalidExpectedOutputError'
+
+  constructor(options: InvalidExpectedOutputError.Options) {
+    super(
+      `Expected output \`${options.expectedAmount}\` must be greater than zero.`,
+    )
+  }
+}
+
+export declare namespace InvalidExpectedOutputError {
+  export type Options = {
+    expectedAmount: bigint
+  }
+}
+
+/**
+ * Error thrown when a slippage tolerance is not an integer from `0` through `9_999`.
+ */
+export class InvalidSlippageError extends Errors.BaseError {
+  override readonly name = 'EarnShares.InvalidSlippageError'
+
+  constructor(options: InvalidSlippageError.Options) {
+    super(`Slippage tolerance \`${options.slippageBps}\` is invalid.`, {
+      metaMessages: [
+        `Slippage must be a whole number from 0 through ${basisPointScale - 1} basis points.`,
+      ],
+    })
+  }
+}
+
+export declare namespace InvalidSlippageError {
+  export type Options = {
+    slippageBps: number
+  }
+}

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

@@ -0,0 +1,62 @@
+import { expectTypeOf, test } from 'vp/test'
+import * as KeyAuthorization from './KeyAuthorization.js'
+import * as SignatureEnvelope from './SignatureEnvelope.js'
+
+const authorization = {
+  address: '0x1111111111111111111111111111111111111111',
+  chainId: 1n,
+  type: 'secp256k1',
+} as const satisfies KeyAuthorization.Input
+
+const signature = {
+  signature: {
+    r: '0x01',
+    s: '0x02',
+    yParity: 0,
+  },
+  type: 'secp256k1',
+} as const satisfies SignatureEnvelope.Secp256k1
+
+const multisig = {
+  account: '0x2222222222222222222222222222222222222222',
+  signatures: [signature],
+  type: 'multisig',
+} as const satisfies SignatureEnvelope.Multisig
+
+test('accepts primitive signatures', () => {
+  const signed = KeyAuthorization.from(authorization, { signature })
+
+  expectTypeOf(signed.signature).toMatchTypeOf<
+    KeyAuthorization.Signed['signature']
+  >()
+})
+
+test('rejects multisig signatures', () => {
+  KeyAuthorization.from(authorization, {
+    // @ts-expect-error Key authorizations accept only primitive signatures.
+    signature: multisig,
+  })
+
+  const multisigRpc = {
+    account: multisig.account,
+    signatures: [
+      {
+        r: '0x01',
+        s: '0x02',
+        type: 'secp256k1',
+        yParity: '0x0',
+      },
+    ],
+  } as const satisfies SignatureEnvelope.MultisigRpc
+
+  const rpc: KeyAuthorization.Rpc = {
+    chainId: '0x1',
+    expiry: null,
+    keyId: authorization.address,
+    keyType: authorization.type,
+    // @ts-expect-error Key authorizations accept only primitive RPC signatures.
+    signature: multisigRpc,
+  }
+
+  expectTypeOf(rpc).toEqualTypeOf<KeyAuthorization.Rpc>()
+})

package/src/tempo/KeyAuthorization.test.ts

@@ -53,6 +53,12 @@ const signature_webauthn = SignatureEnvelope.from({
   },
 })
 
+const signature_multisig = SignatureEnvelope.from({
+  account: address,
+  signatures: [SignatureEnvelope.from(signature_secp256k1)],
+  type: 'multisig',
+})
+
 describe('from', () => {
   test('default', () => {
     const authorization = KeyAuthorization.from({
@@ -416,9 +422,56 @@ describe('from', () => {
       }
     `)
   })
+
+  test('rejects a multisig signature', () => {
+    const authorization = KeyAuthorization.from({
+      address,
+      chainId: 1n,
+      type: 'secp256k1',
+    })
+
+    expect(() =>
+      KeyAuthorization.from(authorization, {
+        signature: signature_multisig as never,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`multisig\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, or \`webAuthn\`.]`,
+    )
+
+    expect(() =>
+      KeyAuthorization.from(authorization, {
+        signature: SignatureEnvelope.serialize(signature_multisig),
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`multisig\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, or \`webAuthn\`.]`,
+    )
+
+    expect(() =>
+      KeyAuthorization.from({
+        ...authorization,
+        signature: signature_multisig,
+      } as never),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`multisig\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, or \`webAuthn\`.]`,
+    )
+  })
 })
 
 describe('fromRpc', () => {
+  test('rejects a multisig signature', () => {
+    expect(() =>
+      KeyAuthorization.fromRpc({
+        chainId: '0x1',
+        expiry: null,
+        keyId: address,
+        keyType: 'secp256k1',
+        signature: SignatureEnvelope.toRpc(signature_multisig),
+      } as never),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`multisig\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, or \`webAuthn\`.]`,
+    )
+  })
+
   test('secp256k1', () => {
     const authorization = KeyAuthorization.fromRpc({
       chainId: '0x1',