@inco/shield-js 0.0.0-bootstrap.0

package/dist/shield/userop/userOp.js

@@ -0,0 +1,98 @@
+/**
+ * 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 { IntentKind } from '../../generated/inco/shield/v2/drafting_pb.js';
+import { ENTRYPOINT_VERSION, } from './types.js';
+export function buildUnsignedUserOp(params) {
+    return {
+        sender: params.sender,
+        nonce: params.nonce,
+        callData: encodeFunctionData({
+            abi: teeSmartAccountAbi,
+            functionName: 'execute',
+            args: [
+                params.shieldAddress,
+                // value: shield ops carry no native ETH
+                0n,
+                encodeSettlementOpCall(params.settlementOp),
+            ],
+        }),
+        callGasLimit: params.gas.callGasLimit,
+        verificationGasLimit: params.gas.verificationGasLimit,
+        preVerificationGas: params.gas.preVerificationGas,
+        maxFeePerGas: params.gas.maxFeePerGas,
+        maxPriorityFeePerGas: params.gas.maxPriorityFeePerGas,
+        paymasterVerificationGasLimit: params.gas.paymasterVerificationGasLimit,
+        paymasterPostOpGasLimit: params.gas.paymasterPostOpGasLimit,
+    };
+}
+export function userOpHash(unsignedUserOp, chainId, entryPointAddress = entryPoint07Address) {
+    return getUserOperationHash({
+        chainId,
+        entryPointAddress,
+        entryPointVersion: ENTRYPOINT_VERSION,
+        userOperation: { ...unsignedUserOp, signature: '0x' },
+    });
+}
+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;
+    switch (settlementOp.kind) {
+        case IntentKind.TRANSFER:
+        case IntentKind.DELEGATED_TRANSFER:
+            return encodeFunctionData({
+                abi,
+                functionName: 'transfer',
+                args: [settlementOp.op],
+            });
+        case IntentKind.WITHDRAW:
+        case IntentKind.DELEGATED_WITHDRAW:
+            return encodeFunctionData({
+                abi,
+                functionName: 'withdraw',
+                args: [settlementOp.op],
+            });
+        case IntentKind.DEFI_INTERACTION:
+        case IntentKind.DELEGATED_DEFI_INTERACTION:
+            return encodeFunctionData({
+                abi,
+                functionName: 'performDefiInteraction',
+                args: [settlementOp.op],
+            });
+        case IntentKind.INDIVIDUAL_REVOCATION:
+            return encodeFunctionData({
+                abi,
+                functionName: 'revokeOne',
+                args: [settlementOp.op],
+            });
+        case IntentKind.USER_WIDE_REVOCATION:
+            return encodeFunctionData({
+                abi,
+                functionName: 'revokeAll',
+                args: [settlementOp.op],
+            });
+        default:
+            throw new Error(`Invalid operation specified ${settlementOp}`);
+    }
+}

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

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

package/dist/shield/utils/chain.js

@@ -0,0 +1,8 @@
+import * as allChains from 'viem/chains';
+export function getChainFromId(chainId) {
+    const chain = Object.values(allChains).find((c) => c.id === chainId);
+    if (!chain) {
+        throw new Error(`Chain with id ${chainId} not found`);
+    }
+    return chain;
+}

package/dist/uniswap-adapter/config.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Sepolia testnet configuration for UniswapV4Adapter testing
+ */
+import type { Address } from 'viem';
+export declare const SEPOLIA_CHAIN_ID = 11155111;
+interface UniswapSepoliaContracts {
+    UNIVERSAL_ROUTER: Address;
+    PERMIT2: Address;
+    POOL_MANAGER: Address;
+    V4_QUOTER: Address;
+    STATE_VIEW: Address;
+}
+interface SepoliaTokens {
+    NATIVE_ETH: Address;
+    WETH: Address;
+    USDC: Address;
+}
+interface PoolConstants {
+    FEE: number;
+    TICK_SPACING: number;
+    HOOKS: Address;
+}
+export declare const UNISWAP_V4_SEPOLIA: UniswapSepoliaContracts;
+export declare const SEPOLIA_TOKENS: SepoliaTokens;
+export declare const POOL_CONFIG: PoolConstants;
+export declare const WETH_USDC_POOL_CONFIG: PoolConstants;
+export interface DeployedContracts {
+    incoShield: Address;
+    teeSmartAccount: Address;
+    erc20Adapter: Address;
+    uniswapV4Adapter: Address;
+}
+export declare const DEPLOYED_CONTRACTS: DeployedContracts;
+export {};

