@funkit/core 2.3.6 → 2.3.8

package/dist/src/actions/AccessControl.d.ts

@@ -4,7 +4,7 @@ import { type TransactionParams } from '../common';
 import type { EnvOption } from '../config';
 import { MerkleTree } from '../utils/MerkleUtils';
 import type { AddOwnerParams, RemoveOwnerParams, SessionKeyParams } from './types';
-export declare const createFeeRecipientAndTokenMerkleTree: (params: SessionKeyParams) => Promise<MerkleTree>;
+export declare const createFeeRecipientAndTokenMerkleTree: (params: SessionKeyParams, txOptions?: EnvOption) => Promise<MerkleTree>;
 export declare const createTargetSelectorMerkleTree: (params: SessionKeyParams) => MerkleTree;
 export declare const createSessionKeyTransactionParams: (params: SessionKeyParams, txOptions?: EnvOption) => Promise<TransactionParams>;
 export declare const createSessionUser: (auth: AuthInput, params: SessionKeyParams) => Promise<SessionKeyAuth>;

package/dist/src/actions/FirstClassActions.d.ts

@@ -21,7 +21,7 @@ export declare abstract class FirstClassActions {
      * If the address is not already cached, it fetches it using the wallet's unique ID and chain information.
      * @returns {Promise<Address>} The wallet address.
      */
-    abstract getAddress(): Promise<Address>;
+    abstract getAddress(options?: EnvOption): Promise<Address>;
     /**
      * Initiates a transfer operation and returns the prepared operation for execution.
      * @param {Auth} auth - The authentication instance for the user.

package/dist/src/actions/Token.d.ts

@@ -1,12 +1,13 @@
 import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
 import { Chain } from '../data/Chain';
 import type { ApproveERC20Params, ApproveERC721Params, ApproveParams, ERC721TransferParams, TokenTransferParams, TransferParams } from './types';
 export declare const isERC721TransferParams: (obj: TransferParams) => obj is ERC721TransferParams;
 export declare const isTokenTransferParams: (obj: TransferParams) => obj is TokenTransferParams;
-export declare const erc721TransferTransactionParams: (params: ERC721TransferParams) => Promise<TransactionParams>;
-export declare const tokenTransferTransactionParams: (params: TokenTransferParams, chain: Chain) => Promise<TransactionParams>;
-export declare const tokenTransferFromTransactionParams: (params: TokenTransferParams, chain: Chain) => Promise<TransactionParams>;
+export declare const erc721TransferTransactionParams: (params: ERC721TransferParams, options?: EnvOption) => Promise<TransactionParams>;
+export declare const tokenTransferTransactionParams: (params: TokenTransferParams, chain: Chain, options?: EnvOption) => Promise<TransactionParams>;
+export declare const tokenTransferFromTransactionParams: (params: TokenTransferParams, chain: Chain, options?: EnvOption) => Promise<TransactionParams>;
 export declare const isERC20ApproveParams: (obj: ApproveParams) => obj is ApproveERC20Params;
 export declare const isERC721ApproveParams: (obj: ApproveParams) => obj is ApproveERC721Params;
-export declare const erc20ApproveTransactionParams: (params: ApproveERC20Params) => Promise<TransactionParams>;
-export declare const erc721ApproveTransactionParams: (params: ApproveERC721Params) => Promise<TransactionParams>;
+export declare const erc20ApproveTransactionParams: (params: ApproveERC20Params, options?: EnvOption) => Promise<TransactionParams>;
+export declare const erc721ApproveTransactionParams: (params: ApproveERC721Params, options?: EnvOption) => Promise<TransactionParams>;

package/dist/src/auth/Auth.d.ts

@@ -26,7 +26,7 @@ export declare class Auth {
      * @param {boolean} isGroupOp - Whether the operation is a group operation (default: false).
      * @returns {Promise<Hex>} The signature of the operation.
      */
-    signOp(operation: Operation, chain: Chain, isGroupOp?: boolean): Promise<Hex>;
+    signOp(operation: Operation, chain: Chain, isGroupOp?: boolean, options?: EnvOption): Promise<Hex>;
     /**
      * Retrieves the address associated with the initialized signer or client.
      * @returns {Promise<Address>} The address associated with the signer or client.
@@ -51,7 +51,7 @@ export declare class Auth {
      * @param {boolean} skipDBActions - Whether to skip database actions (default: false).
      * @returns {Promise<Hex>} The generated unique ID for the wallet.
      */
-    getWalletUniqueId(index?: number, skipDBActions?: boolean): Promise<Hex>;
+    getWalletUniqueId(index?: number, skipDBActions?: boolean, options?: EnvOption): Promise<Hex>;
     /**
      * Sends a transaction with the provided transaction data and options.
      * @param {TransactionParams} txData - The transaction data including 'to', 'data', and 'value'.
@@ -71,11 +71,11 @@ export declare class Auth {
      * @param {string} chainId - The chain identifier.
      * @returns {Promise<Hex[]>} An array of user IDs associated with the wallet address.
      */
-    getUserIds(wallet: Address, chainId: string): Promise<Hex[]>;
+    getUserIds(wallet: Address, chainId: string, options?: EnvOption): Promise<Hex[]>;
     /**
      * Retrieves the wallets associated with the current auth object.
      * @param {string} [chainId] - Optional chain identifier.
      * @returns {Promise<Wallet[]>} An array of wallet objects associated with the address.
      */
-    getWallets(chainId?: string): Promise<Wallet[]>;
+    getWallets(chainId?: string, options?: EnvOption): Promise<Wallet[]>;
 }

