@crossmint/client-sdk-smart-wallet 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossmint/client-sdk-smart-wallet",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "repository": "https://github.com/Crossmint/crossmint-sdk",
   "license": "Apache-2.0",
   "author": "Paella Labs Inc",
@@ -26,8 +26,8 @@
     "permissionless": "0.1.36",
     "viem": "2.17.5",
     "zod": "3.22.4",
-    "@crossmint/common-sdk-base": "0.1.4",
-    "@crossmint/client-sdk-base": "1.2.6"
+    "@crossmint/client-sdk-base": "1.2.7",
+    "@crossmint/common-sdk-base": "0.1.4"
   },
   "devDependencies": {
     "typedoc": "0.26.5",

package/src/SmartWalletSDK.ts

@@ -1,15 +1,9 @@
 import { stringify } from "viem";
 
-import { APIKeyEnvironmentPrefix, validateAPIKey } from "@crossmint/common-sdk-base";
+import { type APIKeyEnvironmentPrefix, validateAPIKey } from "@crossmint/common-sdk-base";
 
 import { CrossmintWalletService } from "./api/CrossmintWalletService";
-import {
-    SMART_WALLET_MAINNETS,
-    SMART_WALLET_TESTNETS,
-    type SmartWalletChain,
-    isMainnetChain,
-    isTestnetChain,
-} from "./blockchain/chains";
+import { type SmartWalletChain, isMainnetChain, isTestnetChain } from "./blockchain/chains";
 import type { EVMSmartWallet } from "./blockchain/wallets";
 import { AccountConfigCache } from "./blockchain/wallets/account/cache";
 import { AccountConfigService } from "./blockchain/wallets/account/config";
@@ -80,7 +74,7 @@ export class SmartWalletSDK {
         }
         this.assertValidChain(chain);
 
-        return this.logger.logPerformance("GET_OR_CREATE_WALLET", async () => {
+        return await this.logger.logPerformance("GET_OR_CREATE_WALLET", async () => {
             try {
                 return await this.smartWalletService.getOrCreate(user, chain, walletParams);
             } catch (error: any) {

package/src/blockchain/chains.ts

@@ -1,5 +1,5 @@
 import {
-    Chain,
+    type Chain,
     arbitrum,
     arbitrumSepolia,
     base,
@@ -10,7 +10,7 @@ import {
     polygonAmoy,
 } from "viem/chains";
 
-import { BlockchainIncludingTestnet as Blockchain, ObjectValues, objectValues } from "@crossmint/common-sdk-base";
+import { BlockchainIncludingTestnet as Blockchain, type ObjectValues, objectValues } from "@crossmint/common-sdk-base";
 
 export const SmartWalletTestnet = {
     BASE_SEPOLIA: Blockchain.BASE_SEPOLIA,

package/src/blockchain/rpc.ts

@@ -1,6 +1,6 @@
 import { blockchainToChainId } from "@crossmint/common-sdk-base";
 
-import { SmartWalletChain } from "./chains";
+import type { SmartWalletChain } from "./chains";
 
 const ALCHEMY_API_KEY = "-7M6vRDBDknwvMxnqah_jbcieWg0qad9";
 const PIMLICO_API_KEY = "pim_9dKmQPxiTCvtbUNF7XFBbA";

package/src/blockchain/transfer.ts

@@ -1,4 +1,4 @@
-import { Abi, Account, Address, erc20Abi, erc721Abi } from "viem";
+import { type Abi, type Account, type Address, erc20Abi, erc721Abi } from "viem";
 
 import erc1155Abi from "../ABI/ERC1155.json";
 import type { ERC20TransferType, SFTTransferType, TransferType } from "../types/token";

package/src/blockchain/wallets/EVMSmartWallet.ts

@@ -1,24 +1,21 @@
-import {
+import type {
     Abi,
+    Address,
     ContractFunctionArgs,
     ContractFunctionName,
     Hex,
-    type HttpTransport,
-    type PublicClient,
+    HttpTransport,
+    PublicClient,
     WriteContractParameters,
-    isAddress,
-    publicActions,
 } from "viem";
 
-import { TransferError } from "@crossmint/client-sdk-base";
-
 import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
-import { scwLogger } from "../../services/logger";
-import { SmartWalletClient } from "../../types/internal";
+import { SmartWalletError } from "../../error";
+import type { SmartWalletClient } from "../../types/internal";
 import type { TransferType } from "../../types/token";
-import { SmartWalletChain } from "../chains";
+import type { SmartWalletChain } from "../chains";
 import { transferParams } from "../transfer";
-import { SendTransactionOptions, SendTransactionService } from "./SendTransactionService";
+import { type SendTransactionOptions, SendTransactionService } from "./SendTransactionService";
 
 /**
  * Smart wallet interface for EVM chains enhanced with Crossmint capabilities.
@@ -41,79 +38,47 @@ export class EVMSmartWallet {
          */
         public: PublicClient;
     };
-    private readonly sendTransactionService: SendTransactionService;
 
     constructor(
-        private readonly crossmintService: CrossmintWalletService,
-        private readonly accountClient: SmartWalletClient,
-        publicClient: PublicClient<HttpTransport>,
+        client: { public: PublicClient<HttpTransport>; wallet: SmartWalletClient },
         chain: SmartWalletChain,
-        protected readonly logger = scwLogger
+        private readonly crossmintService: CrossmintWalletService,
+        private readonly sendTransactionService = new SendTransactionService(client)
     ) {
         this.chain = chain;
-        this.client = {
-            wallet: accountClient,
-            public: publicClient,
-        };
-        this.sendTransactionService = new SendTransactionService(publicClient);
+        this.client = client;
     }
 
     /**
      * The address of the smart wallet.
      */
     public get address() {
-        return this.accountClient.account.address;
+        return this.client.wallet.account.address;
     }
 
     /**
+     * Transfers tokens from the smart wallet to a specified address.
+     * @param toAddress The recipient's address.
+     * @param config The transfer configuration, including token details and amount.
      * @returns The transaction hash.
+     * @throws {SmartWalletError} If there's a chain mismatch between this wallet and the input configuration.
+     * @throws {SendTransactionError} If the transaction fails to send. Contains the error thrown by the viem client.
+     * @throws {SendTransactionExecutionRevertedError} A subclass of SendTransactionError if the transaction fails due to a contract execution error.
      */
-    public async transferToken(toAddress: string, config: TransferType): Promise<string> {
-        return this.logger.logPerformance(
-            "TRANSFER",
-            async () => {
-                if (this.chain !== config.token.chain) {
-                    throw new Error(
-                        `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
-                    );
-                }
-
-                if (!isAddress(toAddress)) {
-                    throw new Error(`Invalid recipient address: '${toAddress}' is not a valid EVM address.`);
-                }
-
-                if (!isAddress(config.token.contractAddress)) {
-                    throw new Error(
-                        `Invalid contract address: '${config.token.contractAddress}' is not a valid EVM address.`
-                    );
-                }
+    public async transferToken(toAddress: Address, config: TransferType): Promise<string> {
+        if (this.chain !== config.token.chain) {
+            throw new SmartWalletError(
+                `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
+            );
+        }
 
-                const tx = transferParams({
-                    contract: config.token.contractAddress,
-                    to: toAddress,
-                    from: this.accountClient.account,
-                    config,
-                });
-
-                try {
-                    const client = this.accountClient.extend(publicActions);
-                    const { request } = await client.simulateContract(tx);
-                    const hash = await client.writeContract(request);
-                    this.logger.log(`[TRANSFER] - Transaction hash from transfer: ${hash}`);
-
-                    return hash;
-                } catch (error) {
-                    this.logger.error("[TRANSFER] - ERROR_TRANSFERRING_TOKEN", {
-                        error: error instanceof Error ? error.message : JSON.stringify(error),
-                        tokenId: tx.tokenId,
-                        contractAddress: config.token.contractAddress,
-                        chain: config.token.chain,
-                    });
-                    const tokenIdString = tx.tokenId == null ? "" : `:${tx.tokenId}}`;
-                    throw new TransferError(`Error transferring token ${config.token.contractAddress}${tokenIdString}`);
-                }
-            },
-            { toAddress, config }
+        return this.executeContract(
+            transferParams({
+                contract: config.token.contractAddress,
+                to: toAddress,
+                from: this.client.wallet.account,
+                config,
+            })
         );
     }
 
@@ -167,7 +132,7 @@ export class EVMSmartWallet {
             TAbi,
             "nonpayable" | "payable",
             TFunctionName
-        >
+        >,
     >({
         address,
         abi,
@@ -186,7 +151,6 @@ export class EVMSmartWallet {
                 args,
                 value,
             },
-            this.accountClient,
             config
         );
     }

package/src/blockchain/wallets/SendTransactionService.test.ts

@@ -1,14 +1,15 @@
-import { SmartAccountClient } from "permissionless";
-import { SmartAccount } from "permissionless/accounts";
-import { EntryPoint } from "permissionless/types";
+import type { SmartAccountClient } from "permissionless";
+import type { SmartAccount } from "permissionless/accounts";
+import type { EntryPoint } from "permissionless/types";
 import {
+    type Address,
     BaseError,
-    Chain,
+    type Chain,
     ContractFunctionRevertedError,
-    PublicClient,
-    SimulateContractReturnType,
-    TransactionReceipt,
-    Transport,
+    type PublicClient,
+    type SimulateContractReturnType,
+    type TransactionReceipt,
+    type Transport,
     zeroAddress,
 } from "viem";
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -27,9 +28,13 @@ function makeMockError<E extends Error, F extends object>(error: E, fields?: F):
 }
 
 describe("SendTransactionService", () => {
+    const walletAddress: Address = "0xE898BBd704CCE799e9593a9ADe2c1cA0351Ab660";
+    const mockSmartAccount = mock<SmartAccount<EntryPoint>>({ address: walletAddress });
     const mockPublicClient = mock<PublicClient>();
-    const mockAccountClient = mock<SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>>();
-    const sendTransactionService = new SendTransactionService(mockPublicClient);
+    const mockAccountClient = mock<SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>>({
+        account: mockSmartAccount,
+    });
+    const sendTransactionService = new SendTransactionService({ public: mockPublicClient, wallet: mockAccountClient });
 
     beforeEach(() => {
         vi.resetAllMocks();
@@ -49,15 +54,12 @@ describe("SendTransactionService", () => {
         mockPublicClient.simulateContract.mockRejectedValue(mockError);
         let rejected = false;
         try {
-            await sendTransactionService.sendTransaction(
-                {
-                    address: zeroAddress,
-                    abi: [],
-                    functionName: "mockFunction",
-                    args: [],
-                },
-                mockAccountClient
-            );
+            await sendTransactionService.sendTransaction({
+                address: zeroAddress,
+                abi: [],
+                functionName: "mockFunction",
+                args: [],
+            });
         } catch (e) {
             rejected = true;
             expect(e).toBeInstanceOf(EVMSendTransactionExecutionRevertedError);
@@ -74,15 +76,12 @@ describe("SendTransactionService", () => {
         mockPublicClient.waitForTransactionReceipt.mockResolvedValueOnce(mockReceipt);
         let rejected = false;
         try {
-            await sendTransactionService.sendTransaction(
-                {
-                    address: zeroAddress,
-                    abi: [],
-                    functionName: "mockFunction",
-                    args: [],
-                },
-                mockAccountClient
-            );
+            await sendTransactionService.sendTransaction({
+                address: zeroAddress,
+                abi: [],
+                functionName: "mockFunction",
+                args: [],
+            });
         } catch (e) {
             rejected = true;
             expect(e).toBeInstanceOf(EVMSendTransactionExecutionRevertedError);
@@ -96,15 +95,12 @@ describe("SendTransactionService", () => {
         mockPublicClient.waitForTransactionReceipt.mockRejectedValue(mockError);
         let rejected = false;
         try {
-            await sendTransactionService.sendTransaction(
-                {
-                    address: zeroAddress,
-                    abi: [],
-                    functionName: "mockFunction",
-                    args: [],
-                },
-                mockAccountClient
-            );
+            await sendTransactionService.sendTransaction({
+                address: zeroAddress,
+                abi: [],
+                functionName: "mockFunction",
+                args: [],
+            });
         } catch (e) {
             rejected = true;
             expect(e).toBeInstanceOf(EVMSendTransactionError);
@@ -118,15 +114,12 @@ describe("SendTransactionService", () => {
         mockAccountClient.writeContract.mockRejectedValue(mockError);
         let rejected = false;
         try {
-            await sendTransactionService.sendTransaction(
-                {
-                    address: zeroAddress,
-                    abi: [],
-                    functionName: "mockFunction",
-                    args: [],
-                },
-                mockAccountClient
-            );
+            await sendTransactionService.sendTransaction({
+                address: zeroAddress,
+                abi: [],
+                functionName: "mockFunction",
+                args: [],
+            });
         } catch (e) {
             rejected = true;
             expect(e).toBeInstanceOf(EVMSendTransactionError);
@@ -148,16 +141,19 @@ describe("SendTransactionService", () => {
             return "0xmockTxHash";
         });
         await expect(
-            sendTransactionService.sendTransaction(
-                {
-                    address: zeroAddress,
-                    abi: [],
-                    functionName: "mockFunction",
-                    args: [],
-                },
-                mockAccountClient
-            )
+            sendTransactionService.sendTransaction({
+                address: zeroAddress,
+                abi: [],
+                functionName: "mockFunction",
+                args: [],
+            })
         ).resolves.toBeDefined();
         expect(callOrder).toEqual(["simulateContract", "sendTransaction"]);
+
+        expect(mockPublicClient.simulateContract).toHaveBeenCalledWith(
+            expect.objectContaining({
+                account: walletAddress,
+            })
+        );
     });
 });

package/src/blockchain/wallets/SendTransactionService.ts

@@ -87,8 +87,11 @@ export interface SendTransactionOptions {
 
 export class SendTransactionService {
     constructor(
-        private publicClient: PublicClient,
-        private defaultSendTransactionOptions: SendTransactionOptions = {
+        private readonly client: {
+            public: PublicClient;
+            wallet: SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>;
+        },
+        private readonly defaultSendTransactionOptions: SendTransactionOptions = {
             confirmations: 2,
             transactionConfirmationTimeout: 30_000,
         }
@@ -96,7 +99,6 @@ export class SendTransactionService {
 
     async sendTransaction(
         request: TransactionServiceTransactionRequest,
-        client: SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>,
         config: Partial<SendTransactionOptions> = {}
     ): Promise<Hex> {
         const { confirmations, transactionConfirmationTimeout } = this.getConfig(config);
@@ -105,10 +107,10 @@ export class SendTransactionService {
 
         let hash;
         try {
-            hash = await client.writeContract({
+            hash = await this.client.wallet.writeContract({
                 ...request,
-                account: client.account,
-                chain: client.chain,
+                account: this.client.wallet.account,
+                chain: this.client.wallet.chain,
             });
         } catch (e) {
             if (e instanceof BaseError) {
@@ -118,7 +120,7 @@ export class SendTransactionService {
         }
 
         try {
-            const receipt = await this.publicClient.waitForTransactionReceipt({
+            const receipt = await this.client.public.waitForTransactionReceipt({
                 hash,
                 confirmations,
                 timeout: transactionConfirmationTimeout,
@@ -161,10 +163,10 @@ export class SendTransactionService {
         stage: SendTransactionFailureStage
     ) {
         try {
-            await this.publicClient.simulateContract({
+            await this.client.public.simulateContract({
                 ...request,
-                account: request.address,
-                chain: this.publicClient.chain,
+                account: this.client.wallet.account.address,
+                chain: this.client.public.chain,
             });
         } catch (e) {
             if (e instanceof BaseError) {

package/src/blockchain/wallets/account/cache.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { UserParams } from "../../../types/params";
+import type { UserParams } from "../../../types/params";
 import { mockConfig } from "../../../utils/test";
 import { AccountConfigCache } from "./cache";
 

package/src/blockchain/wallets/account/cache.ts

@@ -1,6 +1,6 @@
 import { keccak256, toHex } from "viem";
 
-import { UserParams } from "../../../types/params";
+import type { UserParams } from "../../../types/params";
 import { SmartWalletConfigSchema } from "../../../types/schema";
 import type { SmartWalletConfig } from "../../../types/service";
 

package/src/blockchain/wallets/account/config.test.ts

@@ -1,11 +1,11 @@
 import { beforeEach, describe, expect, it } from "vitest";
 import { mock } from "vitest-mock-extended";
 
-import { CrossmintWalletService } from "../../../api/CrossmintWalletService";
-import { SmartWalletConfig } from "../../../types/service";
+import type { CrossmintWalletService } from "../../../api/CrossmintWalletService";
+import type { SmartWalletConfig } from "../../../types/service";
 import { mockConfig } from "../../../utils/test";
 import { SmartWalletChain } from "../../chains";
-import { AccountConfigCache } from "./cache";
+import type { AccountConfigCache } from "./cache";
 import { AccountConfigService } from "./config";
 import { PasskeySignerConfig } from "./signer";
 

package/src/blockchain/wallets/account/config.ts

@@ -8,7 +8,7 @@ import type {
 } from "../../../types/internal";
 import type { UserParams } from "../../../types/params";
 import type { SignerData, SmartWalletConfig } from "../../../types/service";
-import { AccountConfigCache } from "./cache";
+import type { AccountConfigCache } from "./cache";
 import { EOASignerConfig, PasskeySignerConfig, type SignerConfig } from "./signer";
 
 interface AccountConfig {

package/src/blockchain/wallets/account/creator.ts

@@ -6,8 +6,8 @@ import {
     isPasskeyCreationContext,
     isPasskeyWalletParams,
 } from "../../../types/internal";
-import { EOACreationStrategy } from "./eoa";
-import { PasskeyCreationStrategy } from "./passkey";
+import type { EOACreationStrategy } from "./eoa";
+import type { PasskeyCreationStrategy } from "./passkey";
 
 export class AccountCreator {
     constructor(

package/src/blockchain/wallets/account/eoa.ts

@@ -6,7 +6,7 @@ import type { AccountAndSigner, EOACreationContext } from "../../../types/intern
 import { equalsIgnoreCase } from "../../../utils/helpers";
 import { createOwnerSigner } from "../../../utils/signer";
 import { EOASignerConfig } from "./signer";
-import { AccountCreationStrategy } from "./strategy";
+import type { AccountCreationStrategy } from "./strategy";
 
 export class EOACreationStrategy implements AccountCreationStrategy {
     public async create({

package/src/blockchain/wallets/account/passkey.ts

@@ -14,13 +14,16 @@ import type { AccountAndSigner, PasskeyCreationContext } from "../../../types/in
 import type { UserParams } from "../../../types/params";
 import type { PasskeySignerData, PasskeyValidatorSerializedData } from "../../../types/service";
 import { PasskeySignerConfig } from "./signer";
-import { AccountCreationStrategy } from "./strategy";
+import type { AccountCreationStrategy } from "./strategy";
 
 type PasskeyValidator = KernelValidator<EntryPoint, "WebAuthnValidator"> & {
     getSerializedData: () => string;
 };
 export class PasskeyCreationStrategy implements AccountCreationStrategy {
-    constructor(private readonly passkeyServerUrl: string, private readonly apiKey: string) {}
+    constructor(
+        private readonly passkeyServerUrl: string,
+        private readonly apiKey: string
+    ) {}
 
     public async create({
         user,

package/src/blockchain/wallets/account/strategy.ts

@@ -1,4 +1,4 @@
-import { AccountAndSigner, WalletCreationContext } from "../../../types/internal";
+import type { AccountAndSigner, WalletCreationContext } from "../../../types/internal";
 
 export interface AccountCreationStrategy {
     create(params: WalletCreationContext): Promise<AccountAndSigner>;

package/src/blockchain/wallets/clientDecorator.ts

@@ -3,10 +3,10 @@ import type { EntryPoint } from "permissionless/types/entrypoint";
 import { stringify } from "viem";
 
 import { SmartWalletError } from "../../error";
-import { ErrorProcessor } from "../../error/processor";
+import type { ErrorProcessor } from "../../error/processor";
 import { scwLogger } from "../../services";
 import { usesGelatoBundler } from "../../utils/blockchain";
-import { SmartWalletChain } from "../chains";
+import type { SmartWalletChain } from "../chains";
 
 const transactionMethods = [
     "sendTransaction",
@@ -37,7 +37,10 @@ function isSignMethod(method: string): method is SignMethod {
  * - Automatic formatting of transactions for Gelato bundler compatibility.
  *  */
 export class ClientDecorator {
-    constructor(private readonly errorProcessor: ErrorProcessor, protected logger = scwLogger) {}
+    constructor(
+        private readonly errorProcessor: ErrorProcessor,
+        protected logger = scwLogger
+    ) {}
 
     public decorate<Client extends SmartAccountClient<EntryPoint>>({
         crossmintChain,
@@ -69,7 +72,6 @@ export class ClientDecorator {
     private async execute<M extends TxnMethod | SignMethod>(
         target: SmartAccountClient<EntryPoint>,
         prop: M,
-        // eslint-disable-next-line @typescript-eslint/ban-types
         originalMethod: Function,
         args: any[],
         crossmintChain: SmartWalletChain

package/src/blockchain/wallets/paymaster.ts

@@ -1,11 +1,11 @@
-import { CrossmintWalletService } from "@/api/CrossmintWalletService";
-import { Middleware } from "permissionless/actions/smartAccount";
-import { PimlicoBundlerClient } from "permissionless/clients/pimlico";
-import { EntryPoint } from "permissionless/types/entrypoint";
+import type { CrossmintWalletService } from "@/api/CrossmintWalletService";
+import type { Middleware } from "permissionless/actions/smartAccount";
+import type { PimlicoBundlerClient } from "permissionless/clients/pimlico";
+import type { EntryPoint } from "permissionless/types/entrypoint";
 
-import { UserParams } from "../../types/params";
+import type { UserParams } from "../../types/params";
 import { usesGelatoBundler } from "../../utils/blockchain";
-import { SmartWalletChain } from "../chains";
+import type { SmartWalletChain } from "../chains";
 
 export function usePaymaster(chain: SmartWalletChain) {
     return !usesGelatoBundler(chain);

package/src/blockchain/wallets/service.ts

@@ -1,8 +1,8 @@
-import { KernelSmartAccount } from "@zerodev/sdk";
+import type { KernelSmartAccount } from "@zerodev/sdk";
 import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, createSmartAccountClient } from "permissionless";
 import { createPimlicoBundlerClient } from "permissionless/clients/pimlico";
-import { EntryPoint } from "permissionless/types/entrypoint";
-import { HttpTransport, createPublicClient, http } from "viem";
+import type { EntryPoint } from "permissionless/types/entrypoint";
+import { type HttpTransport, createPublicClient, http } from "viem";
 
 import { blockchainToChainId } from "@crossmint/common-sdk-base";
 
@@ -71,10 +71,9 @@ export class SmartWalletService {
         }
 
         return new EVMSmartWallet(
-            this.crossmintService,
-            this.smartAccountClient(chain, account, user),
-            publicClient,
-            chain
+            { wallet: this.smartAccountClient(chain, account, user), public: publicClient },
+            chain,
+            this.crossmintService
         );
     }
 

package/src/error/index.ts

@@ -1,6 +1,6 @@
 import { CrossmintSDKError, SmartWalletErrorCode } from "@crossmint/client-sdk-base";
 
-import { PasskeyDisplay, SignerDisplay } from "../types/service";
+import type { PasskeyDisplay, SignerDisplay } from "../types/service";
 
 export class SmartWalletError extends CrossmintSDKError {
     constructor(message: string, details?: string, code: SmartWalletErrorCode = SmartWalletErrorCode.UNCATEGORIZED) {

package/src/error/processor.ts

@@ -1,6 +1,6 @@
 import { BaseError, stringify } from "viem";
 
-import { SDKLogger } from "@crossmint/client-sdk-base";
+import type { SDKLogger } from "@crossmint/client-sdk-base";
 
 import { SmartWalletError } from ".";
 import { SDK_VERSION } from "../utils/constants";

package/src/index.ts

@@ -37,7 +37,6 @@ export {
     SmartWalletErrorCode,
     CrossmintSDKError,
     CrossmintServiceError,
-    TransferError,
     JWTDecryptionError,
     JWTExpiredError,
     JWTIdentifierError,