@kodiak-finance/orderly-core 2.7.4

package/dist/index.d.mts

@@ -0,0 +1,1436 @@
+import EventEmitter from 'eventemitter3';
+export { default as EventEmitter } from 'eventemitter3';
+import { definedTypes, ChainNamespace, API, AccountStatusEnum, NetworkId } from '@kodiak-finance/orderly-types';
+import { BigNumberish } from 'ethers/src.ts/utils';
+import { parseUnits, TransactionResponse, ethers } from 'ethers';
+
+interface OrderlyKeyPair {
+    getPublicKey(): Promise<string>;
+    secretKey: string;
+    sign: (data: Uint8Array) => Promise<Uint8Array>;
+}
+declare class BaseOrderlyKeyPair implements OrderlyKeyPair {
+    secretKey: string;
+    private privateKey;
+    static generateKey(): OrderlyKeyPair;
+    constructor(secretKey: string);
+    sign(message: Uint8Array): Promise<Uint8Array>;
+    getPublicKey(): Promise<string>;
+    toString(): string;
+}
+
+interface OrderlyKeyStore {
+    getOrderlyKey: (address?: string) => OrderlyKeyPair | null;
+    getAccountId: (address: string) => string | undefined | null;
+    setAccountId: (address: string, accountId: string) => void;
+    getAddress: () => string | undefined | null;
+    setAddress: (address: string) => void;
+    removeAddress: () => void;
+    generateKey: () => OrderlyKeyPair;
+    cleanKey: (address: string, key: string) => void;
+    cleanAllKey: (address: string) => void;
+    setKey: (orderlyKey: string, secretKey: OrderlyKeyPair) => void;
+}
+declare abstract class BaseKeyStore implements OrderlyKeyStore {
+    private readonly networkId;
+    constructor(networkId?: string);
+    abstract getOrderlyKey(address?: string): OrderlyKeyPair | null;
+    abstract getAccountId(address: string): string | undefined | null;
+    abstract setAccountId(address: string, accountId: string): void;
+    abstract getAddress(): string | undefined | null;
+    abstract setAddress(address: string): void;
+    abstract removeAddress(): void;
+    abstract generateKey(): OrderlyKeyPair;
+    abstract setKey(orderlyKey: string, secretKey: OrderlyKeyPair): void;
+    abstract cleanAllKey(address: string): void;
+    abstract cleanKey(address: string, key: string): void;
+    protected get keyPrefix(): string;
+}
+declare class LocalStorageStore extends BaseKeyStore {
+    getOrderlyKey(address?: string): OrderlyKeyPair | null;
+    getAccountId(address: string): string | undefined | null;
+    setAccountId(address: string, accountId: string): void;
+    getAddress(): string | undefined | null;
+    setAddress(address: string): void;
+    removeAddress(): void;
+    generateKey(): OrderlyKeyPair;
+    setKey(address: string, orderlyKey: OrderlyKeyPair): void;
+    cleanAllKey(address: string): void;
+    cleanKey(address: string, key: string): void;
+    private setItem;
+    private getItem;
+}
+declare class MockKeyStore implements OrderlyKeyStore {
+    private readonly secretKey;
+    constructor(secretKey: string);
+    generateKey(): BaseOrderlyKeyPair;
+    getOrderlyKey(): BaseOrderlyKeyPair;
+    getAccountId(): string;
+    setAccountId(accountId: string): void;
+    getAddress(): string;
+    setAddress(address: string): void;
+    removeAddress(): void;
+    setKey(orderlyKey: string, secretKey: OrderlyKeyPair): void;
+    cleanAllKey(): void;
+    cleanKey(key: string): void;
+}
+
+type MessageFactor = {
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    data?: any;
+};
+type SignedMessagePayload = {
+    "orderly-key": string;
+    "orderly-timestamp": string;
+    "orderly-signature": string;
+    "orderly-account-id"?: string;
+};
+/**
+ * Singer interface
+ * @example
+ * ```ts
+ * const signer = new BaseSigner(keyStore);
+ * const payload = await signer.sign({
+ *  url: "https://api.orderly.io/get_account?address=0x1234567890&brokerId=orderly",
+ *   method: "GET",
+ *   data: {
+ *     address: "0x1234567890",
+ *     brokerId: "orderly",
+ *    },
+ *  });
+ *  ```
+ */
+interface Signer {
+    sign: (data: MessageFactor, timestamp?: number) => Promise<SignedMessagePayload>;
+    signText: (text: string) => Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+}
+declare class BaseSigner implements Signer {
+    private readonly keyStore;
+    constructor(keyStore: OrderlyKeyStore);
+    sign(message: MessageFactor, timestamp?: number): Promise<SignedMessagePayload>;
+    signText(text: string): Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+}
+
+type SignatureDomain = {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};
+declare const base64url: (aStr: string) => string;
+declare function parseBrokerHash(brokerId: string): string;
+declare function parseAccountId(userAddress: string, brokerId: string): string;
+declare function parseTokenHash(tokenSymbol: string): string;
+declare function calculateStringHash(input: string): string;
+declare function formatByUnits(amount: BigNumberish, unit?: number | "ether" | "gwei"): string;
+declare function isHex(value: string): boolean;
+declare function isHexString(value: string): boolean;
+declare const getGlobalObject: () => typeof globalThis;
+declare const getTimestamp: () => number;
+
+type utils_SignatureDomain = SignatureDomain;
+declare const utils_base64url: typeof base64url;
+declare const utils_calculateStringHash: typeof calculateStringHash;
+declare const utils_formatByUnits: typeof formatByUnits;
+declare const utils_getGlobalObject: typeof getGlobalObject;
+declare const utils_getTimestamp: typeof getTimestamp;
+declare const utils_isHex: typeof isHex;
+declare const utils_isHexString: typeof isHexString;
+declare const utils_parseAccountId: typeof parseAccountId;
+declare const utils_parseBrokerHash: typeof parseBrokerHash;
+declare const utils_parseTokenHash: typeof parseTokenHash;
+declare const utils_parseUnits: typeof parseUnits;
+declare namespace utils {
+  export { type utils_SignatureDomain as SignatureDomain, utils_base64url as base64url, utils_calculateStringHash as calculateStringHash, utils_formatByUnits as formatByUnits, utils_getGlobalObject as getGlobalObject, utils_getTimestamp as getTimestamp, utils_isHex as isHex, utils_isHexString as isHexString, utils_parseAccountId as parseAccountId, utils_parseBrokerHash as parseBrokerHash, utils_parseTokenHash as parseTokenHash, utils_parseUnits as parseUnits };
+}
+
+declare const getMockSigner: (secretKey?: string) => BaseSigner;
+declare const getDefaultSigner: () => BaseSigner;
+/**
+ * generate `registerAccount` data and to be signed message structure
+ */
+declare function generateRegisterAccountMessage(inputs: {
+    chainId: number;
+    registrationNonce: number;
+    brokerId: string;
+    timestamp?: number;
+}): readonly [{
+    brokerId: string;
+    chainId: number;
+    timestamp: number;
+    registrationNonce: number;
+}, {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    message: {
+        brokerId: string;
+        chainId: number;
+        timestamp: number;
+        registrationNonce: number;
+    };
+    primaryType: string;
+    types: {
+        EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }];
+        Registration: readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }, {
+            readonly name: "registrationNonce";
+            readonly type: "uint256";
+        }];
+    };
+}];
+/**
+ * generate `addOrderlyKey` data and to be signed message structure
+ */
+declare function generateAddOrderlyKeyMessage(inputs: {
+    publicKey: string;
+    chainId: number;
+    brokerId: string;
+    primaryType: keyof typeof definedTypes;
+    expiration?: number;
+    timestamp?: number;
+    scope?: string;
+    tag?: string;
+    subAccountId?: string;
+}): readonly [{
+    subAccountId?: string | undefined;
+    tag?: string | undefined;
+    brokerId: string;
+    orderlyKey: string;
+    scope: string;
+    chainId: number;
+    timestamp: number;
+    expiration: number;
+}, {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    message: {
+        subAccountId?: string | undefined;
+        tag?: string | undefined;
+        brokerId: string;
+        orderlyKey: string;
+        scope: string;
+        chainId: number;
+        timestamp: number;
+        expiration: number;
+    };
+    primaryType: "EIP712Domain" | "Registration" | "Withdraw" | "AddOrderlyKey" | "SettlePnl" | "DexRequest" | "InternalTransfer";
+    types: {
+        [x: string]: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }] | readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }, {
+            readonly name: "registrationNonce";
+            readonly type: "uint256";
+        }] | readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "withdrawNonce";
+            readonly type: "uint64";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }] | readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "orderlyKey";
+            readonly type: "string";
+        }, {
+            readonly name: "scope";
+            readonly type: "string";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expiration";
+            readonly type: "uint64";
+        }] | readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "settleNonce";
+            readonly type: "uint64";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }] | readonly [{
+            readonly name: "payloadType";
+            readonly type: "uint8";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "vaultId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }, {
+            readonly name: "dexBrokerId";
+            readonly type: "string";
+        }] | readonly [{
+            readonly name: "receiver";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "transferNonce";
+            readonly type: "uint64";
+        }];
+        EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }];
+    };
+}];
+/**
+ * generate `settle` data and to be signed message structure
+ */
+declare function generateSettleMessage(inputs: {
+    chainId: number;
+    brokerId: string;
+    settlePnlNonce: string;
+    domain: SignatureDomain;
+}): readonly [{
+    brokerId: string;
+    chainId: number;
+    timestamp: number;
+    settleNonce: string;
+}, {
+    domain: SignatureDomain;
+    message: {
+        brokerId: string;
+        chainId: number;
+        timestamp: number;
+        settleNonce: string;
+    };
+    primaryType: string;
+    types: {
+        EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }];
+        SettlePnl: readonly [{
+            readonly name: "brokerId";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "settleNonce";
+            readonly type: "uint64";
+        }, {
+            readonly name: "timestamp";
+            readonly type: "uint64";
+        }];
+    };
+}];
+/**
+ * generate `dexRequest` data and to be signed message structure
+ */
+declare function generateDexRequestMessage(inputs: {
+    chainId: number;
+    payloadType: number;
+    nonce: string;
+    receiver: string;
+    amount: string;
+    vaultId: string;
+    token: string;
+    dexBrokerId: string;
+    domain: SignatureDomain;
+    timestamp?: number;
+}): readonly [{
+    payloadType: number;
+    nonce: string;
+    receiver: string;
+    amount: string;
+    vaultId: string;
+    token: string;
+    dexBrokerId: string;
+}, {
+    domain: SignatureDomain;
+    message: {
+        payloadType: number;
+        nonce: string;
+        receiver: string;
+        amount: string;
+        vaultId: string;
+        token: string;
+        dexBrokerId: string;
+    };
+    primaryType: string;
+    types: {
+        EIP712Domain: readonly [{
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "version";
+            readonly type: "string";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        }];
+        DexRequest: readonly [{
+            readonly name: "payloadType";
+            readonly type: "uint8";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "vaultId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }, {
+            readonly name: "dexBrokerId";
+            readonly type: "string";
+        }];
+    };
+}];
+
+type ConfigKey = "apiBaseUrl" | "klineDataUrl" | "privateWsUrl" | "publicWsUrl" | "operatorUrl" | "domain" | "brokerId" | "brokerName" | "networkId" | "env" | "chainNamespace" | "PROD_URL" | "orderly_markets" | "markets";
+interface ConfigStore {
+    get<T = string>(key: ConfigKey): T;
+    getOr<T = string>(key: ConfigKey, defaultValue: T): T;
+    set<T>(key: ConfigKey, value: T): void;
+    clear(): void;
+}
+
+/**
+ * Orderly contracts information
+ */
+type OrderlyContracts = {
+    usdcAddress: string;
+    usdcAbi: any;
+    erc20Abi: any;
+    vaultAddress: string;
+    vaultAbi: any;
+    verifyContractAddress: string;
+    solanaUSDCAddress: string;
+    solanaVaultAddress: string;
+    storyTestnetVaultAddress?: string;
+    monadTestnetVaultAddress?: string;
+    monadTestnetUSDCAddress?: string;
+    abstractVaultAddress?: string;
+    abstractUSDCAddress?: string;
+    bscVaultAddress?: string;
+    bscUSDCAddress?: string;
+};
+interface IContract {
+    getContractInfoByEnv(): OrderlyContracts;
+}
+/** @hidden */
+declare class BaseContract implements IContract {
+    private readonly configStore;
+    constructor(configStore: ConfigStore);
+    getContractInfoByEnv(): {
+        usdcAddress: string;
+        usdcAbi: ({
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            outputs?: undefined;
+            stateMutability?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        vaultAddress: string;
+        vaultAbi: ({
+            inputs: never[];
+            stateMutability: string;
+            type: string;
+            name?: undefined;
+            anonymous?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            anonymous?: undefined;
+            outputs?: undefined;
+        } | {
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: ({
+                internalType: string;
+                name: string;
+                type: string;
+                components?: undefined;
+            } | {
+                components: {
+                    internalType: string;
+                    name: string;
+                    type: string;
+                }[];
+                internalType: string;
+                name: string;
+                type: string;
+            })[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        verifyContractAddress: string;
+        erc20Abi: ({
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            outputs?: undefined;
+            stateMutability?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        solanaUSDCAddress: string;
+        solanaVaultAddress: string;
+        abstractVaultAddress: string;
+        abstractUSDCAddress: string;
+        bscVaultAddress: string;
+        bscUSDCAddress: string;
+        storyTestnetVaultAddress?: undefined;
+        monadTestnetVaultAddress?: undefined;
+        monadTestnetUSDCAddress?: undefined;
+    } | {
+        usdcAddress: string;
+        usdcAbi: ({
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+            name?: undefined;
+            outputs?: undefined;
+        } | {
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        vaultAddress: string;
+        solanaVaultAddress: string;
+        solanaUSDCAddress: string;
+        vaultAbi: ({
+            inputs: never[];
+            stateMutability: string;
+            type: string;
+            name?: undefined;
+            anonymous?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            anonymous?: undefined;
+            outputs?: undefined;
+        } | {
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: ({
+                internalType: string;
+                name: string;
+                type: string;
+                components?: undefined;
+            } | {
+                components: {
+                    internalType: string;
+                    name: string;
+                    type: string;
+                }[];
+                internalType: string;
+                name: string;
+                type: string;
+            })[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        verifyContractAddress: string;
+        erc20Abi: ({
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+            name?: undefined;
+            outputs?: undefined;
+        } | {
+            anonymous: boolean;
+            inputs: {
+                indexed: boolean;
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+            stateMutability?: undefined;
+            outputs?: undefined;
+        } | {
+            inputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            outputs: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            stateMutability: string;
+            type: string;
+            anonymous?: undefined;
+        })[];
+        storyTestnetVaultAddress: string;
+        monadTestnetVaultAddress: string;
+        monadTestnetUSDCAddress: string;
+        abstractUSDCAddress: string;
+        abstractVaultAddress: string;
+        bscVaultAddress: string;
+        bscUSDCAddress: string;
+    };
+}
+
+declare const EVENT_NAMES: {
+    statusChanged: string;
+    validateStart: string;
+    validateEnd: string;
+    switchAccount: string;
+    subAccountCreated: string;
+    subAccountUpdated: string;
+};
+
+declare class SimpleDI {
+    private static KEY;
+    private static container;
+    private static getContainer;
+    static register(...serviceClasses: any[]): void;
+    static registerByName(name: string, serviceClass: any): void;
+    static get<T = any>(name: string): T;
+    static getOr<T = any>(name: string, instance: T): T;
+    static getAll(): {
+        [name: string]: any;
+    };
+    private constructor();
+}
+
+type ChainType = "EVM" | "SOL";
+interface Message {
+    message: {
+        chainType: ChainType;
+        [key: string]: any;
+    };
+    signatured: string;
+}
+type RegisterAccountInputs = {
+    brokerId: string;
+    registrationNonce: number;
+    timestamp: number;
+};
+type WithdrawInputs = {
+    brokerId: string;
+    receiver: string;
+    token: string;
+    amount: string;
+    nonce: number;
+    timestamp: number;
+    verifyContract?: string;
+};
+type InternalTransferInputs = {
+    receiver: string;
+    token: string;
+    amount: string;
+    nonce: number;
+    verifyContract?: string;
+};
+type SettleInputs = {
+    brokerId: string;
+    settlePnlNonce: string;
+    timestamp: number;
+    verifyContract?: string;
+};
+type AddOrderlyKeyInputs = {
+    publicKey: string;
+    brokerId: string;
+    expiration: number;
+    timestamp: number;
+    scope?: string;
+    tag?: string;
+    /** @since 2.3.0, when create orderly key for sub account, it's required */
+    subAccountId?: string;
+};
+type DexRequestInputs = {
+    payloadType: number;
+    nonce: string;
+    receiver: string;
+    amount: string;
+    vaultId: string;
+    token: string;
+    dexBrokerId: string;
+    timestamp: number;
+    domain: SignatureDomain;
+};
+interface WalletAdapter<Config = any> {
+    chainNamespace: ChainNamespace;
+    get chainId(): number;
+    get address(): string;
+    set chainId(chainId: number);
+    set address(addresses: string);
+    active(config: Config): void;
+    update(config: Config): void;
+    deactivate(): void;
+    generateSecretKey(): string;
+    /**
+     * business methods
+     */
+    generateRegisterAccountMessage(inputs: RegisterAccountInputs): Promise<Message>;
+    generateWithdrawMessage(inputs: WithdrawInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    generateInternalTransferMessage(inputs: InternalTransferInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    generateSettleMessage(inputs: SettleInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    generateAddOrderlyKeyMessage(inputs: AddOrderlyKeyInputs): Promise<Message>;
+    generateDexRequestMessage(inputs: DexRequestInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    /**
+     * ===== general methods =====
+     */
+    /**
+     * call contract
+     */
+    call(address: string, method: string, params: any[], options?: {
+        abi: any;
+    }): Promise<any>;
+    /**
+     * send transaction
+     */
+    sendTransaction(contractAddress: string, method: string, payload: {
+        from: string;
+        to?: string;
+        data: any[];
+        value?: bigint;
+    }, options: {
+        abi: any;
+    }): Promise<any>;
+    callOnChain(chain: API.NetworkInfos, address: string, method: string, params: any[], options: {
+        abi: any;
+    }): Promise<any>;
+    getBalance(): Promise<bigint>;
+    pollTransactionReceiptWithBackoff(txHash: string, baseInterval?: number, maxInterval?: number, maxRetries?: number): Promise<any>;
+    parseUnits: (amount: string, decimals: number) => string;
+    formatUnits: (amount: BigNumberish, decimals: number) => string;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+}
+
+declare class Assets {
+    private readonly configStore;
+    private readonly contractManger;
+    private readonly account;
+    constructor(configStore: ConfigStore, contractManger: IContract, account: Account);
+    /**
+     * Convert non-USDC asset to USDC manually
+     */
+    convert(inputs: {
+        slippage: number;
+        amount: number;
+        converted_asset: string;
+    }): Promise<any>;
+    withdraw(inputs: {
+        chainId: number;
+        token: string;
+        amount: string | number;
+        allowCrossChainWithdraw: boolean;
+        /** orderly withdraw decimals */
+        decimals: number;
+    }): Promise<any>;
+    private getWithdrawalNonce;
+    getNativeBalance(options?: {
+        /** token decimals on chain, default is 18 */
+        decimals?: number;
+    }): Promise<string>;
+    getBalance(
+    /** token address */
+    address: string, options: {
+        /** token decimals on chain, default is 18 */
+        decimals?: number;
+    }): Promise<string>;
+    /**
+     * @deprecated use getBalance instead, will be removed in the future
+     */
+    getBalanceByAddress(
+    /** token address */
+    address: string, options?: {
+        /** token decimals on chain, default is 18 */
+        decimals?: number;
+    }): Promise<string>;
+    getAllowance(inputs: {
+        /** token address */
+        address: string;
+        /** vault address */
+        vaultAddress?: string;
+        /** token decimals on chain, default is 18 */
+        decimals?: number;
+    }): Promise<string>;
+    approve(inputs: {
+        /** token address */
+        address?: string;
+        /** vault address */
+        vaultAddress?: string;
+        /** token amount */
+        amount?: string;
+        isSetMaxValue?: boolean;
+        /** token decimals on chain, default is 18 */
+        decimals: number;
+    }): Promise<any>;
+    /**
+     * @deprecated use approve instead, will be removed in the future
+     */
+    approveByAddress(inputs: {
+        /** token address */
+        address: string;
+        /** token amount */
+        amount?: string;
+        /** token decimals on chain, default is 18 */
+        decimals: number;
+    }): Promise<any>;
+    getDepositFee(inputs: {
+        amount: string;
+        /** chain info */
+        chain: API.NetworkInfos;
+        /** token decimals on chain, default is 18 */
+        decimals: number;
+        token?: string;
+        /** token address */
+        address?: string;
+    }): Promise<any>;
+    /** deposit native token */
+    depositNativeToken(inputs: {
+        amount: string;
+        fee: bigint;
+        /** token decimals on chain, default is 18 */
+        decimals: number;
+        token?: string;
+    }): Promise<any>;
+    deposit(inputs: {
+        amount: string;
+        fee: bigint;
+        /** token decimals on chain, default is 18 */
+        decimals: number;
+        token?: string;
+        /** token address */
+        address?: string;
+        /** vault address */
+        vaultAddress?: string;
+    }): Promise<any>;
+    internalTransfer(inputs: {
+        token: string;
+        amount: string;
+        receiver: string;
+        /** orderly token decimals */
+        decimals: number;
+    }): Promise<any>;
+    private getTransferNonce;
+    private _simpleFetch;
+    get usdcAddress(): string;
+}
+
+type SubAccount = {
+    id: string;
+    description: string;
+    holding: API.Holding[];
+};
+
+interface AccountState {
+    status: AccountStatusEnum;
+    /**
+     * whether the account is validating
+     */
+    validating: boolean;
+    /**
+     * whether the account is revalidating
+     */
+    /**
+     * The current active account ID
+     * Can be either a root account ID or sub-account ID
+     * @since 2.3.0
+     */
+    accountId?: string;
+    /**
+     * root account id
+     * @since 2.3.0
+     */
+    mainAccountId?: string;
+    /**
+     * sub account id
+     * @since 2.3.0
+     */
+    subAccountId?: string | undefined;
+    userId?: string;
+    address?: string;
+    chainNamespace?: ChainNamespace;
+    /** new account */
+    isNew?: boolean;
+    connectWallet?: {
+        name: string;
+        chainId: number;
+    };
+    /**
+     * sub accounts
+     * @since 2.3.0
+     */
+    subAccounts?: SubAccount[];
+}
+/**
+ * Account
+ * @example
+ * ```ts
+ * const account = new Account();
+ * account.login("0x1234567890");
+ * ```
+ */
+declare class Account {
+    private readonly configStore;
+    readonly keyStore: OrderlyKeyStore;
+    static instanceName: string;
+    static additionalInfoRepositoryName: string;
+    static ACTIVE_SUB_ACCOUNT_ID_KEY: string;
+    private _singer?;
+    private _ee;
+    private walletAdapterManager;
+    assetsManager: Assets;
+    private additionalInfoRepository;
+    private _state;
+    private readonly contractManger;
+    constructor(configStore: ConfigStore, keyStore: OrderlyKeyStore, walletAdapters: WalletAdapter[], options?: Partial<{
+        /**
+         * smart contract configuration class
+         * provide contract address and abi
+         */
+        contracts: IContract;
+    }>);
+    logout(): void;
+    setAddress(address: string, wallet: {
+        provider: any;
+        chain: {
+            id: string | number;
+            namespace: ChainNamespace;
+        };
+        wallet: {
+            name: string;
+        };
+        [key: string]: any;
+    }, options?: {
+        /**
+         * @deprecated will be remove this in next minor version
+         */
+        validateOrderlyKeyScope?: (scope: string) => boolean;
+    }): Promise<AccountStatusEnum>;
+    private saveAdditionalInfo;
+    get stateValue(): AccountState;
+    get accountId(): string | undefined;
+    get mainAccountId(): string | undefined;
+    get subAccountId(): string | undefined;
+    get isSubAccount(): boolean;
+    get accountIdHashStr(): string | undefined;
+    get address(): string | undefined;
+    get chainId(): number | string | undefined;
+    get apiBaseUrl(): string | undefined;
+    private updateState;
+    private _bindEvents;
+    private _checkAccount;
+    private _checkAccountExist;
+    private _restoreSubAccount;
+    restoreSubAccount(): Promise<AccountState>;
+    createAccount(): Promise<any>;
+    createSubAccount(description?: string): Promise<any>;
+    updateSubAccount({ subAccountId, description, }: {
+        subAccountId: string;
+        description?: string;
+    }): Promise<any>;
+    switchAccount(accountId: string): void;
+    getSubAccounts(): Promise<({
+        sub_account_id: string;
+        description: string;
+    } & {
+        holding: API.Holding[];
+    })[]>;
+    getSubAccountBalances(): Promise<Record<string, API.Holding[]>>;
+    /**
+     * refresh sub account balances
+     * @since 2.3.0
+     */
+    refreshSubAccountBalances(): Promise<Record<string, API.Holding[]>>;
+    /**
+     * @since 2.3.0
+     * if you are using main account orderly key, you can create api key for sub account
+     */
+    createSubAccountApiKey(
+    /**
+     * expiration days
+     */
+    expiration: number, options: {
+        tag?: string;
+        scope?: string;
+        subAccountId: string;
+    }): Promise<{
+        key: string;
+        secretKey: string;
+    }>;
+    createApiKey(
+    /**
+     * expiration days
+     */
+    expiration: number, options?: {
+        tag?: string;
+        scope?: string;
+    }): Promise<{
+        key: string;
+        secretKey: string;
+    }>;
+    createOrderlyKey(expiration?: number, options?: {
+        tag?: string;
+        scope?: string;
+    }): Promise<any>;
+    private generateApiKey;
+    importOrderlyKey(options: {
+        secretKey: string;
+        address: string;
+        chainNamespace: ChainNamespace;
+    }): Promise<true | undefined>;
+    checkOrderlyKey(address: string, orderlyKey: OrderlyKeyPair, accountId: string): Promise<true | undefined>;
+    /**
+     * @since 2.3.0
+     * settle sub account pnl
+     */
+    settleSubAccount(options?: {
+        /**
+         * if you are main account and want to settle the sub account, you need to pass the subAccountId
+         * if you are sub account, not need to pass the subAccountId
+         * */
+        subAccountId?: string;
+    }): Promise<any>;
+    /** set main account pnl */
+    settle(options?: {
+        /**
+         * if you are main account, you don't need to pass the accountId
+         * if you are sub account and you want to settle the main account, you need to pass main account id
+         * */
+        accountId?: string;
+    }): Promise<any>;
+    private signData;
+    destroyOrderlyKey(): Promise<void>;
+    disconnect(): Promise<void>;
+    switchChainId(chainId: number | string): void;
+    private parseChainId;
+    private _checkOrderlyKeyState;
+    get signer(): Signer;
+    get walletAdapter(): WalletAdapter<any> | undefined;
+    private _getRegisterationNonce;
+    private _getTimestampFromServer;
+    private _getAccountInfo;
+    private _getSettleNonce;
+    private _simpleFetch;
+    private _getVaultOperationNonce;
+    getAdditionalInfo(): Record<string, any> | null;
+    get on(): <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    get once(): <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    get off(): <T extends string | symbol>(event: T, fn?: ((...args: any[]) => void) | undefined, context?: any, once?: boolean) => EventEmitter<string | symbol, any>;
+    /**
+     * Generate DexRequest message for DEX operations
+     * @param inputs DexRequest parameters
+     * @returns Signed message and domain
+     */
+    generateDexRequest(inputs: {
+        payloadType: number;
+        amount: string;
+        vaultId: string;
+        token: string;
+        domain: SignatureDomain;
+    }): Promise<{
+        message: {
+            [key: string]: any;
+            chainType: ChainType;
+        };
+        signatured: string;
+        domain: SignatureDomain;
+    }>;
+    /**
+     * Signs a GET MessageFactor payload with the current timestamp.
+     * @param url The URL for the GET request
+     * @returns The signature
+     */
+    private signGetMessageFactor;
+}
+
+type ChainNamespaceType = (typeof ChainNamespace)[keyof typeof ChainNamespace];
+type URLS = {
+    apiBaseUrl: string;
+    publicWsUrl: string;
+    privateWsUrl: string;
+    operatorUrl: Record<ChainNamespaceType, string>;
+};
+declare const API_URLS: Record<NetworkId, URLS>;
+declare class DefaultConfigStore implements ConfigStore {
+    protected map: Map<ConfigKey, any>;
+    constructor(init: Partial<Record<ConfigKey, any>>);
+    get<T>(key: ConfigKey): T;
+    getOr<T>(key: ConfigKey, defaultValue: T): T;
+    set<T>(key: ConfigKey, value: T): void;
+    clear(): void;
+}
+
+declare abstract class BaseWalletAdapter<Config> implements WalletAdapter<Config> {
+    abstract generateRegisterAccountMessage(inputs: RegisterAccountInputs): Promise<Message>;
+    abstract generateWithdrawMessage(inputs: WithdrawInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    abstract generateInternalTransferMessage(inputs: InternalTransferInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    abstract generateSettleMessage(inputs: SettleInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    abstract generateAddOrderlyKeyMessage(inputs: AddOrderlyKeyInputs): Promise<Message>;
+    abstract generateDexRequestMessage(inputs: DexRequestInputs): Promise<Message & {
+        domain: SignatureDomain;
+    }>;
+    abstract getBalance(): Promise<bigint>;
+    abstract chainNamespace: ChainNamespace;
+    signMessageByOrderlyKey(payload: any): Promise<SignedMessagePayload>;
+    abstract call(address: string, method: string, params: any[], options?: {
+        abi: any;
+    }): Promise<any>;
+    abstract sendTransaction(contractAddress: string, method: string, payload: {
+        from: string;
+        to?: string;
+        data: any[];
+        value?: bigint;
+    }, options: {
+        abi: any;
+    }): Promise<any>;
+    abstract callOnChain(chain: API.NetworkInfos, address: string, method: string, params: any[], options: {
+        abi: any;
+    }): Promise<any>;
+    get address(): string;
+    get chainId(): number;
+    active(config: Config): void;
+    abstract deactivate(): void;
+    update(config: Config): void;
+    generateSecretKey(): string;
+    parseUnits(amount: string, decimals: number): string;
+    formatUnits(amount: BigNumberish, decimals: number): string;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+    abstract pollTransactionReceiptWithBackoff(txHash: string, baseInterval?: number, maxInterval?: number, maxRetries?: number): Promise<any>;
+}
+
+interface Ed25519Keypair {
+    secretKey: string;
+    publicKey: string;
+}
+
+interface IWalletAdapter {
+    get chainId(): number;
+    get addresses(): string;
+    /**
+     * Set the chain id
+     */
+    set chainId(chainId: number);
+    parseUnits: (amount: string, decimals: number) => string;
+    formatUnits: (amount: string, decimals: number) => string;
+    send: (method: string, params: Array<any> | Record<string, any>) => Promise<any>;
+    sendTransaction(contractAddress: string, method: string, payload: {
+        from: string;
+        to?: string;
+        data: any[];
+        value?: bigint;
+    }, options: {
+        abi: any;
+    }): Promise<TransactionResponse>;
+    getTransactionRecipect: (txHash: string) => Promise<any>;
+    signTypedData: (address: string, data: any) => Promise<string>;
+    pollTransactionReceiptWithBackoff: (txHash: string, baseInterval?: number, maxInterval?: number, maxRetries?: number) => Promise<any>;
+    getBalance: (userAddress: string) => Promise<any>;
+    call(address: string, method: string, params: any, options: {
+        abi: any;
+    }): Promise<any>;
+    callOnChain(chain: API.NetworkInfos, address: string, method: string, params: any, options: {
+        abi: any;
+    }): Promise<any>;
+    on(eventName: any, listener: any): void;
+    off(eventName: any, listener: any): void;
+}
+type WalletAdapterOptions = {
+    provider: any;
+    address: string;
+    chain: {
+        id: number;
+    };
+};
+type getWalletAdapterFunc = (options: WalletAdapterOptions) => IWalletAdapter;
+
+declare class EtherAdapter implements IWalletAdapter {
+    private provider?;
+    private _chainId;
+    private _address;
+    constructor(options: WalletAdapterOptions);
+    parseUnits(amount: string, decimals: number): string;
+    formatUnits(amount: string, decimals: number): string;
+    getBalance(userAddress: string): Promise<any>;
+    deposit(from: string, to: string, amount: string): Promise<any>;
+    call(address: string, method: string, params: any[], options: {
+        abi: any;
+    }): Promise<any>;
+    callOnChain(chain: API.NetworkInfos, address: string, method: string, params: any[], options: {
+        abi: any;
+    }): Promise<any>;
+    get chainId(): number;
+    set chainId(chainId: number);
+    get addresses(): string;
+    send(method: string, params: Array<any> | Record<string, any>): Promise<any>;
+    sendTransaction(contractAddress: string, method: string, payload: {
+        from: string;
+        to?: string;
+        data: any[];
+        value?: bigint;
+    }, options: {
+        abi: any;
+    }): Promise<ethers.TransactionResponse>;
+    getTransactionRecipect(txHash: string): Promise<void>;
+    pollTransactionReceiptWithBackoff(txHash: string, baseInterval?: number, maxInterval?: number, maxRetries?: number): Promise<ethers.TransactionReceipt>;
+    private estimateGas;
+    signTypedData(address: string, data: any): Promise<any>;
+    verify(data: {
+        domain: any;
+        message: any;
+        types: any;
+    }, signature: string): Promise<void>;
+    on(eventName: any, listener: any): void;
+    off(eventName: any, listener: any): void;
+    getContract(address: string, abi: any): ethers.Contract;
+}
+
+export { API_URLS, Account, type AccountState, type AddOrderlyKeyInputs, BaseContract as BaseContractManager, BaseKeyStore, BaseOrderlyKeyPair, BaseSigner, BaseWalletAdapter, type ChainType, type ConfigKey, type ConfigStore, DefaultConfigStore, type DexRequestInputs, EVENT_NAMES, type Ed25519Keypair, EtherAdapter, type IContract, type InternalTransferInputs, LocalStorageStore, type Message, type MessageFactor, MockKeyStore, type OrderlyKeyPair, type OrderlyKeyStore, type RegisterAccountInputs, type SettleInputs, type SignatureDomain, type SignedMessagePayload, type Signer, SimpleDI, type SubAccount, type URLS, type WalletAdapter, type WalletAdapterOptions, type WithdrawInputs, generateAddOrderlyKeyMessage, generateDexRequestMessage, generateRegisterAccountMessage, generateSettleMessage, getDefaultSigner, getMockSigner, type getWalletAdapterFunc, utils };