package/dist/src/config/types.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from '@funkit/api-base';
 import type { Address } from 'viem';
 import type { Chain } from '../data';
 export interface EnvOption {
@@ -17,7 +18,9 @@ export interface EnvOption {
     skipDBAction?: boolean;
     nonce?: bigint;
     bypassInit?: boolean;
+    logger?: Logger;
+    signal?: AbortSignal;
 }
-export interface GlobalEnvOption extends EnvOption {
+export interface GlobalEnvOption extends Omit<EnvOption, 'signal'> {
     apiKey?: string;
 }

package/dist/src/data/Chain.d.ts

@@ -1,6 +1,7 @@
 import { type Address, type Hex, type PublicClient } from 'viem';
 import { type UserOperation, type UserOperationGasPrice } from '@funkit/api-base';
 import { type EstimateGasResult } from '../common';
+import type { EnvOption } from '../config';
 import type { ChainInput } from './types';
 export declare class Chain {
     private initialized;
@@ -12,18 +13,18 @@ export declare class Chain {
     private client?;
     private static chain;
     private constructor();
-    static getChain(chainInput: ChainInput): Promise<Chain>;
+    static getChain(chainInput: ChainInput, options?: EnvOption): Promise<Chain>;
     private init;
     private loadChainFromRpc;
     private loadChain;
-    getChainId(): Promise<string>;
-    getChainName(): Promise<string>;
-    getRpcUrl(): Promise<string>;
-    getAddress(name: string): Promise<Address>;
-    getCurrency(): Promise<string>;
-    getClient(): Promise<PublicClient>;
-    getFeeData(): Promise<UserOperationGasPrice>;
-    estimateOpGas(partialOp: UserOperation): Promise<EstimateGasResult>;
-    getTxId(userOpHash: string, timeout?: number, interval?: number, fromBlock?: bigint): Promise<Hex | null>;
-    addressIsContract(address: Address): Promise<boolean>;
+    getChainId(options?: EnvOption): Promise<string>;
+    getChainName(options?: EnvOption): Promise<string>;
+    getRpcUrl(options?: EnvOption): Promise<string>;
+    getAddress(name: string, options?: EnvOption): Promise<Address>;
+    getCurrency(options?: EnvOption): Promise<string>;
+    getClient(options?: EnvOption): Promise<PublicClient>;
+    getFeeData(options?: EnvOption): Promise<UserOperationGasPrice>;
+    estimateOpGas(partialOp: UserOperation, options?: EnvOption): Promise<EstimateGasResult>;
+    getTxId(userOpHash: string, timeout?: number, interval?: number, fromBlock?: bigint, options?: EnvOption): Promise<Hex | null>;
+    addressIsContract(address: Address, options?: EnvOption): Promise<boolean>;
 }

package/dist/src/data/NFT.d.ts

@@ -11,7 +11,7 @@ export declare class NFT {
     approveForAll(spender: string, options?: EnvOption): Promise<TransactionParams & {
         chain: Chain;
     }>;
-    getAddress(): Promise<Address>;
+    getAddress(options?: EnvOption): Promise<Address>;
     getName(options?: EnvOption): Promise<string>;
     getBalance(address: Address, options?: EnvOption): Promise<bigint>;
     getApproved(tokenId: string, options?: EnvOption): Promise<Address>;
@@ -21,7 +21,7 @@ export declare class NFT {
     }>;
     static approve(data: string, spender: string, tokenId: number, options?: EnvOption): Promise<TransactionData>;
     static approveForAll(data: string, spender: string, options?: EnvOption): Promise<TransactionData>;
-    static getAddress(data: string): Promise<Address>;
+    static getAddress(data: string, options?: EnvOption): Promise<Address>;
     static getApproved(data: string, tokenId: string, options?: EnvOption): Promise<string>;
     static revokeForAll(data: string, spender: string, options?: EnvOption): Promise<TransactionData>;
     static transfer(data: string, sender: string, spender: string, tokenId: number, options?: EnvOption): Promise<TransactionData>;

package/dist/src/data/Operation.d.ts

@@ -27,7 +27,7 @@ export declare class Operation implements OperationData {
     executedBlockTimeStamp?: number;
     constructor(userOp: UserOperation, metadata: OperationMetadata);
     static convertTypeToObject(op: OperationData): Operation;
-    getOpHash(chain: Chain): Promise<Hex>;
+    getOpHash(chain: Chain, options?: EnvOption): Promise<Hex>;
     getMaxTxCost(): bigint;
     estimateGas(auth: Auth, userId: string, options?: EnvOption): Promise<Operation>;
 }

package/dist/src/data/Token.d.ts

@@ -1,5 +1,6 @@
 import { type Address } from 'viem';
 import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
 import type { Chain } from './Chain';
 export declare class Token {
     address?: Address;
@@ -7,21 +8,21 @@ export declare class Token {
     isNative: boolean;
     symbol: string;
     constructor(input: Address | string, chain: Chain);
-    getAddress(): Promise<Address>;
-    getDecimals(): Promise<bigint>;
-    getBalance(address: Address): Promise<string>;
-    getBalanceBN(address: Address): Promise<bigint>;
-    getApproval(owner: string, spender: string): Promise<bigint>;
-    getDecimalAmount(amount: number | string): Promise<bigint>;
-    approve(spender: string, amount: number): Promise<TransactionParams>;
-    transfer(spender: string, amount: number): Promise<TransactionParams>;
-    static getAddress(data: string, chain: Chain): Promise<Address>;
-    static getDecimals(data: string, chain: Chain): Promise<bigint>;
-    static getBalance(data: string, address: Address, chain: Chain): Promise<string>;
-    static getBalanceBN(data: string, address: Address, chain: Chain): Promise<bigint>;
-    static getApproval(data: string, owner: string, spender: string, chain: Chain): Promise<bigint>;
-    static getDecimalAmount(data: string, amount: number, chain: Chain): Promise<bigint>;
-    static approve(data: string, spender: string, amount: number, chain: Chain): Promise<TransactionParams>;
-    static transfer(data: string, spender: string, amount: number, chain: Chain): Promise<TransactionParams>;
+    getAddress(options?: EnvOption): Promise<Address>;
+    getDecimals(options?: EnvOption): Promise<bigint>;
+    getBalance(address: Address, options?: EnvOption): Promise<string>;
+    getBalanceBN(address: Address, options?: EnvOption): Promise<bigint>;
+    getApproval(owner: string, spender: string, options?: EnvOption): Promise<bigint>;
+    getDecimalAmount(amount: number | string, options?: EnvOption): Promise<bigint>;
+    approve(spender: string, amount: number, options?: EnvOption): Promise<TransactionParams>;
+    transfer(spender: string, amount: number, options?: EnvOption): Promise<TransactionParams>;
+    static getAddress(data: string, chain: Chain, options?: EnvOption): Promise<Address>;
+    static getDecimals(data: string, chain: Chain, options?: EnvOption): Promise<bigint>;
+    static getBalance(data: string, address: Address, chain: Chain, options?: EnvOption): Promise<string>;
+    static getBalanceBN(data: string, address: Address, chain: Chain, options?: EnvOption): Promise<bigint>;
+    static getApproval(data: string, owner: string, spender: string, chain: Chain, options?: EnvOption): Promise<bigint>;
+    static getDecimalAmount(data: string, amount: number, chain: Chain, options?: EnvOption): Promise<bigint>;
+    static approve(data: string, spender: string, amount: number, chain: Chain, options?: EnvOption): Promise<TransactionParams>;
+    static transfer(data: string, spender: string, amount: number, chain: Chain, options?: EnvOption): Promise<TransactionParams>;
     static isNative(data: string): boolean;
 }

package/dist/src/utils/ApiUtils.d.ts

@@ -1,7 +1,2 @@
-import { type PartialAttemptOptions } from '@lifeomic/attempt';
+import type { PartialAttemptOptions } from '@lifeomic/attempt';
 export declare const DEFAULT_RETRY_OPTIONS: PartialAttemptOptions<any>;
-export declare const sendRequest: <Response>(uri: string, method: string, apiKey: string, body?: object, retryOptions?: PartialAttemptOptions<Response>) => Promise<Response>;
-export declare function sendGetRequest<Response>(uri: string, endpoint: string, apiKey?: string, retryOptions?: PartialAttemptOptions<Response>): Promise<Response>;
-export declare function sendPostRequest<Response>(uri: string, endpoint: string, body: object, apiKey?: string, retryOptions?: PartialAttemptOptions<Response>): Promise<Response>;
-export declare function sendDeleteRequest(uri: string, endpoint: string, apiKey?: string): Promise<void>;
-export declare function sendPutRequest(uri: string, endpoint: string, body: object, apiKey?: string): Promise<void>;

package/dist/src/utils/AuthUtils.d.ts

@@ -1,3 +1,4 @@
 import type { Hex } from 'viem';
-export declare const getAuthUniqueId: (authId: string, addr?: string, skipDBActions?: boolean) => Promise<string>;
+import type { EnvOption } from 'src/config';
+export declare const getAuthUniqueId: (authId: string, addr?: string, skipDBActions?: boolean, options?: EnvOption) => Promise<string>;
 export declare const generatePrivateKey: () => Hex;

package/dist/src/utils/ChainUtils.d.ts

@@ -7,12 +7,12 @@ export declare const isAddress: (address: string) => boolean;
 export declare const fundWallet: (auth: Auth, wallet: Auth | FunWallet, value: number, txOptions?: EnvOption) => Promise<import("viem").TransactionReceipt>;
 export declare const isContract: (address: Address, client: PublicClient) => Promise<boolean>;
 export declare const randomBytes: (length: number) => `0x${string}`;
-export declare const getWalletPermitNonce: (walletAddr: Address, chain: Chain, nonceKey?: number) => Promise<bigint>;
+export declare const getWalletPermitNonce: (walletAddr: Address, chain: Chain, nonceKey?: number, options?: EnvOption) => Promise<bigint>;
 export declare const getPermitHash: (token: Address, to: Address, amount: bigint, nonce: bigint, walletAddr: Address, chainId: bigint) => `0x${string}`;
-export declare const getGasStation: (gasStationUrl: string) => Promise<{
+export declare const getGasStation: (gasStationUrl: string, options?: EnvOption) => Promise<{
     standard: {
         maxPriorityFee: number;
         maxFee: number;
     };
 }>;
-export declare const useFaucet: (chainIdentifier: Chain | number | string, wallet: FunWallet) => Promise<unknown[]>;
+export declare const useFaucet: (chainIdentifier: Chain | number | string, wallet: FunWallet, txOptions?: EnvOption) => Promise<unknown[]>;

package/dist/src/utils/GroupUtils.d.ts

@@ -1,4 +1,5 @@
 import { type Address, type Hex } from 'viem';
 import type { GroupInfo } from '@funkit/api-base';
+import type { EnvOption } from 'src/config';
 import type { Chain } from '../data';
-export declare function getOnChainGroupData(groupId: Hex, chain: Chain, walletAddr: Address): Promise<GroupInfo>;
+export declare function getOnChainGroupData(groupId: Hex, chain: Chain, walletAddr: Address, options?: EnvOption): Promise<GroupInfo>;

package/dist/src/utils/TokenUtils.d.ts

@@ -1 +1,2 @@
-export declare function getTokenAddressBySymbolAndChainId(inputSymbol: any, inputChainId: any): Promise<any>;
+import type { EnvOption } from '../config';
+export declare function getTokenAddressBySymbolAndChainId(inputSymbol: any, inputChainId: any, options?: EnvOption): Promise<any>;

package/dist/src/utils/UserOpUtils.d.ts

@@ -1,11 +1,6 @@
 import { type Hex } from 'viem';
 import type { UserOperation } from '@funkit/api-base';
+import type { EnvOption } from '../config';
 import type { Chain } from '../data';
 export declare const calcPreVerificationGas: (userOp: UserOperation) => bigint;
-export declare function gasCalculation(txid: string, chain: Chain): Promise<{
-    gasUsed: string;
-    opFee: string;
-    opFeeUSD: string;
-}>;
-export declare const stringify: (object: unknown) => string;
-export declare function getOpHash(chain: Chain, userOp: UserOperation): Promise<Hex>;
+export declare function getOpHash(chain: Chain, userOp: UserOperation, options?: EnvOption): Promise<Hex>;

package/dist/src/utils/WalletUtils.d.ts

@@ -1,5 +1,6 @@
 import { type Address, type Hex } from 'viem';
 import { type Signature, type UserOperation } from '@funkit/api-base';
+import type { EnvOption } from '../config';
 import { type Chain, type Operation } from '../data';
 export declare const generateRandomBytes32: () => Hex;
 export declare const generateRandomWalletUniqueId: () => Hex;
@@ -8,7 +9,7 @@ export declare const generateRoleId: () => Hex;
 export declare const generateRuleId: () => Hex;
 export declare const generateRandomNonceKey: () => bigint;
 export declare const generateRandomNonce: () => bigint;
-export declare const getWalletAddress: (chain: Chain, walletUniqueId: Hex) => Promise<Address>;
+export declare const getWalletAddress: (chain: Chain, walletUniqueId: Hex, options?: EnvOption) => Promise<Address>;
 export declare const isWalletInitOp: (userOp: UserOperation) => boolean;
 export declare const isGroupOperation: (operation: Operation) => boolean;
 export declare const isSignatureMissing: (userId: Hex, signatures: Signature[] | undefined) => boolean;

package/dist/src/utils/index.d.ts

@@ -6,3 +6,4 @@ export * from './PaymasterUtils';
 export * from './UserOpUtils';
 export * from './TokenUtils';
 export * from './WalletUtils';
+export declare const stringify: (object: unknown) => string;

package/dist/src/viem/ContractInterface.d.ts

@@ -1,6 +1,7 @@
 import type { AbiError } from 'abitype';
 import { type AbiEvent, type AbiFunction, type Address, type Hex, type Log, type PublicClient } from 'viem';
 import type { TransactionParams } from '../common';
+import type { EnvOption } from '../config';
 import { Chain } from '../data';
 type ChainReadCall = {
     functionName: string;
@@ -9,12 +10,12 @@ type ChainReadCall = {
 export declare class ContractInterface {
     abi: ReadonlyArray<AbiError | AbiEvent | AbiFunction>;
     constructor(abi: ReadonlyArray<any>);
-    readFromChain<T>(address: Address, functionName: string, args: unknown[], chainOrClient: Chain | PublicClient): Promise<T>;
-    batchReadFromChain<T extends unknown[]>(address: Address, chainOrClient: Chain | PublicClient, calls: ChainReadCall[]): Promise<T>;
+    readFromChain<T>(address: Address, functionName: string, args: unknown[], chainOrClient: Chain | PublicClient, options?: EnvOption): Promise<T>;
+    batchReadFromChain<T extends unknown[]>(address: Address, chainOrClient: Chain | PublicClient, calls: ChainReadCall[], options?: EnvOption): Promise<T>;
     encodeTransactionParams(address: Address, functionName: string, args: unknown[], value?: bigint): TransactionParams;
     encodeData(functionName: string, args: unknown[]): Hex;
-    createFilter(address: Address, eventName: string, args: unknown[], chainOrClient: PublicClient | Chain, fromBlock: bigint): Promise<import("viem").CreateContractEventFilterReturnType<readonly (AbiEvent | AbiFunction | AbiError)[], string, unknown[], undefined, bigint, undefined>>;
-    getLog(address: Address, name: string, args: ReadonlyArray<unknown> | Record<string, unknown> | undefined, chainOrClient: PublicClient | Chain, fromBlock: bigint): Promise<Log[]>;
+    createFilter(address: Address, eventName: string, args: unknown[], chainOrClient: PublicClient | Chain, fromBlock: bigint, options?: EnvOption): Promise<import("viem").CreateContractEventFilterReturnType<readonly (AbiEvent | AbiFunction | AbiError)[], string, unknown[], undefined, bigint, undefined>>;
+    getLog(address: Address, name: string, args: ReadonlyArray<unknown> | Record<string, unknown> | undefined, chainOrClient: PublicClient | Chain, fromBlock: bigint, options?: EnvOption): Promise<Log[]>;
 }
-export declare const parseClient: (chainOrClient: PublicClient | Chain) => Promise<PublicClient>;
+export declare const parseClient: (chainOrClient: PublicClient | Chain, options?: EnvOption) => Promise<PublicClient>;
 export {};

package/dist/src/wallet/FunWallet.d.ts

@@ -28,7 +28,7 @@ export declare class FunWallet extends FirstClassActions {
      * @param {string} apiKey - The API key to access the required resources.
      * @returns {Promise<Address>} The wallet address.
      */
-    static getAddress(uniqueId: string, apiKey: string): Promise<Address>;
+    static getAddress(uniqueId: string, apiKey: string, options?: EnvOption): Promise<Address>;
     /**
      * Retrieves the wallet address associated with the provided unique ID in an offline environment.
      * @param {string} uniqueId - The unique ID of the wallet.
@@ -36,21 +36,21 @@ export declare class FunWallet extends FirstClassActions {
      * @param {Address} factoryAddress - The address of the factory contract.
      * @returns {Promise<Address>} The wallet address.
      */
-    static getAddressOffline(uniqueId: string, rpcUrl: string, factoryAddress: Address): Promise<unknown>;
+    static getAddressOffline(uniqueId: string, rpcUrl: string, factoryAddress: Address, options?: EnvOption): Promise<unknown>;
     /**
      * Get all tokens for a specific chain
      * @param {string} chainId string version of the chainId or ALL. If empty, then default to the one in globalEnvOption
      * @param {boolean} onlyVerifiedTokens If true, only return alchemy tokens that are verified(filters spam) - defaults to false
      * @returns JSON
      */
-    getTokens(chainIdInput?: string, onlyVerifiedTokens?: boolean): Promise<import("@funkit/api-base").GetAllWalletTokensResponse | import("@funkit/api-base").ChainAssetBalanceInfo>;
+    getTokens(chainIdInput?: string, onlyVerifiedTokens?: boolean, options?: EnvOption): Promise<import("@funkit/api-base").GetAllWalletTokensResponse | import("@funkit/api-base").ChainAssetBalanceInfo>;
     /**
      * Given an address and a chain, returns all NFTs owned by that address
      * @param {string} chainId string version of the chainId or ALL. If empty, then default to the one in globalEnvOption
      * @returns array
      */
-    getNFTs(chainIdInput?: string): Promise<import("@funkit/api-base").GetAllWalletNFTsResponse | import("@funkit/api-base").GetAllWalletNFTsByChainIdResponse>;
-    getLidoWithdrawals(): Promise<import("@funkit/api-base").GetWalletLidoWithdrawalsByChainIdResponse>;
+    getNFTs(chainIdInput?: string, options?: EnvOption): Promise<import("@funkit/api-base").GetAllWalletNFTsResponse | import("@funkit/api-base").GetAllWalletNFTsByChainIdResponse>;
+    getLidoWithdrawals(options?: EnvOption): Promise<import("@funkit/api-base").GetWalletLidoWithdrawalsByChainIdResponse>;
     /**
      * Get all tokens on all supported chains. Merge tokens by symbol
      * @param {string} chainIdInput string version of the chainId or ALL. If empty, then default to the one in globalEnvOption
@@ -58,7 +58,7 @@ export declare class FunWallet extends FirstClassActions {
      * @param {boolean} checkStatus true if you want to check if the address has any pending lido withdrawals
      * @returns JSON of all tokens owned by address
      */
-    getAssets(chainIdInput?: string, onlyVerifiedTokens?: boolean, checkStatus?: boolean): Promise<{}>;
+    getAssets(chainIdInput?: string, onlyVerifiedTokens?: boolean, checkStatus?: boolean, options?: EnvOption): Promise<{}>;
     /**
      * Retrieves the nonce value for the specified sender address and nonce key.
      * If the nonce is unavailable, a random nonce key is generated and returned as the nonce.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funkit/core",
-  "version": "2.3.6",
+  "version": "2.3.8",
   "description": "Funkit core SDK provides feature-rich and extensible smart wallets built on account abstraction",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,9 +19,9 @@
     "dotenv": "^16.0.3",
     "ethers": "5.7.2",
     "uuid": "^9.0.0",
-    "@funkit/api-base": "1.5.5",
+    "@funkit/api-base": "1.5.7",
     "@funkit/chains": "0.1.2",
-    "@funkit/utils": "1.0.6"
+    "@funkit/utils": "1.0.7"
   },
   "peerDependencies": {
     "viem": "2.x"