package/dist/uniswap-adapter/config.js

@@ -0,0 +1,45 @@
+/**
+ * Sepolia testnet configuration for UniswapV4Adapter testing
+ */
+// Chain configuration
+export const SEPOLIA_CHAIN_ID = 11155111;
+// Uniswap V4 contracts on Sepolia
+export const UNISWAP_V4_SEPOLIA = {
+    UNIVERSAL_ROUTER: '0x3A9D48AB9751398BbFa63ad67599Bb04e4BdF98b',
+    PERMIT2: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+    POOL_MANAGER: '0xE03A1074c86CFeDd5C142C4F04F1a1536e203543',
+    V4_QUOTER: '0x61b3f2011a92d183c7dbadbda940a7555ccf9227',
+    STATE_VIEW: '0xe1dd9c3fa50edb962e442f60dfbc432e24537e4c',
+};
+// Common test tokens on Sepolia
+export const SEPOLIA_TOKENS = {
+    // Native ETH (address(0) in V4)
+    NATIVE_ETH: '0x0000000000000000000000000000000000000000',
+    WETH: '0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9',
+    USDC: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // Circle's testnet USDC
+};
+// Pool configuration for ETH/USDC (best liquidity pool on Sepolia V4)
+// Pool ID: 0x3390c733d8252e864d4ce769398dd3fb8680d1f626719e8d7736d062665f0987
+// Currency0: Native ETH (0x0...0)
+// Currency1: USDC
+// Liquidity: 2805238952407756
+export const POOL_CONFIG = {
+    FEE: 3000, // 0.3%
+    TICK_SPACING: 60,
+    HOOKS: '0x0000000000000000000000000000000000000000',
+};
+// Alternative: WETH/USDC pool with some liquidity
+// Pool ID: 0xda4df63a89fcfed42a03810ab15dd5df417167b9ecef407de884465f23181d4e
+// Fee: 10000 (1%), TickSpacing: 200, Liquidity: 39867548
+export const WETH_USDC_POOL_CONFIG = {
+    FEE: 10000, // 1%
+    TICK_SPACING: 200,
+    HOOKS: '0x0000000000000000000000000000000000000000',
+};
+// Deployed contracts on Sepolia
+export const DEPLOYED_CONTRACTS = {
+    incoShield: '0xf203cf28b03c8c3c47678c243c49E34A654e1bfb',
+    teeSmartAccount: '0xF468DCD280d345e1a2429Ae569Ebbf23c3D43795',
+    erc20Adapter: '0xF1CD72CFE89c6FF352bdDe4c126Bfec218D7EF95',
+    uniswapV4Adapter: '0xe634f32b0add29b975a58412eff6dfbd8cf946b6',
+};

