@inco/shield-js 0.1.0 → 0.2.0

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

@@ -1,344 +0,0 @@
-/**
- * UniswapV4 swap functionality for IncoShield
- *
- * Provides functions to:
- * - Build V4 swap actions
- * - Encode swap arguments
- * - Execute swaps through the IncoShield DeFi adapter
- */
-import type { Account, Address, Chain, Hex, LocalAccount, Transport } from 'viem';
-import { type PublicClient, type WalletClient } from 'viem';
-import type { PoolKey } from './find-pools.js';
-declare const ERC20_ABI: readonly [{
-    readonly name: "approve";
-    readonly type: "function";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [{
-        readonly type: "address";
-        readonly name: "spender";
-    }, {
-        readonly type: "uint256";
-        readonly name: "amount";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bool";
-    }];
-}, {
-    readonly name: "balanceOf";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly type: "address";
-        readonly name: "account";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-}];
-declare const INCO_SHIELD_ABI: readonly [{
-    readonly name: "DepositSettled";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly type: "bytes32";
-        readonly name: "stateAfterDeposit";
-        readonly indexed: true;
-    }];
-}, {
-    readonly name: "deposit";
-    readonly type: "function";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [{
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "bytes";
-            readonly name: "toCiphertext";
-        }, {
-            readonly type: "address";
-            readonly name: "from";
-        }, {
-            readonly type: "tuple";
-            readonly components: readonly [{
-                readonly type: "address";
-                readonly name: "assetAdapter";
-            }, {
-                readonly type: "bytes";
-                readonly name: "assetIdentificationArgs";
-            }, {
-                readonly type: "bytes";
-                readonly name: "movementArgs";
-            }];
-            readonly name: "assetMovement";
-        }, {
-            readonly type: "uint256";
-            readonly name: "amount";
-        }, {
-            readonly type: "bytes";
-            readonly name: "memo";
-        }, {
-            readonly type: "bytes";
-            readonly name: "escapeHatch";
-        }];
-        readonly name: "_deposit";
-    }];
-    readonly outputs: readonly [];
-}, {
-    readonly name: "performDefiInteraction";
-    readonly type: "function";
-    readonly stateMutability: "nonpayable";
-    readonly inputs: readonly [{
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "tuple";
-            readonly components: readonly [{
-                readonly type: "address";
-                readonly name: "to";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "nullifier";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "pastShieldHandle";
-            }, {
-                readonly type: "tuple";
-                readonly components: readonly [{
-                    readonly type: "address";
-                    readonly name: "assetAdapter";
-                }, {
-                    readonly type: "bytes";
-                    readonly name: "assetIdentificationArgs";
-                }, {
-                    readonly type: "bytes";
-                    readonly name: "movementArgs";
-                }];
-                readonly name: "assetMovement";
-            }, {
-                readonly type: "uint256";
-                readonly name: "amount";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "sessionKeyHash";
-            }, {
-                readonly type: "bytes";
-                readonly name: "memo";
-            }];
-            readonly name: "withdrawal";
-        }, {
-            readonly type: "address";
-            readonly name: "defiAdapter";
-        }, {
-            readonly type: "bytes";
-            readonly name: "adapterArgs";
-        }];
-        readonly name: "_defiInteraction";
-    }, {
-        readonly type: "bytes";
-        readonly name: "signature";
-    }];
-    readonly outputs: readonly [];
-}, {
-    readonly name: "defiInteractionDigest";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly type: "tuple";
-        readonly components: readonly [{
-            readonly type: "tuple";
-            readonly components: readonly [{
-                readonly type: "address";
-                readonly name: "to";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "nullifier";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "pastShieldHandle";
-            }, {
-                readonly type: "tuple";
-                readonly components: readonly [{
-                    readonly type: "address";
-                    readonly name: "assetAdapter";
-                }, {
-                    readonly type: "bytes";
-                    readonly name: "assetIdentificationArgs";
-                }, {
-                    readonly type: "bytes";
-                    readonly name: "movementArgs";
-                }];
-                readonly name: "assetMovement";
-            }, {
-                readonly type: "uint256";
-                readonly name: "amount";
-            }, {
-                readonly type: "bytes32";
-                readonly name: "sessionKeyHash";
-            }, {
-                readonly type: "bytes";
-                readonly name: "memo";
-            }];
-            readonly name: "withdrawal";
-        }, {
-            readonly type: "address";
-            readonly name: "defiAdapter";
-        }, {
-            readonly type: "bytes";
-            readonly name: "adapterArgs";
-        }];
-        readonly name: "_defiInteraction";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bytes32";
-    }];
-}];
-/** Arguments for UniswapV4 swap */
-export interface UniswapV4SwapArgs {
-    encodedV4Actions: Hex;
-    tokenIn: Address;
-    tokenOut: Address;
-    amountOutMinimum: bigint;
-    toCiphertext: Hex;
-    deadline: bigint;
-    unwrapWeth: boolean;
-}
-/** Parameters for building V4 swap actions */
-export interface BuildV4ActionsParams {
-    poolKey: PoolKey;
-    zeroForOne: boolean;
-    amountIn: bigint;
-    amountOutMinimum: bigint;
-}
-/** Deposit parameters for IncoShield */
-export interface DepositParams {
-    toCiphertext: Hex;
-    from: Address;
-    assetAdapter: Address;
-    tokenAddress: Address;
-    amount: bigint;
-    memo?: Hex;
-    escapeHatch?: Hex;
-}
-/** DefiInteraction parameters */
-export interface DefiInteractionParams {
-    to: Address;
-    nullifier: Hex;
-    pastShieldHandle: Hex;
-    assetAdapter: Address;
-    tokenAddress: Address;
-    amount: bigint;
-    sessionKeyHash?: Hex;
-    memo?: Hex;
-    defiAdapter: Address;
-    adapterArgs: Hex;
-}
-type TransactionLog = {
-    address: Address;
-    topics: readonly Hex[];
-};
-type WaitForReceiptParams = Parameters<PublicClient<Transport, Chain>['waitForTransactionReceipt']>;
-type WaitForReceiptResult = {
-    status: 'success' | 'reverted';
-    blockNumber?: bigint;
-    logs?: readonly TransactionLog[];
-};
-export interface ReadClient {
-    readContract(...args: Parameters<PublicClient<Transport, Chain>['readContract']>): Promise<unknown>;
-    waitForTransactionReceipt(...args: WaitForReceiptParams): Promise<WaitForReceiptResult>;
-    simulateContract?(...args: Parameters<PublicClient<Transport, Chain>['simulateContract']>): Promise<unknown>;
-}
-export interface WriteClient {
-    writeContract(...args: Parameters<WalletClient<Transport, Chain, Account>['writeContract']>): Promise<Hex>;
-}
-export type Signer = Pick<LocalAccount, 'address'> & {
-    sign: NonNullable<LocalAccount['sign']>;
-};
-/**
- * Build encoded V4 actions for a swap
- *
- * @returns Encoded bytes to pass to Universal Router
- */
-export declare function buildEncodedV4Actions(params: BuildV4ActionsParams): Hex;
-/**
- * Encode UniswapV4SwapArgs to bytes
- */
-export declare function encodeSwapArgs(args: UniswapV4SwapArgs): Hex;
-/**
- * Generate a unique nullifier for a transaction.
- *
- * Uses cryptographically secure random bytes combined with address
- * to prevent collision attacks and replay vulnerabilities.
- *
- * @param address - The user's address
- * @param nonce - Optional explicit nonce (for deterministic testing)
- */
-export declare function generateNullifier(address: Address, nonce?: bigint): Hex;
-/**
- * Build deposit struct for IncoShield
- */
-export declare function buildDeposit(params: DepositParams): {
-    toCiphertext: `0x${string}`;
-    from: `0x${string}`;
-    assetMovement: {
-        assetAdapter: `0x${string}`;
-        assetIdentificationArgs: `0x${string}`;
-        movementArgs: `0x${string}`;
-    };
-    amount: bigint;
-    memo: `0x${string}`;
-    escapeHatch: `0x${string}`;
-};
-/**
- * Build DefiInteraction struct for IncoShield
- */
-export declare function buildDefiInteraction(params: DefiInteractionParams): {
-    withdrawal: {
-        to: `0x${string}`;
-        nullifier: `0x${string}`;
-        pastShieldHandle: `0x${string}`;
-        assetMovement: {
-            assetAdapter: `0x${string}`;
-            assetIdentificationArgs: `0x${string}`;
-            movementArgs: `0x${string}`;
-        };
-        amount: bigint;
-        sessionKeyHash: `0x${string}`;
-        memo: `0x${string}`;
-    };
-    defiAdapter: `0x${string}`;
-    adapterArgs: `0x${string}`;
-};
-/**
- * Get token balance
- */
-export declare function getTokenBalance(publicClient: ReadClient, tokenAddress: Address, account: Address): Promise<bigint>;
-/**
- * Approve token spending
- */
-export declare function approveToken(walletClient: WriteClient, publicClient: ReadClient, tokenAddress: Address, spender: Address, amount: bigint): Promise<Hex>;
-/**
- * Deposit tokens into IncoShield
- */
-export declare function depositToShield(walletClient: WriteClient, publicClient: ReadClient, incoShieldAddress: Address, params: DepositParams): Promise<{
-    txHash: Hex;
-    stateAfterDeposit: Hex;
-}>;
-/**
- * Get digest for DefiInteraction signature
- */
-export declare function getDefiInteractionDigest(publicClient: ReadClient, incoShieldAddress: Address, defiInteraction: ReturnType<typeof buildDefiInteraction>): Promise<Hex>;
-/**
- * Sign DefiInteraction and encode signature
- *
- * Uses raw signing (no message prefix) as expected by the contract.
- */
-export declare function signDefiInteraction(signer: Signer, digest: Hex): Promise<Hex>;
-/**
- * Execute performDefiInteraction on IncoShield
- */
-export declare function executeDefiInteraction(walletClient: WriteClient, publicClient: ReadClient, incoShieldAddress: Address, defiInteraction: ReturnType<typeof buildDefiInteraction>, signature: Hex, options?: {
-    gas?: bigint;
-    simulate?: boolean;
-    signerAddress?: Address;
-}): Promise<{
-    txHash: Hex;
-    blockNumber: bigint;
-}>;
-export { ERC20_ABI, INCO_SHIELD_ABI };

