@funkit/core 2.2.5 → 2.2.7

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

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

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

@@ -1,3 +1,3 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
+import type { Address } from 'viem';
+import { type TransactionParams } from '../common';
 export declare const createExecuteBatchTxParams: (params: TransactionParams[], walletAddress: Address) => TransactionParams;

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

@@ -1,5 +1,5 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
+import type { Address } from 'viem';
+import { type TransactionParams } from '../common';
 import { Chain } from '../data';
-import { BridgeParams } from './types';
+import { type BridgeParams } from './types';
 export declare const bridgeTransactionParams: (params: BridgeParams, walletAddress: Address, chain: Chain) => Promise<TransactionParams>;

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

@@ -1,9 +1,9 @@
-import { Address } from 'viem';
-import { Auth } from '../auth';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { Chain, Operation } from '../data';
-import { AddOwnerParams, AddUserToGroupParams, ApproveParams, BridgeParams, CreateGroupParams, FinishUnstakeParams, LimitOrderParam, RemoveGroupParams, RemoveOwnerParams, RemoveUserFromGroupParams, RequestUnstakeParams, SessionKeyParams, StakeParams, SwapParams, TransferParams, UpdateThresholdOfGroupParams } from './types';
+import { type Address } from 'viem';
+import type { Auth } from '../auth';
+import type { TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import { Chain, type Operation } from '../data';
+import type { AddOwnerParams, AddUserToGroupParams, ApproveParams, BridgeParams, CreateGroupParams, FinishUnstakeParams, LimitOrderParam, RemoveGroupParams, RemoveOwnerParams, RemoveUserFromGroupParams, RequestUnstakeParams, SessionKeyParams, StakeParams, SwapParams, TransferParams, UpdateThresholdOfGroupParams } from './types';
 export declare abstract class FirstClassActions {
     protected chain: Chain;
     constructor(chain: Chain);

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

@@ -1,6 +1,6 @@
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { CreateGroupParams, RemoveGroupParams, UpdateGroupParams } from './types';
+import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import type { CreateGroupParams, RemoveGroupParams, UpdateGroupParams } from './types';
 export declare const createGroupTxParams: (params: CreateGroupParams, txOptions?: EnvOption) => Promise<TransactionParams>;
 export declare const updateGroupTxParams: (params: UpdateGroupParams, txOptions?: EnvOption) => Promise<TransactionParams>;
 export declare const removeGroupTxParams: (params: RemoveGroupParams, txOptions?: EnvOption) => Promise<TransactionParams>;

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

@@ -1,4 +1,4 @@
-import { TransactionParams } from '../common';
-import { Chain } from '../data';
-import { LimitOrderParam } from './types';
+import { type TransactionParams } from '../common';
+import { type Chain } from '../data';
+import type { LimitOrderParam } from './types';
 export declare const limitSwapOrderTransactionParams: (params: LimitOrderParam, chain: Chain) => Promise<TransactionParams>;

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

@@ -1,6 +1,6 @@
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { FinishUnstakeParams, RequestUnstakeParams, StakeParams } from './types';
+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 stakeTransactionParams: (params: StakeParams, txOptions?: EnvOption) => Promise<TransactionParams>;

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

@@ -1,7 +1,7 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { SwapParams } from './types';
+import { type Address } from 'viem';
+import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import { type SwapParams } from './types';
 export declare const oneInchSupported: number[];
 export declare const uniswapV3Supported: number[];
 export declare const oneInchTransactionParams: (params: SwapParams, walletAddress: Address, txOptions?: EnvOption) => Promise<TransactionParams>;

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

@@ -1,6 +1,6 @@
-import { TransactionParams } from '../common';
+import { type TransactionParams } from '../common';
 import { Chain } from '../data/Chain';
-import { ApproveERC20Params, ApproveERC721Params, ApproveParams, ERC721TransferParams, TokenTransferParams, TransferParams } from './types';
+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>;

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

@@ -1,6 +1,6 @@
-import { Address, Hex } from 'viem';
-import { TransactionParams } from '../common';
-import { Chain } from '../data';
+import type { Address, Hex } from 'viem';
+import type { TransactionParams } from '../common';
+import type { Chain } from '../data';
 export interface ApproveAndExecParams {
     approve: ApproveERC20Params;
     exec: TransactionParams;

package/dist/src/apis/AccessControlApis.d.ts

@@ -1,4 +1,4 @@
-import { Address, Hex } from 'viem';
+import type { Address, Hex } from 'viem';
 export declare function initializeWalletAccess(walletAddr: Address, creatorAddr: Address): Promise<void>;
 export declare function checkWalletAccessInitialization(walletAddr: Address): Promise<boolean>;
 export declare function addAccessToWallet(walletAddr: Address, nonce: number, signature: Hex): Promise<void>;

package/dist/src/apis/BridgeApis.d.ts

@@ -1,4 +1,4 @@
-import { Address } from 'viem';
+import type { Address } from 'viem';
 export declare function getSocketBridgeQuote(recipient: string, walletAddress: string, fromChain: string, toChain: string, fromToken: string, toToken: string, amount: bigint, sort: string): Promise<any>;
 export declare function getSocketBridgeTransaction(route: any): Promise<any>;
 export declare function getSocketBridgeAllowance(chainId: string, sender: Address, allowanceTarget: string, token: string): Promise<any>;

package/dist/src/apis/GroupApis.d.ts

@@ -1,4 +1,4 @@
-import { Address, Hex } from 'viem';
-import { GroupMetadata } from './types';
+import type { Address, Hex } from 'viem';
+import type { GroupMetadata } from './types';
 export declare function getGroups(groupIds: Hex[], chainId: string): Promise<GroupMetadata[]>;
 export declare function getGroupsByWallet(walletAddr: Address, chainId: string): Promise<GroupMetadata[]>;

package/dist/src/apis/InfoApis.d.ts

@@ -1,4 +1,4 @@
-import { Address } from 'viem';
+import type { Address } from 'viem';
 export declare function getTokenInfo(symbol: string, chainId: string): Promise<Address>;
 export declare function getChainFromId(chainId: string): Promise<any>;
 export declare function getChainFromName(name: string): Promise<any>;

package/dist/src/apis/ListenerApis.d.ts

@@ -1,3 +1,3 @@
-import { Address } from 'viem';
+import type { Address } from 'viem';
 export declare function createListener(walletAddresses: Address[], chains: string[], webhookUrl: string): Promise<void>;
 export declare function deleteListener(walletAddress: Address, chain: string): Promise<void>;

package/dist/src/apis/OperationApis.d.ts

@@ -1,7 +1,7 @@
-import { Address, Hex } from 'viem';
-import { ExecutionReceipt } from '../common/types';
-import { Operation, OperationStatus } from '../data';
-import { EstimatedGas, EstimateOpInput, ExecuteOpInput, ScheduleOpInput, UserOperationGasPrice } from './types';
+import type { Address, Hex } from 'viem';
+import type { ExecutionReceipt } from '../common/types';
+import { type Operation, OperationStatus } from '../data';
+import type { EstimateOpInput, EstimatedGas, ExecuteOpInput, ScheduleOpInput, UserOperationGasPrice } from './types';
 export declare function createOp(op: Operation): Promise<string>;
 export declare function getOpsOfGroup(groupId: Hex, chainId: string, status: OperationStatus): Promise<Operation[]>;
 export declare function getOpsOfWallet(walletAddr: Address, chainId: string, status?: OperationStatus): Promise<Operation[]>;

package/dist/src/apis/PaymasterApis.d.ts

@@ -1,4 +1,4 @@
-import { PaymasterType } from '../sponsors/types';
+import type { PaymasterType } from '../sponsors/types';
 export interface PaymasterTransaction {
     action: string;
     amount: number;

package/dist/src/apis/SwapApis.d.ts

@@ -1,4 +1,4 @@
-import { TransactionParams } from '../common';
+import type { TransactionParams } from '../common';
 export declare function get1InchSwapTx(chainId: string, src: string, dst: string, amount: string, from: string, slippage: string, disableEstimate: string, allowPartialFill: string): Promise<TransactionParams>;
 export declare function get1InchAllowance(chainId: string, tokenAddress: string, walletAddress: string): Promise<number>;
 export declare function get1InchApproveTx(chainId: string, tokenAddress: string, amount: string): Promise<TransactionParams>;

package/dist/src/apis/UserApis.d.ts

@@ -1,5 +1,5 @@
-import { Address, Hex } from 'viem';
-import { Wallet } from './types';
+import { type Address, type Hex } from 'viem';
+import type { Wallet } from './types';
 export declare function createUser(authId: string, addr: string, method: string, userUniqueId: string): Promise<void>;
 export declare function getUserUniqueId(authId: string): Promise<string>;
 export declare function getUserAddr(authId: string): Promise<string>;

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

@@ -1,6 +1,6 @@
-import { Address, Hex } from 'viem';
-import { UserOperation } from '../data';
-import { GroupInfo } from '../wallet';
+import type { Address, Hex } from 'viem';
+import type { UserOperation } from '../data';
+import type { GroupInfo } from '../wallet';
 export type Wallet = {
     walletUniqueId?: string;
     walletAddr: Address;

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

@@ -1,9 +1,9 @@
-import { Address, Hex, JsonRpcAccount, PrivateKeyAccount, TransactionReceipt, WalletClient } from 'viem';
-import { Wallet } from '../apis/types';
-import { TransactionData, TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { Chain, Operation } from '../data';
-import { AuthInput } from './types';
+import { type Address, type Hex, type JsonRpcAccount, type PrivateKeyAccount, type TransactionReceipt, type WalletClient } from 'viem';
+import type { Wallet } from '../apis/types';
+import { type TransactionData, type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import { Chain, type Operation } from '../data';
+import type { AuthInput } from './types';
 export declare class Auth {
     authId?: string;
     signer?: PrivateKeyAccount | JsonRpcAccount;

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

@@ -1,8 +1,8 @@
-import { Hex } from 'viem';
-import { Chain, Operation } from '../data';
-import { MerkleTree } from '../utils/MerkleUtils';
+import { type Hex } from 'viem';
+import { type Chain, type Operation } from '../data';
+import type { MerkleTree } from '../utils/MerkleUtils';
 import { Auth } from './Auth';
-import { AuthInput, WalletCallData } from './types';
+import type { AuthInput, WalletCallData } from './types';
 export declare class SessionKeyAuth extends Auth {
     ruleId: Hex;
     roleId: Hex;

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

@@ -1,4 +1,4 @@
-import { Address, Hex, WalletClient } from 'viem';
+import type { Address, Hex, WalletClient } from 'viem';
 export interface AuthInput {
     web2AuthId?: string;
     client?: WalletClient;

package/dist/src/common/constants.d.ts

@@ -1,3 +1,4 @@
+import { type Hex } from 'viem';
 import { ContractInterface } from '../viem/ContractInterface';
 export declare const LOCAL_API_URL = "http://127.0.0.1:3000";
 declare let API_URL: string;
@@ -5,37 +6,37 @@ export { API_URL };
 export declare const DASHBOARD_API_URL = "https://api.fun.xyz/dashboard";
 export declare const BASE_WRAP_TOKEN_ADDR: {
     '1': {
-        weth: string;
+        weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
     };
     '5': {
-        weth: string;
+        weth: "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6";
     };
     '10': {
-        weth: string;
+        weth: "0x4200000000000000000000000000000000000006";
     };
     '137': {
-        wmatic: string;
+        wmatic: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
     };
     '5000': {
-        weth: string;
+        weth: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111";
     };
     '8453': {
-        weth: string;
+        weth: "0x4200000000000000000000000000000000000006";
     };
     '36865': {
-        weth: string;
+        weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
     };
     '42161': {
-        weth: string;
+        weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
     };
     '421614': {
-        weth: string;
+        weth: "0x980b62da83eff3d4576c647993b0c1d7faf17c73";
     };
     '43113': {
-        weth: string;
+        weth: "0x1D308089a2D1Ced3f1Ce36B1FcaF815b07217be3";
     };
     '534352': {
-        weth: string;
+        weth: "0x5300000000000000000000000000000000000004";
     };
 };
 export declare const FUN_GASLESS_SPONSOR_ADDRESS = "0xCB5D0b4569A39C217c243a436AC3feEe5dFeb9Ad";

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

@@ -1,5 +1,5 @@
-import { Address, Hex } from 'viem';
-import { Chain } from '../data';
+import type { Address, Hex } from 'viem';
+import type { Chain } from '../data';
 type BigIntIsh = bigint | number | string | undefined;
 export type TransactionParams = {
     to: Address;

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

@@ -1,4 +1,4 @@
-import { EnvOption, GlobalEnvOption } from './types';
+import type { EnvOption, GlobalEnvOption } from './types';
 export declare function getEnvOptions(): GlobalEnvOption;
-export declare function parseOptions(option: EnvOption): any;
+export declare function parseOptions(option: EnvOption): GlobalEnvOption & EnvOption;
 export declare function configureEnvironment(option: GlobalEnvOption): Promise<void>;

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

@@ -1,5 +1,5 @@
-import { Address } from 'viem';
-import { Chain } from '../data';
+import type { Address } from 'viem';
+import type { Chain } from '../data';
 export interface EnvOption {
     chain?: string | Chain | number;
     gasSponsor?: {

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

@@ -1,7 +1,7 @@
-import { Address, Hex, PublicClient } from 'viem';
-import { UserOperationGasPrice } from '../apis';
-import { EstimateGasResult } from '../common';
-import { ChainInput, UserOperation } from './types';
+import { type Address, type Hex, type PublicClient } from 'viem';
+import { type UserOperationGasPrice } from '../apis';
+import { type EstimateGasResult } from '../common';
+import type { ChainInput, UserOperation } from './types';
 export declare class Chain {
     private initialized;
     private id?;

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

@@ -1,6 +1,6 @@
-import { Address } from 'viem';
-import { TransactionData } from '../common';
-import { EnvOption } from '../config';
+import { type Address } from 'viem';
+import { type TransactionData } from '../common';
+import type { EnvOption } from '../config';
 export declare class NFT {
     address?: Address;
     name: string;
@@ -16,7 +16,7 @@ export declare class NFT {
     transfer(sender: string, spender: string, tokenId: number, options?: EnvOption): Promise<any>;
     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<string>;
+    static getAddress(data: string): 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

@@ -1,9 +1,12 @@
-import { Address, Hex } from 'viem';
-import { Auth } from '../auth';
-import { EnvOption } from '../config';
+import type { Address, Hex } from 'viem';
+import type { Auth } from '../auth';
+import type { EnvOption } from '../config';
 import { Chain } from './Chain';
-import { AuthType, OperationMetadata, OperationStatus, OperationType, Signature, UserOperation } from './types';
-export declare class Operation {
+import type { AuthType, OperationMetadata, OperationStatus, OperationType, Signature, UserOperation } from './types';
+export interface OperationData extends OperationMetadata {
+    userOp: UserOperation;
+}
+export declare class Operation implements OperationData {
     opId?: Hex;
     chainId: string;
     opType: OperationType;
@@ -26,7 +29,7 @@ export declare class Operation {
     executedBlockNumber?: number;
     executedBlockTimeStamp?: number;
     constructor(userOp: UserOperation, metadata: OperationMetadata);
-    static convertTypeToObject(op: Operation): Operation;
+    static convertTypeToObject(op: OperationData): Operation;
     getOpHash(chain: Chain): Promise<Hex>;
     getMaxTxCost(): bigint;
     estimateGas(auth: Auth, userId: string, options?: EnvOption): Promise<Operation>;

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

@@ -1,6 +1,6 @@
-import { Address, Hex } from 'viem';
-import { User } from '../wallet/types';
-import { LoginData, WalletSignature } from './types';
+import { type Address, type Hex } from 'viem';
+import type { User } from '../wallet/types';
+import type { LoginData, WalletSignature } from './types';
 export declare function encodeLoginData(data: LoginData): Hex;
 export declare function encodeWalletSignature(data: WalletSignature): Hex;
 export declare function encodeUserAuthInitData(groupUsers: User[]): Hex;

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

@@ -1,6 +1,6 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
-import { Chain } from './Chain';
+import { type Address } from 'viem';
+import { type TransactionParams } from '../common';
+import type { Chain } from './Chain';
 export declare class Token {
     address?: Address;
     chain: Chain;

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

@@ -1,5 +1,5 @@
-import { Address, Hex } from 'viem';
-import { Chain } from './Chain';
+import type { Address, Hex } from 'viem';
+import type { Chain } from './Chain';
 export interface ChainInput {
     chainIdentifier?: string | Chain | number;
     rpcUrl?: string;

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

@@ -1,6 +1,6 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
+import type { Address } from 'viem';
+import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
 import { Sponsor } from './Sponsor';
 export declare class CheckoutSponsor extends Sponsor {
     constructor(options?: EnvOption);

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

@@ -1,6 +1,6 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
+import { type Address } from 'viem';
+import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
 import { Sponsor } from './Sponsor';
 export declare class GaslessSponsor extends Sponsor {
     constructor(options?: EnvOption);

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

@@ -1,8 +1,8 @@
-import { Address } from 'viem';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { ContractInterface } from '../viem/ContractInterface';
-import { PaymasterType } from './types';
+import type { Address } from 'viem';
+import type { TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import type { ContractInterface } from '../viem/ContractInterface';
+import type { PaymasterType } from './types';
 export declare abstract class Sponsor {
     sponsorAddress?: Address;
     contractInterface: ContractInterface;
@@ -10,7 +10,7 @@ export declare abstract class Sponsor {
     paymasterAddress?: Address;
     paymasterType: PaymasterType;
     chainId?: string;
-    constructor(options: EnvOption | undefined, contractInterface: ContractInterface, name: string, paymasterType: PaymasterType);
+    constructor(options: EnvOption, contractInterface: ContractInterface, name: string, paymasterType: PaymasterType);
     getPaymasterAddress(options?: EnvOption): Promise<Address>;
     abstract getPaymasterAndData(options: EnvOption): Promise<string>;
     abstract stake(sponsor: string, amount: number, options: EnvOption): Promise<TransactionParams>;

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

@@ -1,10 +1,10 @@
-import { Address } from 'viem';
-import { Auth } from '../auth';
-import { TransactionParams } from '../common';
-import { EnvOption } from '../config';
-import { Operation } from '../data';
+import { type Address } from 'viem';
+import type { Auth } from '../auth';
+import { type TransactionParams } from '../common';
+import type { EnvOption } from '../config';
+import { type Operation } from '../data';
 import { Sponsor } from './Sponsor';
-import { AllTokenData } from './types';
+import { type AllTokenData } from './types';
 export declare class TokenSponsor extends Sponsor {
     token: string;
     constructor(options?: EnvOption);

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

@@ -1,4 +1,4 @@
-import { PartialAttemptOptions } from '@lifeomic/attempt';
+import { type PartialAttemptOptions } from '@lifeomic/attempt';
 export declare const DEFAULT_RETRY_OPTIONS: {
     delay: number;
     initialDelay: number;
@@ -14,7 +14,7 @@ export declare const DEFAULT_RETRY_OPTIONS: {
     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 | undefined, endpoint: string, apiKey?: string, retryOptions?: PartialAttemptOptions<any>): Promise<any>;
-export declare function sendPostRequest(uri: string | undefined, endpoint: string, body: object, apiKey?: string, retryOptions?: PartialAttemptOptions<any>): Promise<any>;
-export declare function sendDeleteRequest(uri: string | undefined, endpoint: string, apiKey?: string): Promise<void>;
-export declare function sendPutRequest(uri: string | undefined, endpoint: string, body: object, apiKey?: string): Promise<void>;
+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 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,3 @@
-import { Hex } from 'viem';
-export declare const getAuthUniqueId: (authId: string, addr?: string, skipDBActions?: boolean) => Promise<any>;
+import type { Hex } from 'viem';
+export declare const getAuthUniqueId: (authId: string, addr?: string, skipDBActions?: boolean) => Promise<string>;
 export declare const generatePrivateKey: () => Hex;

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

@@ -1,13 +1,18 @@
-import { Address, PublicClient } from 'viem';
-import { Auth } from '../auth';
-import { EnvOption } from '../config';
+import { type Address, type PublicClient } from 'viem';
+import type { Auth } from '../auth';
+import type { EnvOption } from '../config';
 import { Chain } from '../data';
-import { FunWallet } from '../wallet';
+import type { FunWallet } from '../wallet';
 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 getPermitHash: (token: Address, to: Address, amount: bigint, nonce: bigint, walletAddr: Address, chainId: bigint) => `0x${string}`;
-export declare const getGasStation: (gasStationUrl: string) => Promise<any>;
+export declare const getGasStation: (gasStationUrl: string) => Promise<{
+    standard: {
+        maxPriorityFee: number;
+        maxFee: number;
+    };
+}>;
 export declare const useFaucet: (chainIdentifier: Chain | number | string, wallet: FunWallet) => Promise<any[]>;

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

@@ -1,4 +1,4 @@
-import { Address, Hex } from 'viem';
-import { Chain } from '../data';
-import { GroupInfo } from '../wallet';
+import { type Address, type Hex } from 'viem';
+import type { Chain } from '../data';
+import type { GroupInfo } from '../wallet';
 export declare function getOnChainGroupData(groupId: Hex, chain: Chain, walletAddr: Address): Promise<GroupInfo>;

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

@@ -1,4 +1,4 @@
-import { Hex } from 'viem';
+import { type Hex } from 'viem';
 export declare const createMerkleHashes: (list: Hex[]) => any[];
 export declare const getLeft: (i: number) => number;
 export declare const getRight: (i: number) => number;

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

@@ -1,3 +1,3 @@
-import { EnvOption } from '../config';
+import type { EnvOption } from '../config';
 import { PaymasterType } from '../sponsors/types';
 export declare const getPaymasterType: (txOptions: EnvOption) => PaymasterType.GaslessSponsor | PaymasterType.TokenSponsor | PaymasterType.CheckoutSponsor;

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

@@ -1,5 +1,5 @@
-import { Address, PublicClient } from 'viem';
-import { UniswapPoolFeeOptions } from '../actions';
+import { type Address, type PublicClient } from 'viem';
+import type { UniswapPoolFeeOptions } from '../actions';
 export declare function fromReadableAmount(amount: number, decimals: number): bigint;
 type SwapParamsUtils = {
     tokenInAddress: Address;
@@ -26,8 +26,8 @@ export declare function swapExec(client: PublicClient, uniswapAddrs: UniswapV3Ad
     value: string;
 }>;
 export declare function swapExecV2(client: PublicClient, uniswapAddrs: UniswapV2Addrs, swapParams: SwapParamsUtils, chainId: number): Promise<{
-    data: any;
-    to: any;
+    data: `0x${string}` | undefined;
+    to: `0x${string}`;
     amount: string;
 }>;
 export {};

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

@@ -1,5 +1,5 @@
-import { Hex } from 'viem';
-import { Chain, UserOperation } from '../data';
+import { type Hex } from 'viem';
+import type { Chain, UserOperation } 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<{

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

@@ -1,5 +1,5 @@
-import { AbiParameter } from 'abitype';
-import { AbiItem } from 'viem';
+import type { AbiParameter } from 'abitype';
+import { type AbiItem } from 'viem';
 export declare function formatAbiItem(abiItem: AbiItem, { includeName }?: {
     includeName?: boolean;
 }): string;

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

@@ -1,5 +1,5 @@
-import { Address, Hex } from 'viem';
-import { Chain, Operation, Signature, UserOperation } from '../data';
+import { type Address, type Hex } from 'viem';
+import { type Chain, type Operation, type Signature, type UserOperation } from '../data';
 export declare const generateRandomBytes32: () => Hex;
 export declare const generateRandomWalletUniqueId: () => Hex;
 export declare const generateRandomGroupId: () => Hex;