package/dist/uniswap-adapter/find-pools.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Find Uniswap V4 pools with liquidity
+ *
+ * Uses the StateView contract to query pool state and liquidity.
+ */
+import type { Address, Hex } from 'viem';
+declare const STATE_VIEW_ABI: readonly [{
+    readonly name: "getSlot0";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "poolId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint160";
+        readonly name: "sqrtPriceX96";
+    }, {
+        readonly type: "int24";
+        readonly name: "tick";
+    }, {
+        readonly type: "uint24";
+        readonly name: "protocolFee";
+    }, {
+        readonly type: "uint24";
+        readonly name: "lpFee";
+    }];
+}, {
+    readonly name: "getLiquidity";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "poolId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint128";
+    }];
+}];
+/** Pool key configuration */
+export interface PoolKey {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+}
+/** Pool configuration with name for display */
+export interface PoolConfig extends PoolKey {
+    name: string;
+}
+/** Pool state from on-chain query */
+export interface PoolState {
+    pool: PoolConfig;
+    poolId: Hex;
+    liquidity: bigint;
+    tick: number;
+    sqrtPriceX96: bigint;
+    isInitialized: boolean;
+    hasLiquidity: boolean;
+}
+/** Client capable of reading contracts */
+export interface ReadClient {
+    readContract: (params: {
+        address: Address;
+        abi: typeof STATE_VIEW_ABI;
+        functionName: string;
+        args: readonly unknown[];
+    }) => Promise<unknown>;
+}
+/**
+ * Compute pool ID from pool key
+ *
+ * Pool ID is keccak256(abi.encode(poolKey))
+ */
+export declare function computePoolId(pool: PoolKey): Hex;
+/**
+ * Get pool state from StateView contract
+ */
+export declare function getPoolState(publicClient: ReadClient, stateViewAddress: Address, pool: PoolConfig): Promise<PoolState>;
+/**
+ * Find pools with liquidity from a list of pool configurations
+ *
+ * @returns Array of pool states sorted by liquidity (descending)
+ */
+export declare function findPoolsWithLiquidity(publicClient: ReadClient, stateViewAddress: Address, pools: PoolConfig[]): Promise<PoolState[]>;
+/**
+ * Get the best pool (highest liquidity) from a list
+ */
+export declare function findBestPool(publicClient: ReadClient, stateViewAddress: Address, pools: PoolConfig[]): Promise<PoolState | null>;
+export {};

package/dist/uniswap-adapter/find-pools.js

@@ -0,0 +1,108 @@
+/**
+ * Find Uniswap V4 pools with liquidity
+ *
+ * Uses the StateView contract to query pool state and liquidity.
+ */
+import { encodeAbiParameters, keccak256, parseAbi } from 'viem';
+import { InvalidContractReturnType } from '../errors.js';
+// StateView ABI for reading pool state
+const STATE_VIEW_ABI = parseAbi([
+    'function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)',
+    'function getLiquidity(bytes32 poolId) view returns (uint128)',
+]);
+/**
+ * Compute pool ID from pool key
+ *
+ * Pool ID is keccak256(abi.encode(poolKey))
+ */
+export function computePoolId(pool) {
+    return keccak256(encodeAbiParameters([
+        { type: 'address', name: 'currency0' },
+        { type: 'address', name: 'currency1' },
+        { type: 'uint24', name: 'fee' },
+        { type: 'int24', name: 'tickSpacing' },
+        { type: 'address', name: 'hooks' },
+    ], [pool.currency0, pool.currency1, pool.fee, pool.tickSpacing, pool.hooks]));
+}
+/**
+ * Get pool state from StateView contract
+ */
+export async function getPoolState(publicClient, stateViewAddress, pool) {
+    const poolId = computePoolId(pool);
+    const [slot0, liquidity] = await Promise.all([
+        publicClient.readContract({
+            address: stateViewAddress,
+            abi: STATE_VIEW_ABI,
+            functionName: 'getSlot0',
+            args: [poolId],
+        }),
+        publicClient.readContract({
+            address: stateViewAddress,
+            abi: STATE_VIEW_ABI,
+            functionName: 'getLiquidity',
+            args: [poolId],
+        }),
+    ]);
+    if (!Array.isArray(slot0) ||
+        typeof slot0[0] !== 'bigint' ||
+        typeof slot0[1] !== 'number') {
+        throw new InvalidContractReturnType({
+            message: 'Expected slot0 tuple from getSlot0',
+            functionName: 'getSlot0',
+            expectedType: '[bigint sqrtPriceX96, number tick, ...]',
+        });
+    }
+    const sqrtPriceX96 = slot0[0];
+    const tick = slot0[1];
+    if (typeof liquidity !== 'bigint') {
+        throw new InvalidContractReturnType({
+            message: 'Expected bigint liquidity from getLiquidity',
+            functionName: 'getLiquidity',
+            expectedType: 'bigint',
+        });
+    }
+    const liquidityValue = liquidity;
+    return {
+        pool,
+        poolId,
+        liquidity: liquidityValue,
+        tick,
+        sqrtPriceX96,
+        isInitialized: sqrtPriceX96 > 0n,
+        hasLiquidity: liquidityValue > 0n,
+    };
+}
+/**
+ * Find pools with liquidity from a list of pool configurations
+ *
+ * @returns Array of pool states sorted by liquidity (descending)
+ */
+export async function findPoolsWithLiquidity(publicClient, stateViewAddress, pools) {
+    const results = [];
+    for (const pool of pools) {
+        try {
+            const state = await getPoolState(publicClient, stateViewAddress, pool);
+            results.push(state);
+        }
+        catch (error) {
+            // Only skip if pool doesn't exist (sqrtPriceX96 is 0)
+            // Re-throw unexpected errors (network failures, etc.)
+            if (error instanceof Error &&
+                error.message.includes('returned no data')) {
+                continue; // Pool not initialized, expected
+            }
+            console.warn(`Failed to query pool ${pool.name}:`, error);
+        }
+    }
+    // Filter to pools with liquidity and sort by liquidity descending
+    return results
+        .filter((r) => r.hasLiquidity)
+        .sort((a, b) => (b.liquidity > a.liquidity ? 1 : -1));
+}
+/**
+ * Get the best pool (highest liquidity) from a list
+ */
+export async function findBestPool(publicClient, stateViewAddress, pools) {
+    const poolsWithLiquidity = await findPoolsWithLiquidity(publicClient, stateViewAddress, pools);
+    return poolsWithLiquidity[0] ?? null;
+}