package/dist/uniswap-adapter/swap.js

@@ -1,309 +0,0 @@
-/**
- * UniswapV4 swap functionality for IncoShield
- *
- * Provides functions to:
- * - Build V4 swap actions
- * - Encode swap arguments
- * - Execute swaps through the IncoShield DeFi adapter
- */
-import { Actions, V4Planner } from '@uniswap/v4-sdk';
-import { encodeAbiParameters, encodePacked, isHex, keccak256, parseAbi, parseAbiParameters, } from 'viem';
-import { InvalidContractReturnType, InvalidTransactionReceipt, MalformedEventLog, MissingEventLog, TransactionReverted, } from '../errors.js';
-// ABIs
-const ERC20_ABI = parseAbi([
-    'function approve(address spender, uint256 amount) returns (bool)',
-    'function balanceOf(address account) view returns (uint256)',
-]);
-const INCO_SHIELD_ABI = parseAbi([
-    'event DepositSettled(bytes32 indexed stateAfterDeposit)',
-    'function deposit((bytes toCiphertext, address from, (address assetAdapter, bytes assetIdentificationArgs, bytes movementArgs) assetMovement, uint256 amount, bytes memo, bytes escapeHatch) _deposit) external',
-    'function performDefiInteraction(((address to, bytes32 nullifier, bytes32 pastShieldHandle, (address assetAdapter, bytes assetIdentificationArgs, bytes movementArgs) assetMovement, uint256 amount, bytes32 sessionKeyHash, bytes memo) withdrawal, address defiAdapter, bytes adapterArgs) _defiInteraction, bytes signature) external',
-    'function defiInteractionDigest(((address to, bytes32 nullifier, bytes32 pastShieldHandle, (address assetAdapter, bytes assetIdentificationArgs, bytes movementArgs) assetMovement, uint256 amount, bytes32 sessionKeyHash, bytes memo) withdrawal, address defiAdapter, bytes adapterArgs) _defiInteraction) view returns (bytes32)',
-]);
-// Event signature for DepositSettled - keccak256("DepositSettled(bytes32)")
-const DEPOSIT_SETTLED_EVENT_SIGNATURE = '0x945b4585fc853bcf3d386694bcb5b7b32cba8727f8cdf849c067da29294ee71e';
-function requireBigIntResult(value, functionName) {
-    if (typeof value !== 'bigint') {
-        throw new InvalidContractReturnType({
-            message: `${functionName} returned a non-bigint value`,
-            functionName,
-            expectedType: 'bigint',
-        });
-    }
-    return value;
-}
-function requireHexResult(value, functionName) {
-    if (!isHex(value)) {
-        throw new InvalidContractReturnType({
-            message: `${functionName} returned a non-hex value`,
-            functionName,
-            expectedType: 'Hex',
-        });
-    }
-    return value;
-}
-function requireBlockNumber(receipt) {
-    if (typeof receipt.blockNumber !== 'bigint') {
-        throw new InvalidTransactionReceipt({
-            message: 'Transaction receipt did not include a block number',
-        });
-    }
-    return receipt.blockNumber;
-}
-/**
- * Build encoded V4 actions for a swap
- *
- * @returns Encoded bytes to pass to Universal Router
- */
-export function buildEncodedV4Actions(params) {
-    const { poolKey, zeroForOne, amountIn, amountOutMinimum } = params;
-    const v4Planner = new V4Planner();
-    // Build swap config
-    const swapConfig = {
-        poolKey,
-        zeroForOne,
-        amountIn: amountIn.toString(),
-        amountOutMinimum: amountOutMinimum.toString(),
-        hookData: '0x',
-    };
-    v4Planner.addAction(Actions.SWAP_EXACT_IN_SINGLE, [swapConfig]);
-    // SETTLE_ALL: (currency, maxAmount)
-    const settleToken = zeroForOne ? poolKey.currency0 : poolKey.currency1;
-    v4Planner.addAction(Actions.SETTLE_ALL, [settleToken, amountIn.toString()]);
-    // TAKE_ALL: (currency, minAmount)
-    const takeToken = zeroForOne ? poolKey.currency1 : poolKey.currency0;
-    v4Planner.addAction(Actions.TAKE_ALL, [
-        takeToken,
-        amountOutMinimum.toString(),
-    ]);
-    const encodedActions = v4Planner.finalize();
-    if (!isHex(encodedActions)) {
-        throw new InvalidContractReturnType({
-            message: 'Expected hex-encoded V4 actions',
-            functionName: 'V4Planner.finalize',
-            expectedType: 'Hex',
-        });
-    }
-    return encodedActions;
-}
-/**
- * Encode UniswapV4SwapArgs to bytes
- */
-export function encodeSwapArgs(args) {
-    return encodeAbiParameters([
-        {
-            type: 'tuple',
-            components: [
-                { type: 'bytes', name: 'encodedV4Actions' },
-                { type: 'address', name: 'tokenIn' },
-                { type: 'address', name: 'tokenOut' },
-                { type: 'uint256', name: 'amountOutMinimum' },
-                { type: 'bytes', name: 'toCiphertext' },
-                { type: 'uint256', name: 'deadline' },
-                { type: 'bool', name: 'unwrapWeth' },
-            ],
-        },
-    ], [
-        {
-            encodedV4Actions: args.encodedV4Actions,
-            tokenIn: args.tokenIn,
-            tokenOut: args.tokenOut,
-            amountOutMinimum: args.amountOutMinimum,
-            toCiphertext: args.toCiphertext,
-            deadline: args.deadline,
-            unwrapWeth: args.unwrapWeth,
-        },
-    ]);
-}
-/**
- * Generate a unique nullifier for a transaction.
- *
- * Uses cryptographically secure random bytes combined with address
- * to prevent collision attacks and replay vulnerabilities.
- *
- * @param address - The user's address
- * @param nonce - Optional explicit nonce (for deterministic testing)
- */
-export function generateNullifier(address, nonce) {
-    if (nonce !== undefined) {
-        return keccak256(encodePacked(['address', 'uint256'], [address, nonce]));
-    }
-    // Use crypto random for production - prevents collision attacks
-    const randomBytes = crypto.getRandomValues(new Uint8Array(32));
-    const randomHex = `0x${Array.from(randomBytes)
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join('')}`;
-    if (!isHex(randomHex)) {
-        throw new InvalidContractReturnType({
-            message: `Expected hex from random byte encoding: ${randomHex}`,
-            functionName: 'generateNullifier',
-            expectedType: 'Hex',
-        });
-    }
-    return keccak256(encodePacked(['address', 'bytes32'], [address, randomHex]));
-}
-/**
- * Build deposit struct for IncoShield
- */
-export function buildDeposit(params) {
-    return {
-        toCiphertext: params.toCiphertext,
-        from: params.from,
-        assetMovement: {
-            assetAdapter: params.assetAdapter,
-            assetIdentificationArgs: encodeAbiParameters(parseAbiParameters('address'), [params.tokenAddress]),
-            movementArgs: encodeAbiParameters(parseAbiParameters('uint256'), [
-                params.amount,
-            ]),
-        },
-        amount: params.amount,
-        memo: params.memo ?? '0x',
-        escapeHatch: params.escapeHatch ?? '0x',
-    };
-}
-/**
- * Build DefiInteraction struct for IncoShield
- */
-export function buildDefiInteraction(params) {
-    return {
-        withdrawal: {
-            to: params.to,
-            nullifier: params.nullifier,
-            pastShieldHandle: params.pastShieldHandle,
-            assetMovement: {
-                assetAdapter: params.assetAdapter,
-                assetIdentificationArgs: encodeAbiParameters(parseAbiParameters('address'), [params.tokenAddress]),
-                movementArgs: encodeAbiParameters(parseAbiParameters('uint256'), [
-                    params.amount,
-                ]),
-            },
-            amount: params.amount,
-            sessionKeyHash: params.sessionKeyHash ??
-                '0x0000000000000000000000000000000000000000000000000000000000000001',
-            memo: params.memo ?? '0x',
-        },
-        defiAdapter: params.defiAdapter,
-        adapterArgs: params.adapterArgs,
-    };
-}
-/**
- * Get token balance
- */
-export async function getTokenBalance(publicClient, tokenAddress, account) {
-    const result = await publicClient.readContract({
-        address: tokenAddress,
-        abi: ERC20_ABI,
-        functionName: 'balanceOf',
-        args: [account],
-    });
-    return requireBigIntResult(result, 'balanceOf');
-}
-/**
- * Approve token spending
- */
-export async function approveToken(walletClient, publicClient, tokenAddress, spender, amount) {
-    const hash = await walletClient.writeContract({
-        address: tokenAddress,
-        abi: ERC20_ABI,
-        functionName: 'approve',
-        args: [spender, amount],
-    });
-    await publicClient.waitForTransactionReceipt({ hash });
-    return hash;
-}
-/**
- * Deposit tokens into IncoShield
- */
-export async function depositToShield(walletClient, publicClient, incoShieldAddress, params) {
-    const deposit = buildDeposit(params);
-    const hash = await walletClient.writeContract({
-        address: incoShieldAddress,
-        abi: INCO_SHIELD_ABI,
-        functionName: 'deposit',
-        args: [deposit],
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash });
-    if (receipt.status === 'reverted') {
-        throw new TransactionReverted({
-            message: 'Deposit transaction reverted',
-            operation: 'deposit',
-        });
-    }
-    // Find DepositSettled event to get handle
-    const depositSettledLog = (receipt.logs ?? []).find((log) => log.address.toLowerCase() === incoShieldAddress.toLowerCase() &&
-        log.topics[0] === DEPOSIT_SETTLED_EVENT_SIGNATURE);
-    if (!depositSettledLog) {
-        throw new MissingEventLog({
-            message: 'Could not find DepositSettled event',
-            eventName: 'DepositSettled',
-        });
-    }
-    const stateAfterDeposit = depositSettledLog.topics[1];
-    if (!stateAfterDeposit || !isHex(stateAfterDeposit)) {
-        throw new MalformedEventLog({
-            message: 'DepositSettled log did not include a handle topic',
-            eventName: 'DepositSettled',
-        });
-    }
-    return { txHash: hash, stateAfterDeposit };
-}
-/**
- * Get digest for DefiInteraction signature
- */
-export async function getDefiInteractionDigest(publicClient, incoShieldAddress, defiInteraction) {
-    const result = await publicClient.readContract({
-        address: incoShieldAddress,
-        abi: INCO_SHIELD_ABI,
-        functionName: 'defiInteractionDigest',
-        args: [defiInteraction],
-    });
-    return requireHexResult(result, 'defiInteractionDigest');
-}
-/**
- * Sign DefiInteraction and encode signature
- *
- * Uses raw signing (no message prefix) as expected by the contract.
- */
-export async function signDefiInteraction(signer, digest) {
-    // Use the account's sign method directly for raw hash signing (no prefix)
-    const rawSignature = await signer.sign({ hash: digest });
-    const signerBytes = signer.address;
-    return encodeAbiParameters([
-        { type: 'bytes[]', name: 'signers' },
-        { type: 'bytes[]', name: 'signatures' },
-    ], [[signerBytes], [rawSignature]]);
-}
-/**
- * Execute performDefiInteraction on IncoShield
- */
-export async function executeDefiInteraction(walletClient, publicClient, incoShieldAddress, defiInteraction, signature, options) {
-    // Optionally simulate first
-    if (options?.simulate &&
-        publicClient.simulateContract &&
-        options.signerAddress) {
-        await publicClient.simulateContract({
-            address: incoShieldAddress,
-            abi: INCO_SHIELD_ABI,
-            functionName: 'performDefiInteraction',
-            args: [defiInteraction, signature],
-            account: options.signerAddress,
-        });
-    }
-    const hash = await walletClient.writeContract({
-        address: incoShieldAddress,
-        abi: INCO_SHIELD_ABI,
-        functionName: 'performDefiInteraction',
-        args: [defiInteraction, signature],
-        gas: options?.gas,
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash });
-    if (receipt.status === 'reverted') {
-        throw new TransactionReverted({
-            message: 'DefiInteraction transaction reverted',
-            operation: 'performDefiInteraction',
-        });
-    }
-    return { txHash: hash, blockNumber: requireBlockNumber(receipt) };
-}
-// Re-export ABIs for external use
-export { ERC20_ABI, INCO_SHIELD_ABI };