@funkit/core 2.3.3 → 2.3.4

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

@@ -1,8 +1,8 @@
 import { type TransactionParams } from '../common';
 import type { EnvOption } from '../config';
 import type { FinishUnstakeParams, RequestUnstakeParams, StakeParams } from './types';
-export declare const isRequestUnstakeParams: (input: any) => boolean;
-export declare const isFinishUnstakeParams: (input: any) => boolean;
+export declare const isRequestUnstakeParams: (input: RequestUnstakeParams | FinishUnstakeParams) => boolean;
+export declare const isFinishUnstakeParams: (input: RequestUnstakeParams | FinishUnstakeParams) => boolean;
 export declare const stakeTransactionParams: (params: StakeParams, txOptions?: EnvOption) => Promise<TransactionParams>;
 export declare const requestUnstakeTransactionParams: (params: RequestUnstakeParams, txOptions?: EnvOption) => Promise<TransactionParams>;
 export declare const finishUnstakeTransactionParams: (params: FinishUnstakeParams, txOptions?: EnvOption) => Promise<TransactionParams>;

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

@@ -1,19 +1,24 @@
 import { type Address } from 'viem';
-import { type TransactionData } from '../common';
+import { type TransactionData, type TransactionParams } from '../common';
 import type { EnvOption } from '../config';
