@inco/shield-js 0.0.0-bootstrap.0 → 0.2.0

package/dist/shield/userop/token-exchange.js

@@ -1,165 +1,57 @@
-import { parseAbi } from 'viem';
-import { InvalidContractReturnType, TaggedError } from '../../errors.js';
-const aggregatorAbi = parseAbi([
-    'function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)',
-    'function decimals() view returns (uint8)',
-    'function description() view returns (string)',
-]);
-const erc20DecimalsAbi = parseAbi(['function decimals() view returns (uint8)']);
-/** ETH / USD aggregator on Base Sepolia. */
-const BASE_SEPOLIA_ETH_USD_FEED = '0x4aDC67696bA383F43DD60A9e78F2C97Fbbfc7cb1';
-/**
- * Fetch the latest price from a single Chainlink aggregator contract.
- *
- * The aggregator's `description` (e.g. "ETH / USD") encodes the pair —
- * there is no on-chain way to enforce that callers passed the right address.
- */
-export async function getAggregatorRate(publicClient, aggregator) {
-    const [roundDataRaw, decimalsRaw, descriptionRaw] = await Promise.all([
-        publicClient.readContract({
-            address: aggregator,
-            abi: aggregatorAbi,
-            functionName: 'latestRoundData',
-        }),
-        publicClient.readContract({
-            address: aggregator,
-            abi: aggregatorAbi,
-            functionName: 'decimals',
-        }),
-        publicClient.readContract({
-            address: aggregator,
-            abi: aggregatorAbi,
-            functionName: 'description',
-        }),
-    ]);
-    const { answer, updatedAt } = parseLatestRoundData(roundDataRaw);
-    const decimals = parseDecimals(decimalsRaw);
-    if (typeof descriptionRaw !== 'string') {
+import { zeroAddress } from 'viem';
+import { shieldPaymasterAbi } from '../../contracts/abi.js';
+import { InvalidContractReturnType, UnsupportedFeeToken, } from '../../errors.js';
+export async function getPaymasterAssetAdapter(publicClient, paymaster) {
+    const adapter = await publicClient.readContract({
+        address: paymaster,
+        abi: shieldPaymasterAbi,
+        functionName: 'ALLOWED_ASSET_ADAPTER',
+    });
+    if (typeof adapter !== 'string') {
         throw new InvalidContractReturnType({
-            message: `Aggregator.description returned non-string: ${typeof descriptionRaw}`,
-            functionName: 'Aggregator.description',
-            expectedType: 'string',
+            message: `ShieldPaymaster.ALLOWED_ASSET_ADAPTER returned non-address: ${typeof adapter}`,
+            functionName: 'ShieldPaymaster.ALLOWED_ASSET_ADAPTER',
+            expectedType: 'address',
         });
     }
-    if (answer <= 0n) {
-        throw new InvalidContractReturnType({
-            message: `Aggregator ${aggregator} returned non-positive answer (${answer})`,
-            functionName: 'Aggregator.latestRoundData',
-            expectedType: 'positive int256',
+    return adapter;
+}
+export async function assertFeeTokenSupported(publicClient, paymaster, token) {
+    const [wrapper] = await publicClient.readContract({
+        address: paymaster,
+        abi: shieldPaymasterAbi,
+        functionName: 'priceFeeds',
+        args: [token],
+    });
+    if (wrapper === zeroAddress) {
+        throw new UnsupportedFeeToken({
+            message: `Fee token ${token} has no price feed on ShieldPaymaster ${paymaster}; it cannot be used to pay gas`,
+            feeToken: token,
         });
     }
-    return { answer, decimals, updatedAt, description: descriptionRaw };
 }
-function parseLatestRoundData(value) {
-    if (!Array.isArray(value) ||
-        value.length < 5 ||
-        typeof value[1] !== 'bigint' ||
-        typeof value[3] !== 'bigint') {
+export const RAY = 10n ** 27n;
+export async function getEthExchangeRateRay(publicClient, paymaster, token) {
+    const rate = await publicClient.readContract({
+        address: paymaster,
+        abi: shieldPaymasterAbi,
+        functionName: 'exchangeRateRay',
+        args: [token],
+    });
+    if (typeof rate !== 'bigint') {
         throw new InvalidContractReturnType({
-            message: 'Aggregator.latestRoundData returned an unexpected shape',
-            functionName: 'Aggregator.latestRoundData',
-            expectedType: '[uint80, int256, uint256, uint256, uint80]',
+            message: `ShieldPaymaster.exchangeRateRay returned non-bigint: ${typeof rate}`,
+            functionName: 'ShieldPaymaster.exchangeRateRay',
+            expectedType: 'uint256',
         });
     }
-    return { answer: value[1], updatedAt: value[3] };
-}
-/**
- * Chainlink aggregators for fee-payment assets on Base Sepolia, keyed by
- * the ERC-20 token address (Shield's `assetId` is just the token address
- * left-padded to bytes32). Each feed is **TOKEN / USD** — direction matters
- * when converting gas cost from ETH to token units downstream.
- */
-const BASE_SEPOLIA_TOKEN_FEEDS = {
-    // Circle native USDC on Base Sepolia → USDC/USD aggregator
-    '0x036CbD53842c5426634e7929541eC2318f3dCF7e': '0xd30e2101a97dcbAeBCBC04F14C3f624E67A35165',
-};
-export class UnknownAssetFeed extends TaggedError('UnknownAssetFeed') {
-}
-/**
- * Resolve the Chainlink aggregator for a Shield `assetId` (= ERC-20 token
- * address padded to bytes32) and return its latest rate.
- */
-export async function getAssetRate(publicClient, assetId) {
-    const tokenAddress = tokenAddressFromAssetId(assetId);
-    const aggregator = lookupFeed(tokenAddress);
-    if (aggregator === undefined) {
-        throw new UnknownAssetFeed({ assetId });
-    }
-    return getAggregatorRate(publicClient, aggregator);
-}
-/** Extract the trailing 20-byte ERC-20 address from a bytes32 assetId. */
-function tokenAddressFromAssetId(assetId) {
-    // bytes32 hex = "0x" + 64 chars; last 40 are the address.
-    const hex = assetId.startsWith('0x') ? assetId.slice(2) : assetId;
-    return `0x${hex.slice(-40)}`;
-}
-/** Case-insensitive lookup against the feed registry. */
-function lookupFeed(token) {
-    const target = token.toLowerCase();
-    for (const [key, aggregator] of Object.entries(BASE_SEPOLIA_TOKEN_FEEDS)) {
-        if (key.toLowerCase() === target)
-            return aggregator;
-    }
-    return undefined;
-}
-/** RAY = 1e27, the fixed-point scale used by the Shield paymaster. */
-export const RAY = 10n ** 27n;
-/**
- * Compute the RAY-precision exchange rate (ETH priced in token units)
- * that the Shield paymaster consumes. Mirrors the on-chain convention
- * from SHIELD_PAYMASTER.md:
- *
- *     tokenAmount = ceil(gasCostWei * exchangeRate / 1e27)
- *
- * Worked example: if 1 ETH = 2000 USDC and USDC has 6 decimals,
- *     exchangeRate = 2000 * 1e6 * 1e27 / 1e18 = 2e18
- *
- * Derivation here uses two Chainlink USD feeds:
- *     ethInToken (real) = ethUsd / tokenUsd
- *     rate (RAY)        = ethInToken * 10^tokenDec * 1e27 / 1e18
- *                       = ethUsd * 10^tokenDec * 10^tokenFeedDec * RAY
- *                         / (tokenUsd * 10^ethFeedDec * 1e18)
- */
-export async function getEthExchangeRateRay(publicClient, assetId) {
-    const tokenAddress = tokenAddressFromAssetId(assetId);
-    const [tokenRate, ethRate, tokenDecimalsRaw] = await Promise.all([
-        getAssetRate(publicClient, assetId),
-        getAggregatorRate(publicClient, BASE_SEPOLIA_ETH_USD_FEED),
-        publicClient.readContract({
-            address: tokenAddress,
-            abi: erc20DecimalsAbi,
-            functionName: 'decimals',
-        }),
-    ]);
-    const tokenDecimals = parseDecimals(tokenDecimalsRaw);
-    const numerator = ethRate.answer *
-        10n ** BigInt(tokenDecimals) *
-        10n ** BigInt(tokenRate.decimals) *
-        RAY;
-    const denominator = tokenRate.answer * 10n ** BigInt(ethRate.decimals) * 10n ** 18n;
-    return numerator / denominator;
+    return rate;
 }
-/** `ceil(ethWei * exchangeRate / RAY)` — matches the paymaster's rounding. */
 export function applyExchangeRateRayCeil(ethWei, exchangeRateRay) {
     const product = ethWei * exchangeRateRay;
     return (product + RAY - 1n) / RAY;
 }
-/**
- * Convenience: fetch the RAY rate for `assetId` and apply it to `ethWei`.
- * Use `getEthExchangeRateRay` directly when the caller also needs to
- * forward the rate to the paymaster signer.
- */
-export async function convertEthWeiToTokenUnits(publicClient, assetId, ethWei) {
-    const rate = await getEthExchangeRateRay(publicClient, assetId);
+export async function convertEthWeiToTokenUnits(publicClient, paymaster, token, ethWei) {
+    const rate = await getEthExchangeRateRay(publicClient, paymaster, token);
     return applyExchangeRateRayCeil(ethWei, rate);
 }
-function parseDecimals(value) {
-    if (typeof value !== 'number') {
-        throw new InvalidContractReturnType({
-            message: `Aggregator.decimals returned non-number: ${typeof value}`,
-            functionName: 'Aggregator.decimals',
-            expectedType: 'uint8',
-        });
-    }
-    return value;
-}

package/dist/shield/userop/types.d.ts

@@ -1,22 +1,10 @@
-/**
- * Type-only surface for the UserOp builder. Runtime code lives in `userOp.ts`.
- */
 import type { Address } from 'viem';
 import type { UserOperation } from 'viem/account-abstraction';
 import type { IntentKind } from '../../generated/inco/shield/v2/drafting_pb.js';
 import type * as abi from '../shield.eip712.gen.js';
 import type { DefiInteraction, IndividualRevocation, Transfer, UserWideRevocation, Withdrawal } from '../shield.eip712.gen.js';
-export declare const ENTRYPOINT_VERSION: "0.7";
-/**
- * A drafted op — the full on-chain settlement struct the enclave produces from
- * an intent via `draft()`, tagged by {@link IntentKind}. This is the "cheque":
- * an intent is what the user signs *before* `draft()`; the cheque is what comes
- * *after*, and is exactly what `IncoShield.{transfer,withdraw,...}` settles.
- *
- * Delegated kinds settle through the same on-chain function — and thus the same
- * struct — as their non-delegated counterparts; the delegation context rides
- * inside the intent, not in a separate selector.
- */
+import type { PaymasterFields } from './paymaster.js';
+export declare const ENTRYPOINT_VERSION = "0.7";
 export type SettlementOp = {
     kind: IntentKind.TRANSFER;
     op: Transfer;
@@ -42,13 +30,6 @@ export type SettlementOp = {
     kind: IntentKind.USER_WIDE_REVOCATION;
     op: UserWideRevocation;
 };
-/**
- * Domain Intent: a signed EIP-712 intent struct tagged by its {@link IntentKind}
- * discriminant. This is what the user signs *before* `draft()` — the enclave
- * processes an `Intent` and produces the {@link Cheque}. Each variant is the
- * generated `abi.{*}Intent` struct plus a `kind` tag; delegated kinds wrap
- * their non-delegated inner intent inside the generated `Delegated*Intent` shape.
- */
 export type Intent = TransferIntent | WithdrawalIntent | DefiInteractionIntent | IndividualRevocationIntent | UserWideRevocationIntent | DelegatedTransferIntent | DelegatedWithdrawalIntent | DelegatedDefiInteractionIntent;
 export type TransferIntent = {
     readonly kind: IntentKind.TRANSFER;
@@ -74,18 +55,12 @@ export type DelegatedWithdrawalIntent = {
 export type DelegatedDefiInteractionIntent = {
     readonly kind: IntentKind.DELEGATED_DEFI_INTERACTION;
 } & abi.DelegatedDefiInteractionIntent;
-/**
- * A v0.7 UserOperation before the quorum signature is attached. Quorum signing
- * happens enclave-side over {@link userOpHash}; the SDK only builds and assembles.
- */
 export type UnsignedUserOperation = Omit<UserOperation<typeof ENTRYPOINT_VERSION>, 'signature'>;
 export type BuildUnsignedUserOpParams = {
-    /** The drafted on-chain struct to settle, tagged by intent kind. */
     settlementOp: SettlementOp;
-    /** AA account submitting the op — the TeeSmartAccount (sole TEE_ROLE holder). */
     sender: Address;
     nonce: bigint;
     shieldAddress: Address;
-    /** Bundler-estimated limits — everything except the signed fee fields. */
     gas: abi.Gas;
+    paymaster?: PaymasterFields;
 };

package/dist/shield/userop/types.js

@@ -1,4 +1 @@
-/**
- * Type-only surface for the UserOp builder. Runtime code lives in `userOp.ts`.
- */
 export const ENTRYPOINT_VERSION = '0.7';

package/dist/shield/userop/userOp.d.ts

@@ -1,26 +1,7 @@
-/**
- * Constitution: builds a v0.7 UserOperation from a drafted cheque in three pure
- * stages — (1) assemble the unsigned op, (2) compute the hash the quorum signs,
- * (3) attach a signature. Every stage is deterministic: identical inputs produce
- * identical bytes across all quorum members. That is the property the on-chain
- * TEE smart account relies on when it verifies that every quorum signature is
- * over the same userOpHash. Quorum signing itself is enclave-side and
- * intentionally absent here — the SDK builds and assembles, it does not sign.
- */
 import { type Address, type Hex } from 'viem';
 import { type UserOperation } from 'viem/account-abstraction';
 import { type BuildUnsignedUserOpParams, ENTRYPOINT_VERSION, type SettlementOp, type UnsignedUserOperation } from './types.js';
 export declare function buildUnsignedUserOp(params: BuildUnsignedUserOpParams): UnsignedUserOperation;
 export declare function userOpHash(unsignedUserOp: UnsignedUserOperation, chainId: number, entryPointAddress?: Address): Hex;
 export declare function assembleUserOp(unsigned: UnsignedUserOperation, signature: Hex): UserOperation<typeof ENTRYPOINT_VERSION>;
-/**
- * Encode the shield settlement call for a drafted {@link OnchainCheque}: the
- * `kind` selects the on-chain function and `op` is its sole argument. This is
- * the inner call wrapped by {@link buildUnsignedUserOp} inside `execute`, and is
- * exported so the enclave can reuse the canonical encoding when it assembles
- * the cheque calldata itself.
- *
- * TODO(#639): the enclave OnChainOp path ABI-encodes only the struct while this
- * emits selector + struct. Harmonize so both produce identical calldata.
- */
 export declare function encodeSettlementOpCall(settlementOp: SettlementOp): Hex;

package/dist/shield/userop/userOp.js

@@ -1,15 +1,6 @@
-/**
- * Constitution: builds a v0.7 UserOperation from a drafted cheque in three pure
- * stages — (1) assemble the unsigned op, (2) compute the hash the quorum signs,
- * (3) attach a signature. Every stage is deterministic: identical inputs produce
- * identical bytes across all quorum members. That is the property the on-chain
- * TEE smart account relies on when it verifies that every quorum signature is
- * over the same userOpHash. Quorum signing itself is enclave-side and
- * intentionally absent here — the SDK builds and assembles, it does not sign.
- */
 import { encodeFunctionData } from 'viem';
 import { entryPoint07Address, getUserOperationHash, } from 'viem/account-abstraction';
-import { shieldAbiStubAbi, teeSmartAccountAbi } from '../../contracts/abi.js';
+import { incoShieldAbi, teeSmartAccountAbi } from '../../contracts/abi.js';
 import { IntentKind } from '../../generated/inco/shield/v2/drafting_pb.js';
 import { ENTRYPOINT_VERSION, } from './types.js';
 export function buildUnsignedUserOp(params) {
@@ -21,7 +12,6 @@ export function buildUnsignedUserOp(params) {
             functionName: 'execute',
             args: [
                 params.shieldAddress,
-                // value: shield ops carry no native ETH
                 0n,
                 encodeSettlementOpCall(params.settlementOp),
             ],
@@ -33,6 +23,8 @@ export function buildUnsignedUserOp(params) {
         maxPriorityFeePerGas: params.gas.maxPriorityFeePerGas,
         paymasterVerificationGasLimit: params.gas.paymasterVerificationGasLimit,
         paymasterPostOpGasLimit: params.gas.paymasterPostOpGasLimit,
+        paymaster: params.paymaster?.paymaster,
+        paymasterData: params.paymaster?.paymasterData,
     };
 }
 export function userOpHash(unsignedUserOp, chainId, entryPointAddress = entryPoint07Address) {
@@ -46,18 +38,8 @@ export function userOpHash(unsignedUserOp, chainId, entryPointAddress = entryPoi
 export function assembleUserOp(unsigned, signature) {
     return { ...unsigned, signature };
 }
-/**
- * Encode the shield settlement call for a drafted {@link OnchainCheque}: the
- * `kind` selects the on-chain function and `op` is its sole argument. This is
- * the inner call wrapped by {@link buildUnsignedUserOp} inside `execute`, and is
- * exported so the enclave can reuse the canonical encoding when it assembles
- * the cheque calldata itself.
- *
- * TODO(#639): the enclave OnChainOp path ABI-encodes only the struct while this
- * emits selector + struct. Harmonize so both produce identical calldata.
- */
 export function encodeSettlementOpCall(settlementOp) {
-    const abi = shieldAbiStubAbi;
+    const abi = incoShieldAbi;
     switch (settlementOp.kind) {
         case IntentKind.TRANSFER:
         case IntentKind.DELEGATED_TRANSFER:

package/dist/shield/utils/chain.d.ts

@@ -1,2 +1,3 @@
 import type { Chain } from 'viem';
 export declare function getChainFromId(chainId: number): Chain;
+export declare function defaultBundlerUrl(chainId: number): string;

package/dist/shield/utils/chain.js

@@ -6,3 +6,6 @@ export function getChainFromId(chainId) {
     }
     return chain;
 }
+export function defaultBundlerUrl(chainId) {
+    return `https://public.pimlico.io/v2/${chainId}/rpc`;
+}

package/dist/shield/validate-withdrawal-split.d.ts

@@ -0,0 +1,13 @@
+import { type Address } from 'viem';
+import type { UserOperation } from 'viem/account-abstraction';
+import type { WithdrawalIntent } from './shield.eip712.gen.js';
+import type { ENTRYPOINT_VERSION } from './userop/types.js';
+declare const WithdrawalSplitMismatch_base: new <Fields extends Record<string, unknown>>(fields: Fields) => Error & {
+    readonly _tag: "WithdrawalSplitMismatch";
+} & Readonly<Fields>;
+export declare class WithdrawalSplitMismatch extends WithdrawalSplitMismatch_base<{
+    readonly message: string;
+}> {
+}
+export declare function assertWithdrawalSplitMatchesIntent(userOp: UserOperation<typeof ENTRYPOINT_VERSION>, signed: WithdrawalIntent, shieldAddress: Address): void;
+export {};

package/dist/shield/validate-withdrawal-split.js

@@ -0,0 +1,93 @@
+import { decodeFunctionData, isAddressEqual } from 'viem';
+import { incoShieldAbi, teeSmartAccountAbi } from '../contracts/abi.js';
+import { TaggedError } from '../errors.js';
+export class WithdrawalSplitMismatch extends TaggedError('WithdrawalSplitMismatch') {
+}
+export function assertWithdrawalSplitMatchesIntent(userOp, signed, shieldAddress) {
+    const outer = tryDecode(() => decodeFunctionData({ abi: teeSmartAccountAbi, data: userOp.callData }), 'settlement callData');
+    if (outer.functionName !== 'execute') {
+        throw mismatch(`settlement call is '${outer.functionName}', expected 'execute'`);
+    }
+    const [target, value, inner] = outer.args;
+    if (!isAddressEqual(target, shieldAddress)) {
+        throw mismatch(`execute target ${target} is not the shield ${shieldAddress}`);
+    }
+    if (value !== 0n) {
+        throw mismatch(`execute carries non-zero value ${value}`);
+    }
+    const call = tryDecode(() => decodeFunctionData({ abi: incoShieldAbi, data: inner }), 'inner withdraw call');
+    if (call.functionName !== 'withdraw') {
+        throw mismatch(`inner call is '${call.functionName}', expected 'withdraw'`);
+    }
+    const core = call.args[0].core;
+    const signedAsset = signed.op.core.asset;
+    if (core.asset.standard !== signedAsset.standard ||
+        !isAddressEqual(core.asset.token, signedAsset.token) ||
+        core.asset.tokenId !== signedAsset.tokenId) {
+        throw mismatch('withdrawal asset does not match the signed asset');
+    }
+    const signedMovements = signed.op.core.assetMovements;
+    const movements = core.assetMovements;
+    if (movements.length !== signedMovements.length) {
+        throw mismatch(`expected the ${signedMovements.length} signed movement(s), got ${movements.length}`);
+    }
+    signedMovements.forEach((signedMovement, i) => {
+        const movement = movements[i];
+        if (!isAddressEqual(movement.account, signedMovement.account)) {
+            throw mismatch(`movement ${i} account was changed`);
+        }
+        if (!isAddressEqual(movement.assetAdapter, signedMovement.assetAdapter)) {
+            throw mismatch(`movement ${i} asset adapter was changed`);
+        }
+        if (movement.movementArgs.toLowerCase() !==
+            signedMovement.movementArgs.toLowerCase()) {
+            throw mismatch(`movement ${i} args were changed`);
+        }
+    });
+    assertGasWithinSigned(userOp, signed.gas);
+}
+function assertGasWithinSigned(userOp, gas) {
+    const limits = [
+        ['callGasLimit', userOp.callGasLimit, gas.callGasLimit],
+        [
+            'verificationGasLimit',
+            userOp.verificationGasLimit,
+            gas.verificationGasLimit,
+        ],
+        ['preVerificationGas', userOp.preVerificationGas, gas.preVerificationGas],
+        ['maxFeePerGas', userOp.maxFeePerGas, gas.maxFeePerGas],
+        [
+            'maxPriorityFeePerGas',
+            userOp.maxPriorityFeePerGas,
+            gas.maxPriorityFeePerGas,
+        ],
+        [
+            'paymasterVerificationGasLimit',
+            userOp.paymasterVerificationGasLimit ?? 0n,
+            gas.paymasterVerificationGasLimit,
+        ],
+        [
+            'paymasterPostOpGasLimit',
+            userOp.paymasterPostOpGasLimit ?? 0n,
+            gas.paymasterPostOpGasLimit,
+        ],
+    ];
+    for (const [name, actual, limit] of limits) {
+        if (actual > limit) {
+            throw mismatch(`${name} ${actual} exceeds the signed limit ${limit}`);
+        }
+    }
+}
+function tryDecode(decode, what) {
+    try {
+        return decode();
+    }
+    catch (cause) {
+        throw mismatch(`could not decode ${what}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+function mismatch(detail) {
+    return new WithdrawalSplitMismatch({
+        message: `enclave withdrawal UserOp does not match the signed intent: ${detail}`,
+    });
+}

package/package.json

@@ -1,8 +1,13 @@
 {
 	"name": "@inco/shield-js",
-	"version": "0.0.0-bootstrap.0",
+	"version": "0.2.0",
+	"description": "TypeScript SDK for interacting with Inco Shield.",
 	"license": "Apache-2.0",
-	"repository": "https://github.com/Inco-fhevm/shield",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Inco-fhevm/shield.git",
+		"directory": "sdk"
+	},
 	"type": "module",
 	"files": [
 		"dist"
@@ -19,48 +24,34 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
-		},
-		"./uniswap": {
-			"types": "./dist/uniswap-adapter/index.d.ts",
-			"import": "./dist/uniswap-adapter/index.js"
 		}
 	},
 	"scripts": {
 		"generate:proto": "rm -rf src/generated && buf generate",
 		"generate:abi": "cd ../contracts && bun run generate && cd ../sdk && bun run scripts/extract-abi.ts",
 		"generate": "bun run generate:proto && bun run generate:abi",
-		"build": "bun run generate && tsc -p tsconfig.dist.json",
-		"typecheck": "tsc --noEmit",
-		"test": "bun run generate && vitest run",
+		"clean": "rm -rf dist",
+		"compile": "bun run clean && tsc -p tsconfig.dist.json",
+		"build": "bun run generate && bun run compile",
+		"typecheck": "tsc --noEmit -p tsconfig.dist.json",
+		"test": "bun run generate && bun run test:unit",
+		"test:unit": "vitest run",
 		"lint": "biome check --write . && eslint .",
 		"test:lint": "biome check . && eslint .",
-		"uniswap": "bun run scripts/uniswap/uniswap.ts"
+		"publish:npm": "npm publish"
 	},
 	"dependencies": {
-		"@bufbuild/protobuf": "^1.10.0",
-		"@connectrpc/connect": "^1.7.0",
+		"@bufbuild/protobuf": "^2.12.0",
+		"@connectrpc/connect": "^2.1.2",
 		"@hpke/chacha20poly1305": "^1.8.0",
 		"@hpke/core": "^1.9.0",
 		"@hpke/hybridkem-x-wing": "^0.7.0",
 		"@noble/ciphers": "^1.3.0",
 		"viem": "^2.30.0"
 	},
-	"peerDependencies": {
-		"@uniswap/v4-sdk": "^1.22.0",
-		"ethers": "^5"
-	},
-	"peerDependenciesMeta": {
-		"@uniswap/v4-sdk": {
-			"optional": true
-		},
-		"ethers": {
-			"optional": true
-		}
-	},
 	"devDependencies": {
-		"@bufbuild/buf": "^1.34.0",
-		"@bufbuild/protoc-gen-es": "^1.10.0",
-		"@connectrpc/protoc-gen-connect-es": "^1.7.0",
+		"@bufbuild/buf": "^1.70.0",
+		"@bufbuild/protoc-gen-es": "^2.12.0",
 		"@types/node": "^22.8.5",
 		"@uniswap/v4-sdk": "^1.22.0",
 		"bun-types": "^1.3.8",