@wiimdy/openfunderse-agents 0.1.1

package/dist/lib/aa-client.js

@@ -0,0 +1,353 @@
+import { concatHex, createPublicClient, defineChain, encodeFunctionData, http, padHex, parseAbi, toHex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+const ENTRYPOINT_V07_ABI = parseAbi([
+    'function getNonce(address sender, uint192 key) view returns (uint256)',
+    'function getUserOpHash((address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData,bytes signature) userOp) view returns (bytes32)'
+]);
+const ENTRYPOINT_V06_ABI = parseAbi([
+    'function getNonce(address sender, uint192 key) view returns (uint256)',
+    'function getUserOpHash((address sender,uint256 nonce,bytes initCode,bytes callData,uint256 callGasLimit,uint256 verificationGasLimit,uint256 preVerificationGas,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,bytes paymasterAndData,bytes signature) userOp) view returns (bytes32)'
+]);
+const SIMPLE_ACCOUNT_ABI = parseAbi([
+    'function execute(address dest, uint256 value, bytes data)'
+]);
+const DEFAULT_CALL_GAS_LIMIT = 400000n;
+const DEFAULT_VERIFICATION_GAS_LIMIT = 300000n;
+const DEFAULT_PRE_VERIFICATION_GAS_V07 = 60000n;
+const DEFAULT_PRE_VERIFICATION_GAS_V06 = 2000000n;
+const DEFAULT_POLL_INTERVAL_MS = 3_000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+const toU128Hex = (value) => {
+    if (value < 0n) {
+        throw new Error('u128 value must be non-negative');
+    }
+    return padHex(toHex(value), { size: 16 });
+};
+const packU128 = (left, right) => {
+    return concatHex([toU128Hex(left), toU128Hex(right)]);
+};
+export class StrategyAaClient {
+    config;
+    publicClient;
+    owner;
+    constructor(config) {
+        this.config = config;
+        this.owner = privateKeyToAccount(config.ownerPrivateKey);
+        const chain = defineChain({
+            id: config.chainId,
+            name: `strategy-aa-${config.chainId}`,
+            nativeCurrency: { name: 'MON', symbol: 'MON', decimals: 18 },
+            rpcUrls: {
+                default: { http: [config.rpcUrl] },
+                public: { http: [config.rpcUrl] }
+            }
+        });
+        this.publicClient = createPublicClient({
+            chain,
+            transport: http(config.rpcUrl)
+        });
+    }
+    static fromEnv(overrides = {}) {
+        const chainIdRaw = process.env.CHAIN_ID ?? '10143';
+        const envChainId = Number(chainIdRaw);
+        const chainId = overrides.chainId ?? envChainId;
+        const rpcUrl = overrides.rpcUrl ?? process.env.STRATEGY_AA_RPC_URL ?? process.env.RPC_URL ?? '';
+        const bundlerUrl = overrides.bundlerUrl ?? process.env.STRATEGY_AA_BUNDLER_URL ?? '';
+        const entryPoint = overrides.entryPoint ?? process.env.STRATEGY_AA_ENTRYPOINT_ADDRESS ?? '';
+        const smartAccount = overrides.smartAccount ?? process.env.STRATEGY_AA_ACCOUNT_ADDRESS ?? '';
+        const ownerPrivateKey = overrides.ownerPrivateKey ??
+            process.env.STRATEGY_AA_OWNER_PRIVATE_KEY ??
+            process.env.STRATEGY_PRIVATE_KEY ??
+            '';
+        const rawUserOpVersion = (overrides.userOpVersion ?? process.env.STRATEGY_AA_USER_OP_VERSION ?? 'v07')
+            .toLowerCase();
+        if (rawUserOpVersion !== 'v06' && rawUserOpVersion !== 'v07') {
+            throw new Error('STRATEGY_AA_USER_OP_VERSION must be one of: v06, v07');
+        }
+        if (!rpcUrl)
+            throw new Error('STRATEGY_AA_RPC_URL (or RPC_URL) is required');
+        if (!bundlerUrl)
+            throw new Error('STRATEGY_AA_BUNDLER_URL is required');
+        if (!entryPoint)
+            throw new Error('STRATEGY_AA_ENTRYPOINT_ADDRESS is required');
+        if (!smartAccount)
+            throw new Error('STRATEGY_AA_ACCOUNT_ADDRESS is required');
+        if (!ownerPrivateKey) {
+            throw new Error('STRATEGY_AA_OWNER_PRIVATE_KEY (or STRATEGY_PRIVATE_KEY) is required');
+        }
+        if (!Number.isFinite(chainId) || chainId <= 0) {
+            throw new Error('CHAIN_ID must be a positive number');
+        }
+        const parseBigIntEnv = (name) => {
+            const raw = process.env[name];
+            if (!raw || raw.trim().length === 0)
+                return undefined;
+            return BigInt(raw);
+        };
+        const parseNumberEnv = (name) => {
+            const raw = process.env[name];
+            if (!raw || raw.trim().length === 0)
+                return undefined;
+            const value = Number(raw);
+            if (!Number.isFinite(value) || value <= 0) {
+                throw new Error(`${name} must be a positive number`);
+            }
+            return Math.trunc(value);
+        };
+        return new StrategyAaClient({
+            chainId: Math.trunc(chainId),
+            rpcUrl,
+            bundlerUrl,
+            entryPoint: entryPoint,
+            smartAccount: smartAccount,
+            ownerPrivateKey: ownerPrivateKey,
+            initCode: overrides.initCode ??
+                (process.env.STRATEGY_AA_INIT_CODE ?? '0x'),
+            callGasLimit: overrides.callGasLimit ?? parseBigIntEnv('STRATEGY_AA_CALL_GAS_LIMIT'),
+            verificationGasLimit: overrides.verificationGasLimit ?? parseBigIntEnv('STRATEGY_AA_VERIFICATION_GAS_LIMIT'),
+            preVerificationGas: overrides.preVerificationGas ?? parseBigIntEnv('STRATEGY_AA_PRE_VERIFICATION_GAS'),
+            maxPriorityFeePerGas: overrides.maxPriorityFeePerGas ?? parseBigIntEnv('STRATEGY_AA_MAX_PRIORITY_FEE_PER_GAS'),
+            maxFeePerGas: overrides.maxFeePerGas ?? parseBigIntEnv('STRATEGY_AA_MAX_FEE_PER_GAS'),
+            pollIntervalMs: overrides.pollIntervalMs ?? parseNumberEnv('STRATEGY_AA_POLL_INTERVAL_MS'),
+            timeoutMs: overrides.timeoutMs ?? parseNumberEnv('STRATEGY_AA_TIMEOUT_MS'),
+            userOpVersion: rawUserOpVersion
+        });
+    }
+    async sendExecute(input) {
+        const callData = encodeFunctionData({
+            abi: SIMPLE_ACCOUNT_ABI,
+            functionName: 'execute',
+            args: [input.target, input.value ?? 0n, input.data]
+        });
+        return this.sendUserOperation(callData);
+    }
+    async sendUserOperation(callData) {
+        if (this.userOpVersion() === 'v06') {
+            const userOp = await this.buildSignedUserOperationV06(callData);
+            const rpcUserOp = this.toRpcUserOperationV06(userOp);
+            return this.submitUserOperation(rpcUserOp);
+        }
+        const userOp = await this.buildSignedUserOperationV07(callData);
+        const rpcUserOp = this.toRpcUserOperationV07(userOp);
+        return this.submitUserOperation(rpcUserOp);
+    }
+    async waitForUserOperationReceipt(userOpHash) {
+        const pollIntervalMs = this.config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const timeoutMs = this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() <= deadline) {
+            const receipt = await this.callBundler('eth_getUserOperationReceipt', [userOpHash]);
+            if (receipt) {
+                return receipt;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        throw new Error(`UserOperation receipt timeout after ${timeoutMs}ms: ${userOpHash}`);
+    }
+    userOpVersion() {
+        return this.config.userOpVersion ?? 'v07';
+    }
+    async submitUserOperation(rpcUserOp) {
+        const userOpHash = await this.callBundler('eth_sendUserOperation', [
+            rpcUserOp,
+            this.config.entryPoint
+        ]);
+        const receipt = await this.waitForUserOperationReceipt(userOpHash);
+        const maybeTxHash = receipt?.receipt
+            ?.transactionHash;
+        const transactionHash = typeof maybeTxHash === 'string' && /^0x[0-9a-fA-F]{64}$/.test(maybeTxHash)
+            ? maybeTxHash
+            : null;
+        return {
+            userOpHash,
+            receipt,
+            transactionHash
+        };
+    }
+    async resolveGasFees(preferBundlerGasRpc) {
+        let maxPriorityFeePerGas = this.config.maxPriorityFeePerGas;
+        let maxFeePerGas = this.config.maxFeePerGas;
+        if (preferBundlerGasRpc && (maxPriorityFeePerGas === undefined || maxFeePerGas === undefined)) {
+            const bundlerGas = await this.tryResolveBundlerGasFees();
+            if (bundlerGas) {
+                maxPriorityFeePerGas = maxPriorityFeePerGas ?? bundlerGas.maxPriorityFeePerGas;
+                maxFeePerGas = maxFeePerGas ?? bundlerGas.maxFeePerGas;
+            }
+        }
+        if (maxPriorityFeePerGas === undefined || maxFeePerGas === undefined) {
+            try {
+                const fee = await this.publicClient.estimateFeesPerGas();
+                const fallback = fee.gasPrice ?? 1n;
+                maxPriorityFeePerGas = maxPriorityFeePerGas ?? fee.maxPriorityFeePerGas ?? fallback;
+                maxFeePerGas = maxFeePerGas ?? fee.maxFeePerGas ?? fallback;
+            }
+            catch {
+                const gasPrice = await this.publicClient.getGasPrice();
+                maxPriorityFeePerGas = maxPriorityFeePerGas ?? gasPrice;
+                maxFeePerGas = maxFeePerGas ?? gasPrice;
+            }
+        }
+        return { maxPriorityFeePerGas, maxFeePerGas };
+    }
+    parseBigIntLike(raw) {
+        if (typeof raw === 'bigint') {
+            return raw;
+        }
+        if (typeof raw === 'number') {
+            if (!Number.isFinite(raw) || raw < 0)
+                return null;
+            return BigInt(Math.trunc(raw));
+        }
+        if (typeof raw === 'string' && raw.trim().length > 0) {
+            try {
+                return BigInt(raw);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    async tryResolveBundlerGasFees() {
+        try {
+            const response = await this.callBundler('pimlico_getUserOperationGasPrice', []);
+            const level = response.standard ?? response.fast ?? response.slow;
+            if (!level)
+                return null;
+            const maxFeePerGas = this.parseBigIntLike(level.maxFeePerGas);
+            const maxPriorityFeePerGas = this.parseBigIntLike(level.maxPriorityFeePerGas);
+            if (maxFeePerGas === null || maxPriorityFeePerGas === null) {
+                return null;
+            }
+            return { maxPriorityFeePerGas, maxFeePerGas };
+        }
+        catch {
+            return null;
+        }
+    }
+    async buildSignedUserOperationV07(callData) {
+        const nonce = await this.publicClient.readContract({
+            address: this.config.entryPoint,
+            abi: ENTRYPOINT_V07_ABI,
+            functionName: 'getNonce',
+            args: [this.config.smartAccount, 0n]
+        });
+        const { maxPriorityFeePerGas, maxFeePerGas } = await this.resolveGasFees(false);
+        const callGasLimit = this.config.callGasLimit ?? DEFAULT_CALL_GAS_LIMIT;
+        const verificationGasLimit = this.config.verificationGasLimit ?? DEFAULT_VERIFICATION_GAS_LIMIT;
+        const preVerificationGas = this.config.preVerificationGas ?? DEFAULT_PRE_VERIFICATION_GAS_V07;
+        const draft = {
+            sender: this.config.smartAccount,
+            nonce,
+            initCode: this.config.initCode ?? '0x',
+            callData,
+            accountGasLimits: packU128(verificationGasLimit, callGasLimit),
+            preVerificationGas,
+            gasFees: packU128(maxPriorityFeePerGas, maxFeePerGas),
+            paymasterAndData: '0x',
+            signature: '0x'
+        };
+        const userOpHash = await this.publicClient.readContract({
+            address: this.config.entryPoint,
+            abi: ENTRYPOINT_V07_ABI,
+            functionName: 'getUserOpHash',
+            args: [draft]
+        });
+        const signature = await this.owner.signMessage({
+            message: { raw: userOpHash }
+        });
+        return {
+            ...draft,
+            signature
+        };
+    }
+    async buildSignedUserOperationV06(callData) {
+        const nonce = await this.publicClient.readContract({
+            address: this.config.entryPoint,
+            abi: ENTRYPOINT_V06_ABI,
+            functionName: 'getNonce',
+            args: [this.config.smartAccount, 0n]
+        });
+        const { maxPriorityFeePerGas, maxFeePerGas } = await this.resolveGasFees(true);
+        const callGasLimit = this.config.callGasLimit ?? DEFAULT_CALL_GAS_LIMIT;
+        const verificationGasLimit = this.config.verificationGasLimit ?? DEFAULT_VERIFICATION_GAS_LIMIT;
+        const preVerificationGas = this.config.preVerificationGas ?? DEFAULT_PRE_VERIFICATION_GAS_V06;
+        const draft = {
+            sender: this.config.smartAccount,
+            nonce,
+            initCode: this.config.initCode ?? '0x',
+            callData,
+            callGasLimit,
+            verificationGasLimit,
+            preVerificationGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            paymasterAndData: '0x',
+            signature: '0x'
+        };
+        const userOpHash = await this.publicClient.readContract({
+            address: this.config.entryPoint,
+            abi: ENTRYPOINT_V06_ABI,
+            functionName: 'getUserOpHash',
+            args: [draft]
+        });
+        const signature = await this.owner.signMessage({
+            message: { raw: userOpHash }
+        });
+        return {
+            ...draft,
+            signature
+        };
+    }
+    toRpcUserOperationV07(userOp) {
+        return {
+            sender: userOp.sender,
+            nonce: toHex(userOp.nonce),
+            initCode: userOp.initCode,
+            callData: userOp.callData,
+            accountGasLimits: userOp.accountGasLimits,
+            preVerificationGas: toHex(userOp.preVerificationGas),
+            gasFees: userOp.gasFees,
+            paymasterAndData: userOp.paymasterAndData,
+            signature: userOp.signature
+        };
+    }
+    toRpcUserOperationV06(userOp) {
+        return {
+            sender: userOp.sender,
+            nonce: toHex(userOp.nonce),
+            initCode: userOp.initCode,
+            callData: userOp.callData,
+            callGasLimit: toHex(userOp.callGasLimit),
+            verificationGasLimit: toHex(userOp.verificationGasLimit),
+            preVerificationGas: toHex(userOp.preVerificationGas),
+            maxFeePerGas: toHex(userOp.maxFeePerGas),
+            maxPriorityFeePerGas: toHex(userOp.maxPriorityFeePerGas),
+            paymasterAndData: userOp.paymasterAndData,
+            signature: userOp.signature
+        };
+    }
+    async callBundler(method, params) {
+        const payload = {
+            jsonrpc: '2.0',
+            id: Date.now(),
+            method,
+            params
+        };
+        const response = await fetch(this.config.bundlerUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+            throw new Error(`Bundler request failed (${response.status}): ${response.statusText}`);
+        }
+        const json = (await response.json());
+        if ('error' in json) {
+            throw new Error(`Bundler RPC error ${json.error.code}: ${json.error.message}${json.error.data ? ` (${JSON.stringify(json.error.data)})` : ''}`);
+        }
+        return json.result;
+    }
+}

package/dist/lib/relayer-client.d.ts

@@ -0,0 +1,171 @@
+import { type Address, type ClaimPayload, type Hex, type IntentExecutionRouteInput, type TradeIntent } from '@claw/protocol-sdk';
+export interface ClaimTemplateInput {
+    templateType: string;
+    sourceRef: string;
+    raw: unknown;
+    observedAt?: bigint | number | string;
+    meta?: Record<string, unknown>;
+    sourceType?: string;
+    selector?: string;
+    extractedType?: string;
+    evidenceType?: string;
+    evidenceURI?: string;
+    notes?: string;
+    crawler?: Address;
+}
+export interface ClaimQuery {
+    status?: 'PENDING' | 'APPROVED' | 'REJECTED';
+    epochId?: bigint | number | string;
+    limit?: number;
+    offset?: number;
+}
+export interface ClaimAttestationInput {
+    claimHash: Hex;
+    epochId: bigint | number | string;
+    verifier: Address;
+    expiresAt: bigint | number | string;
+    nonce: bigint | number | string;
+    signature: Hex;
+}
+export interface IntentAttestationInput {
+    intentHash: Hex;
+    verifier: Address;
+    expiresAt: bigint | number | string;
+    nonce: bigint | number | string;
+    signature: Hex;
+}
+export interface RelayerProposeIntentInput {
+    intent: TradeIntent;
+    executionRoute: IntentExecutionRouteInput;
+    maxNotional?: bigint | number | string;
+    intentURI?: string;
+}
+export interface RelayerClientOptions {
+    baseUrl?: string;
+    botId?: string;
+    botApiKey?: string;
+    botAddress?: Address;
+    requestTimeoutMs?: number;
+    maxRetries?: number;
+    retryBaseDelayMs?: number;
+    authOnRead?: boolean;
+    defaultHeaders?: Record<string, string>;
+}
+export interface RelayerHttpErrorShape {
+    endpoint: string;
+    status: number | null;
+    code: string;
+    message: string;
+    retryable: boolean;
+    requestId: string;
+    details?: unknown;
+}
+export declare class RelayerHttpError extends Error implements RelayerHttpErrorShape {
+    endpoint: string;
+    status: number | null;
+    code: string;
+    retryable: boolean;
+    requestId: string;
+    details?: unknown;
+    constructor(shape: RelayerHttpErrorShape);
+}
+export interface SseEvent<TType extends string = string, TData = unknown> {
+    type: TType;
+    id: string;
+    data: TData;
+}
+export interface SseHandlers<TType extends string> {
+    onOpen?: () => void;
+    onEvent?: (event: SseEvent<TType>) => void;
+    onError?: (error: unknown) => void;
+}
+export interface SseSubscription {
+    close: () => void;
+}
+type ClaimEventType = 'claim:attested' | 'snapshot:finalized';
+type IntentEventType = 'intent:attested';
+interface SubmitClaimResponse {
+    claimHash: Hex;
+}
+export interface IntentOnchainBundleItem {
+    verifier: Address;
+    expiresAt: string;
+    nonce: string;
+    signature: Hex;
+}
+export interface IntentOnchainBundleResponse {
+    intentHash: Hex;
+    subjectState: 'PENDING' | 'READY_FOR_ONCHAIN' | 'APPROVED' | 'REJECTED';
+    thresholdWeight: string;
+    attestedWeight: string;
+    thresholdReached: boolean;
+    verifiers: Address[];
+    signatures: Hex[];
+    attestations: IntentOnchainBundleItem[];
+}
+export interface ReadyExecutionPayloadItem {
+    jobId: number;
+    intentHash: Hex;
+    jobStatus: string;
+    attemptCount: number;
+    nextRunAt: number;
+    maxNotional: string;
+    deadline: string;
+    intent: TradeIntent;
+    executionRoute: IntentExecutionRouteInput;
+}
+export interface SyncFundDeploymentInput {
+    fundId: string;
+    fundName: string;
+    strategyBotId: string;
+    strategyBotAddress: Address;
+    txHash: Hex;
+    verifierThresholdWeight?: bigint | number | string;
+    intentThresholdWeight?: bigint | number | string;
+    strategyPolicyUri?: string;
+    telegramRoomId?: string;
+    telegramHandle?: string;
+}
+export declare class RelayerClient {
+    private readonly baseUrl;
+    private readonly botId;
+    private readonly botApiKey;
+    private readonly botAddress;
+    private readonly requestTimeoutMs;
+    private readonly maxRetries;
+    private readonly retryBaseDelayMs;
+    private readonly authOnRead;
+    private readonly defaultHeaders;
+    constructor(options?: RelayerClientOptions);
+    submitClaim(fundId: string, claimPayload: ClaimPayload, epochId: bigint | number | string): Promise<SubmitClaimResponse & Record<string, unknown>>;
+    submitClaimTemplate(fundId: string, template: ClaimTemplateInput, epochId: bigint | number | string): Promise<SubmitClaimResponse & Record<string, unknown> & {
+        localClaimHash: Hex;
+        canonicalPayload: ClaimPayload;
+    }>;
+    getClaims(fundId: string, query?: ClaimQuery): Promise<Record<string, unknown>>;
+    submitClaimAttestation(fundId: string, attestation: ClaimAttestationInput): Promise<Record<string, unknown>>;
+    getLatestSnapshot(fundId: string): Promise<Record<string, unknown>>;
+    proposeIntent(fundId: string, input: RelayerProposeIntentInput): Promise<Record<string, unknown>>;
+    submitIntentAttestations(fundId: string, attestations: IntentAttestationInput[]): Promise<Record<string, unknown>>;
+    getIntentOnchainBundle(fundId: string, intentHash: Hex): Promise<IntentOnchainBundleResponse & Record<string, unknown>>;
+    markIntentOnchainAttested(fundId: string, intentHash: Hex, txHash: Hex): Promise<Record<string, unknown>>;
+    listReadyExecutionPayloads(fundId: string, query?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown> & {
+        total: number;
+        items: ReadyExecutionPayloadItem[];
+    }>;
+    markIntentOnchainExecuted(fundId: string, intentHash: Hex, txHash: Hex): Promise<Record<string, unknown>>;
+    markIntentOnchainFailed(fundId: string, intentHash: Hex, error: string, retryDelayMs?: number): Promise<Record<string, unknown>>;
+    getFundStatus(fundId: string): Promise<Record<string, unknown>>;
+    syncFundDeployment(input: SyncFundDeploymentInput): Promise<Record<string, unknown>>;
+    subscribeClaimEvents(fundId: string, handlers: SseHandlers<ClaimEventType>): SseSubscription;
+    subscribeIntentEvents(fundId: string, handlers: SseHandlers<IntentEventType>): SseSubscription;
+    buildClaimPayloadFromTemplate(template: ClaimTemplateInput): ClaimPayload;
+    private subscribeToEvents;
+    private request;
+    private buildHeaders;
+}
+export declare const createRelayerClient: (options?: RelayerClientOptions) => RelayerClient;
+export {};