+import { Chain } from './Chain';
 export declare class NFT {
     address?: Address;
     name: string;
     constructor(input: string);
     approve(spender: string, tokenId: number, options?: EnvOption): Promise<TransactionData>;
     ownerOf(tokenId: number, options?: EnvOption): Promise<Address>;
-    approveForAll(spender: string, options?: EnvOption): Promise<any>;
+    approveForAll(spender: string, options?: EnvOption): Promise<TransactionParams & {
+        chain: Chain;
+    }>;
     getAddress(): Promise<Address>;
     getName(options?: EnvOption): Promise<string>;
     getBalance(address: Address, options?: EnvOption): Promise<bigint>;
     getApproved(tokenId: string, options?: EnvOption): Promise<Address>;
     revokeForAll(spender: string, options?: EnvOption): Promise<TransactionData>;
-    transfer(sender: string, spender: string, tokenId: number, options?: EnvOption): Promise<any>;
+    transfer(sender: string, spender: string, tokenId: number, options?: EnvOption): Promise<TransactionParams & {
+        chain: Chain;
+    }>;
     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>;

package/dist/src/errors/clientErrors.d.ts

@@ -1,4 +1,4 @@
 import { ClientError } from '@funkit/utils';
 export declare class InvalidActionError extends ClientError {
-    constructor(code: string, msg: string, paramsUsed: any, fixSuggestion: string, docLink: string);
+    constructor(code: string, msg: string, paramsUsed: unknown, fixSuggestion: string, docLink: string);
 }

package/dist/src/sponsors/GaslessSponsor.d.ts

@@ -15,5 +15,4 @@ export declare class GaslessSponsor extends Sponsor {
     unlockDepositAfter(blocksToWait: number): Promise<TransactionParams>;
     getSpenderBlacklistMode(spender: Address, sponsor: Address, options?: EnvOption): Promise<boolean>;
     getSpenderWhitelistMode(spender: Address, sponsor: Address, options?: EnvOption): Promise<boolean>;
-    static getPaymasterAddress(options?: EnvOption): Promise<Address>;
 }

package/dist/src/sponsors/TokenSponsor.d.ts

@@ -15,10 +15,10 @@ export declare class TokenSponsor extends Sponsor {
     unstake(receiver: Address, amount: number, options?: EnvOption): Promise<TransactionParams>;
     getUnlockBlock(sponsor: Address, token: string, options?: EnvOption): Promise<bigint>;
     getLockState(sponsor: Address, token: string, options?: EnvOption): Promise<boolean>;
-    getTokenInfo(token: string, options?: EnvOption): Promise<any>;
+    getTokenInfo(token: string, options?: EnvOption): Promise<unknown>;
     getAllTokenData(spender: Address, token: string, options?: EnvOption): Promise<AllTokenData>;
     getTokenBalance(spender: Address, token: string, options?: EnvOption): Promise<bigint>;
-    getAllTokens(options?: EnvOption): Promise<any>;
+    getAllTokens(options?: EnvOption): Promise<unknown>;
     addUsableToken(oracle: string, token: string, aggregator: string, options?: EnvOption): Promise<TransactionParams>;
     depositToken(token: string, spender: Address, amount: number, options?: EnvOption): Promise<TransactionParams>;
     withdrawToken(token: string, receiver: Address, amount: number, options?: EnvOption): Promise<TransactionParams>;
@@ -32,9 +32,8 @@ export declare class TokenSponsor extends Sponsor {
     getTokenWhitelisted(sponsor: Address, token: string, options?: EnvOption): Promise<boolean>;
     setTokenToWhitelistMode(): Promise<TransactionParams>;
     batchWhitelistTokens(tokens: string[], modes: boolean[], options?: EnvOption): Promise<TransactionParams>;
-    getTokenListMode(sponsor: Address, options?: EnvOption): Promise<any>;
+    getTokenListMode(sponsor: Address, options?: EnvOption): Promise<unknown>;
     getTokenBlacklisted(sponsor: Address, token: string, options?: EnvOption): Promise<boolean>;
     setTokenToBlacklistMode(): Promise<TransactionParams>;
     batchBlacklistTokens(tokens: string[], modes: boolean[], options?: EnvOption): Promise<TransactionParams>;
-    static getPaymasterAddress(options?: EnvOption): Promise<Address>;
 }

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

@@ -1,20 +1,7 @@
 import { type PartialAttemptOptions } from '@lifeomic/attempt';
-export declare const DEFAULT_RETRY_OPTIONS: {
-    delay: number;
-    initialDelay: number;
-    maxDelay: number;
-    factor: number;
-    maxAttempts: number;
-    timeout: number;
-    jitter: boolean;
-    minDelay: number;
-    handleError: (err: any, context: any) => void;
-    handleTimeout: null;
-    beforeAttempt: null;
-    calculateDelay: null;
-};
-export declare const sendRequest: (uri: string, method: string, apiKey: string, body?: object, retryOptions?: PartialAttemptOptions<any>) => Promise<any>;
-export declare function sendGetRequest(uri: string, endpoint: string, apiKey?: string, retryOptions?: PartialAttemptOptions<any>): Promise<any>;
-export declare function sendPostRequest(uri: string, endpoint: string, body: object, apiKey?: string, retryOptions?: PartialAttemptOptions<any>): Promise<any>;
+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/ChainUtils.d.ts

@@ -7,7 +7,7 @@ export declare const isAddress: (address: string) => boolean;
 export declare const fundWallet: (auth: Auth, wallet: 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<any>;
+export declare const getWalletPermitNonce: (walletAddr: Address, chain: Chain, nonceKey?: number) => 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<{
     standard: {

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

@@ -6,7 +6,7 @@ export declare const getParent: (index: number) => number;
 export declare const getSibling: (index: number) => number;
 export declare const getHash: (list: Hex[], i: number) => Hex;
 export declare const getHashPair: (left: Hex, right: Hex) => Hex;
-export declare const arrayCopy: (arr: any[], copy: any[], start: number) => void;
+export declare const arrayCopy: <T>(arr: T[], copy: T[], start: number) => void;
 export declare const getPathForItem: (list: Hex[], item: Hex) => `0x${string}`[];
 export declare const verifyPath: (root: Hex, item: Hex, path: Hex[]) => boolean;
 export declare class MerkleTree {

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

@@ -2,12 +2,10 @@ import { type Hex } from 'viem';
 import type { UserOperation } from '@funkit/api-base';
 import type { Chain } from '../data';
 export declare const calcPreVerificationGas: (userOp: UserOperation) => bigint;
-export declare const getPromiseFromOp: (op: UserOperation) => Promise<any>;
 export declare function gasCalculation(txid: string, chain: Chain): Promise<{
     gasUsed: string;
     opFee: string;
     opFeeUSD: string;
 }>;
-export declare const stringify: (object: any) => string;
-export declare const objectify: (op: any) => any;
+export declare const stringify: (object: unknown) => string;
 export declare function getOpHash(chain: Chain, userOp: UserOperation): Promise<Hex>;

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

@@ -6,4 +6,6 @@ export declare function formatAbiItem(abiItem: AbiItem, { includeName }?: {
 export declare function formatAbiParams(params: readonly AbiParameter[] | undefined, { includeName }?: {
     includeName?: boolean;
 }): string;
-export declare const getSigHash: (abi: any, functionName: string) => `0x${string}`;
+export declare const getSigHash: (abi: ReadonlyArray<{
+    name?: string;
+}>, functionName: string) => `0x${string}`;

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

@@ -1,19 +1,20 @@
-import { type Address, type Hex, type Log, type PublicClient } from 'viem';
+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 { Chain } from '../data';
 type ChainReadCall = {
     functionName: string;
-    args?: any[];
+    args?: unknown[];
 };
 export declare class ContractInterface {
-    abi: any;
-    constructor(abi: any);
-    readFromChain(address: Address, functionName: string, args: any[], chainOrClient: Chain | PublicClient): Promise<any>;
-    batchReadFromChain(address: Address, chainOrClient: Chain | PublicClient, calls: ChainReadCall[]): Promise<any[]>;
-    encodeTransactionParams(address: Address, functionName: string, args: any[], value?: bigint): TransactionParams;
-    encodeData(functionName: string, args: any[]): Hex;
-    createFilter(address: Address, eventName: any, args: any, chainOrClient: PublicClient | Chain, fromBlock: bigint): Promise<import("viem").CreateContractEventFilterReturnType<any, any, any, undefined, bigint, undefined>>;
-    getLog(address: Address, name: string, args: any, chainOrClient: PublicClient | Chain, fromBlock: bigint): Promise<Log[]>;
+    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>;
+    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[]>;
 }
 export declare const parseClient: (chainOrClient: PublicClient | Chain) => Promise<PublicClient>;
 export {};

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

@@ -36,7 +36,7 @@ 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<any>;
+    static getAddressOffline(uniqueId: string, rpcUrl: string, factoryAddress: Address): 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funkit/core",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "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,10 +19,12 @@
     "dotenv": "^16.0.3",
     "ethers": "5.7.2",
     "uuid": "^9.0.0",
-    "viem": "2.17.0",
-    "@funkit/api-base": "1.5.2",
-    "@funkit/chains": "0.1.1",
-    "@funkit/utils": "1.0.5"
+    "@funkit/api-base": "1.5.3",
+    "@funkit/utils": "1.0.5",
+    "@funkit/chains": "0.1.2"
+  },
+  "peerDependencies": {
+    "viem": "2.x"
   },
   "devDependencies": {
     "@types/uuid": "^9.0.1",