package/dist/uniswap-adapter/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * UniswapV4 Adapter SDK for IncoShield
+ *
+ * Provides functions for:
+ * - Finding Uniswap V4 pools with liquidity
+ * - Building and executing swaps through IncoShield
+ */
+export { DEPLOYED_CONTRACTS, type DeployedContracts, POOL_CONFIG, SEPOLIA_CHAIN_ID, SEPOLIA_TOKENS, UNISWAP_V4_SEPOLIA, WETH_USDC_POOL_CONFIG, } from './config.js';
+export { computePoolId, findBestPool, findPoolsWithLiquidity, getPoolState, type PoolConfig, type PoolKey, type PoolState, } from './find-pools.js';
+export { approveToken, type BuildV4ActionsParams, buildDefiInteraction, buildDeposit, buildEncodedV4Actions, type DefiInteractionParams, type DepositParams, depositToShield, encodeSwapArgs, executeDefiInteraction, generateNullifier, getDefiInteractionDigest, getTokenBalance, signDefiInteraction, type UniswapV4SwapArgs, } from './swap.js';

package/dist/uniswap-adapter/index.js

@@ -0,0 +1,13 @@
+/**
+ * UniswapV4 Adapter SDK for IncoShield
+ *
+ * Provides functions for:
+ * - Finding Uniswap V4 pools with liquidity
+ * - Building and executing swaps through IncoShield
+ */
+// Configuration
+export { DEPLOYED_CONTRACTS, POOL_CONFIG, SEPOLIA_CHAIN_ID, SEPOLIA_TOKENS, UNISWAP_V4_SEPOLIA, WETH_USDC_POOL_CONFIG, } from './config.js';
+// Pool discovery
+export { computePoolId, findBestPool, findPoolsWithLiquidity, getPoolState, } from './find-pools.js';
+// Swap functionality
+export { approveToken, buildDefiInteraction, buildDeposit, buildEncodedV4Actions, depositToShield, encodeSwapArgs, executeDefiInteraction, generateNullifier, getDefiInteractionDigest, getTokenBalance, signDefiInteraction, } from './swap.js';