@renegade-fi/node/dist/types/clients/renegade/base.d.ts

Node.js library for Renegade

import type { CancelOrderParameters, CreateOrderParameters, DepositParameters, GetBackOfQueueWalletParameters, GetOrderHistoryParameters, GetWalletFromRelayerParameters, OrderMetadata, RenegadeConfig, SDKConfig, UpdateOrderParameters, WithdrawParameters } from "@renegade-fi/core";
import { type Logger } from "@renegade-fi/core";
import type { PublicClient } from "viem";
import { type ExecuteDepositParameters } from "../../actions/executeDeposit.js";
import { type ExecuteWithdrawalParameters } from "../../actions/executeWithdrawal.js";
import { type GeneratedSecrets } from "../../actions/generateWalletSecrets.js";
import type { ConstructorParams } from "./types.js";
/**
 * The client for interacting with the Renegade relayer with a keychain.
 */
export declare class RenegadeClient {
    readonly config: RenegadeConfig;
    readonly configv2: SDKConfig;
    readonly seed?: `0x${string}`;
    readonly walletSecrets?: GeneratedSecrets;
    /**
     * @internal
     */
    protected constructor(params: ConstructorParams & {
        logger?: Logger;
    });
    /**
     * Create a client for any chain by seed.
     *
     * @param params.chainId    the chain ID (e.g. CHAIN_IDS.ArbitrumMainnet)
     * @param params.seed       your 0x… seed
     * @param params.overrides  any SDKConfig field can be passed directly as an override
     */
    static new({ chainId, seed, overrides, logger, }: {
        chainId: number;
        seed: `0x${string}`;
        overrides?: Partial<SDKConfig>;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Create a client for any chain with an external keychain.
     *
     * @param params.chainId        the chain ID
     * @param params.walletSecrets  symmetric key + wallet ID
     * @param params.signMessage    callback to sign auth messages
     * @param params.publicKey      your public key
     */
    static newWithExternalKeychain({ chainId, walletSecrets, signMessage, publicKey, logger, }: {
        chainId: number;
        walletSecrets: GeneratedSecrets;
        signMessage: (message: string) => Promise<`0x${string}`>;
        publicKey: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Arbitrum One client via seed.
     *
     * @param params.seed your 0x… seed
     */
    static newArbitrumOneClient({ seed, logger }: {
        seed: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Arbitrum Mainnet client with external keychain.
     *
     * @param params.walletSecrets  symmetric key + wallet ID
     * @param params.signMessage    callback to sign auth messages
     * @param params.publicKey      your public key
     */
    static newArbitrumOneClientWithKeychain({ walletSecrets, signMessage, publicKey, logger, }: {
        walletSecrets: GeneratedSecrets;
        signMessage: (message: string) => Promise<`0x${string}`>;
        publicKey: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Arbitrum Sepolia client via seed.
     *
     * @param params.seed your 0x… seed
     */
    static newArbitrumSepoliaClient({ seed, logger }: {
        seed: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Arbitrum Sepolia client with external keychain.
     *
     * @param params.walletSecrets  symmetric key + wallet ID
     * @param params.signMessage    callback to sign auth messages
     * @param params.publicKey      your public key
     */
    static newArbitrumSepoliaClientWithKeychain({ walletSecrets, signMessage, publicKey, logger, }: {
        walletSecrets: GeneratedSecrets;
        signMessage: (message: string) => Promise<`0x${string}`>;
        publicKey: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Base Sepolia client via seed.
     *
     * @param params.seed your 0x… seed
     */
    static newBaseMainnetClient({ seed, logger }: {
        seed: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Base Sepolia client with external keychain.
     *
     * @param params.walletSecrets  symmetric key + wallet ID
     * @param params.signMessage    callback to sign auth messages
     * @param params.publicKey      your public key
     */
    static newBaseMainnetClientWithKeychain({ walletSecrets, signMessage, publicKey, logger, }: {
        walletSecrets: GeneratedSecrets;
        signMessage: (message: string) => Promise<`0x${string}`>;
        publicKey: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Base Sepolia client via seed.
     *
     * @param params.seed your 0x… seed
     */
    static newBaseSepoliaClient({ seed, logger }: {
        seed: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    /**
     * Base Sepolia client with external keychain.
     *
     * @param params.walletSecrets  symmetric key + wallet ID
     * @param params.signMessage    callback to sign auth messages
     * @param params.publicKey      your public key
     */
    static newBaseSepoliaClientWithKeychain({ walletSecrets, signMessage, publicKey, logger, }: {
        walletSecrets: GeneratedSecrets;
        signMessage: (message: string) => Promise<`0x${string}`>;
        publicKey: `0x${string}`;
        logger?: Logger;
    }): RenegadeClient;
    getWallet(params?: GetWalletFromRelayerParameters): Promise<import("@renegade-fi/core").Wallet>;
    getBackOfQueueWallet(params?: GetBackOfQueueWalletParameters): Promise<import("@renegade-fi/core").Wallet>;
    lookupWallet(): Promise<void>;
    refreshWallet(): Promise<import("@renegade-fi/core/actions").RefreshWalletReturnType>;
    createWallet(): Promise<void>;
    getWalletId(): string;
    getWalletNullifier(): Promise<bigint>;
    getOrderHistory(parameters?: GetOrderHistoryParameters): Promise<import("@renegade-fi/core").GetOrderHistoryReturnType>;
    deposit(parameters: DepositParameters): Promise<{
        taskId: string;
    }>;
    executeDeposit(parameters: Omit<ExecuteDepositParameters, "permit2Address"> & {
        publicClient: PublicClient;
    }): Promise<{
        taskId: string;
    }>;
    withdraw(parameters: WithdrawParameters): Promise<{
        taskId: string;
    }>;
    executeWithdraw(parameters: ExecuteWithdrawalParameters): Promise<{
        taskId: string;
    }>;
    payFees(): Promise<import("@renegade-fi/core").PayFeesReturnType>;
    placeOrder(parameters: CreateOrderParameters): Promise<import("@renegade-fi/core").CreateOrderReturnType>;
    updateOrder(parameters: UpdateOrderParameters): Promise<{
        taskId: string;
    }>;
    cancelOrder(parameters: CancelOrderParameters): Promise<import("@renegade-fi/core").CancelOrderReturnType>;
    createOrderWebSocket(onUpdate: (order: OrderMetadata) => void): Promise<{
        config: RenegadeConfig;
        ws: import("@renegade-fi/core").RelayerWebsocket | null;
        callback: (order: OrderMetadata) => void;
        walletId: string;
        connect(): void;
        disconnect(): void;
        handleMessage(event: MessageEvent): void;
        handleClose(): void;
        handleError(): void;
    }>;
    getTaskQueue(): Promise<import("@renegade-fi/core").OldTask[]>;
    getTaskQueuePaused(): Promise<boolean>;
    /**
     * Generate the message from which the seed can be derived.
     *
     * @param chainId - the chain ID
     * @returns the message to sign
     */
    static generateSeedMessage(chainId: number): string;
    /**
     * Generate an externally managed keychain for a Renegade wallet.
     *
     * @param sign - the callback to sign messages
     * @returns the keychain
     */
    static generateKeychain({ sign }: {
        sign: (message: string) => Promise<`0x${string}`>;
    }): Promise<GeneratedSecrets>;
    /**
     * @internal
     */
    getConfig(): RenegadeConfig;
}
//# sourceMappingURL=base.d.ts.map