@crossmint/wallets-sdk 0.18.14 → 0.19.0

package/dist/api/__tests__/test-utils.d.cts

@@ -0,0 +1,99 @@
+import { MockedFunction } from 'vitest';
+import { Crossmint } from '@crossmint/common-sdk-base';
+import { ApiClient } from '../client.cjs';
+import { CreateWalletResponse, SendResponse, CreateWalletParams, WalletLocator, FundWalletResponse, GetTransactionResponse } from '../types.cjs';
+import '../../chains/chains.cjs';
+import 'viem';
+import '../gen/types.gen.cjs';
+
+type MockResponseOptions<T> = {
+    data: T;
+    status?: number;
+    ok?: boolean;
+    statusText?: string;
+};
+type FetchCallInfo = {
+    path: string;
+    options: RequestInit;
+};
+declare const createMockResponse: <T>({ data, status, ok, statusText, }: MockResponseOptions<T>) => Response;
+declare const createMockSuccessResponse: <T>(data: T) => Response;
+declare const createMockErrorResponse: <T>(data: T, status?: number, statusText?: string) => Response;
+declare const createMockCrossmint: (overrides?: Partial<Crossmint>) => Crossmint;
+declare const createTestApiClient: (crossmint?: Crossmint) => ApiClient;
+declare const createServerSideApiClient: () => ApiClient;
+declare const extractFetchCall: (mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => FetchCallInfo | undefined;
+declare const expectRequestPath: (call: FetchCallInfo | undefined, expectedPath: string) => void;
+declare const expectCommonHeaders: (headers: HeadersInit) => void;
+declare const expectRequestBody: (options: RequestInit, expectedBody: unknown) => void;
+declare const validateRequest: (call: FetchCallInfo | undefined, expectedPath: string, expectedBody?: unknown) => void;
+declare const testHttpErrorResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, errorData: {
+    error: boolean;
+    message?: string;
+}, statusCode: number) => Promise<void>;
+declare const testCommonHttpErrors: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, skipStatuses?: number[]) => Promise<void>;
+declare const testNetworkError: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testInvalidJsonResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testTimeoutError: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testMalformedResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, malformedData: unknown) => Promise<void>;
+declare const createMockWalletResponse: (overrides?: Partial<CreateWalletResponse>) => CreateWalletResponse;
+declare const createMockSendResponse: (overrides?: Partial<SendResponse>) => SendResponse;
+interface ErrorResponse {
+    error: true;
+    message?: string;
+    details?: unknown;
+}
+interface SuccessWalletResponse {
+    address: string;
+    chainType: string;
+    type: string;
+    config?: {
+        adminSigner?: {
+            type: string;
+            address: string;
+        };
+    };
+}
+interface SuccessTransactionResponse {
+    id: string;
+    status: string;
+    chainType: string;
+}
+declare function isErrorResponse(response: unknown): response is ErrorResponse;
+declare function isSuccessWalletResponse(response: unknown): response is SuccessWalletResponse;
+declare function isSuccessTransactionResponse(response: unknown): response is SuccessTransactionResponse;
+declare const delay: (ms: number) => Promise<unknown>;
+declare const isValidEthereumAddress: (address: string) => boolean;
+declare const isValidSolanaAddress: (address: string) => boolean;
+/**
+ * Creates an API client for integration tests using environment variables.
+ * This is different from createTestApiClient which uses mocked data.
+ */
+declare const createIntegrationApiClient: (apiKey: string, baseUrl?: string, overrides?: Partial<Crossmint>) => ApiClient;
+declare class TestDataFactory {
+    private wallets;
+    private transactions;
+    addWallet(address: string): void;
+    addTransaction(id: string): void;
+    getWallet(index?: number): string | undefined;
+    getTransaction(index?: number): string | undefined;
+    hasWallets(): boolean;
+    clear(): void;
+}
+declare function ensureWalletExists(apiClient: ApiClient, testData: TestDataFactory, options?: {
+    chainType?: "evm" | "solana";
+    type?: "mpc" | "smart";
+    owner?: string;
+    testName?: string;
+}): Promise<string | undefined>;
+declare function createTestWallet(apiClient: ApiClient, testData: TestDataFactory, params: CreateWalletParams): Promise<CreateWalletResponse>;
+declare function expectErrorResponse(response: unknown, message?: string): asserts response is ErrorResponse;
+declare function expectSuccessWalletResponse(response: unknown): asserts response is SuccessWalletResponse;
+declare function expectSuccessTransactionResponse(response: unknown): asserts response is SuccessTransactionResponse;
+declare const fundWallet: (apiClient: ApiClient, walletLocator: WalletLocator, amount: number, token?: "usdc" | "usdxm", chain?: string) => Promise<FundWalletResponse>;
+declare const approveTransaction: (apiClient: ApiClient, walletLocator: WalletLocator, transactionId: string, maxRetries?: number) => Promise<GetTransactionResponse>;
+declare const fundWalletAndWait: (apiClient: ApiClient, walletLocator: WalletLocator, amount?: number, token?: "usdc" | "usdxm", chain?: string) => Promise<FundWalletResponse>;
+declare const sendTokenAndApprove: (apiClient: ApiClient, walletLocator: WalletLocator, tokenLocator: string, recipient: string, amount: string) => Promise<GetTransactionResponse>;
+declare const ensureWalletFunded: (apiClient: ApiClient, walletLocator: WalletLocator, amount?: number, token?: "usdc" | "usdxm", chain?: string) => Promise<void>;
+
+export { type ErrorResponse, type FetchCallInfo, type MockResponseOptions, type SuccessTransactionResponse, type SuccessWalletResponse, TestDataFactory, approveTransaction, createIntegrationApiClient, createMockCrossmint, createMockErrorResponse, createMockResponse, createMockSendResponse, createMockSuccessResponse, createMockWalletResponse, createServerSideApiClient, createTestApiClient, createTestWallet, delay, ensureWalletExists, ensureWalletFunded, expectCommonHeaders, expectErrorResponse, expectRequestBody, expectRequestPath, expectSuccessTransactionResponse, expectSuccessWalletResponse, extractFetchCall, fundWallet, fundWalletAndWait, isErrorResponse, isSuccessTransactionResponse, isSuccessWalletResponse, isValidEthereumAddress, isValidSolanaAddress, sendTokenAndApprove, testCommonHttpErrors, testHttpErrorResponse, testInvalidJsonResponse, testMalformedResponse, testNetworkError, testTimeoutError, validateRequest };

package/dist/api/__tests__/test-utils.d.ts

@@ -0,0 +1,99 @@
+import { MockedFunction } from 'vitest';
+import { Crossmint } from '@crossmint/common-sdk-base';
+import { ApiClient } from '../client.js';
+import { CreateWalletResponse, SendResponse, CreateWalletParams, WalletLocator, FundWalletResponse, GetTransactionResponse } from '../types.js';
+import '../../chains/chains.js';
+import 'viem';
+import '../gen/types.gen.js';
+
+type MockResponseOptions<T> = {
+    data: T;
+    status?: number;
+    ok?: boolean;
+    statusText?: string;
+};
+type FetchCallInfo = {
+    path: string;
+    options: RequestInit;
+};
+declare const createMockResponse: <T>({ data, status, ok, statusText, }: MockResponseOptions<T>) => Response;
+declare const createMockSuccessResponse: <T>(data: T) => Response;
+declare const createMockErrorResponse: <T>(data: T, status?: number, statusText?: string) => Response;
+declare const createMockCrossmint: (overrides?: Partial<Crossmint>) => Crossmint;
+declare const createTestApiClient: (crossmint?: Crossmint) => ApiClient;
+declare const createServerSideApiClient: () => ApiClient;
+declare const extractFetchCall: (mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => FetchCallInfo | undefined;
+declare const expectRequestPath: (call: FetchCallInfo | undefined, expectedPath: string) => void;
+declare const expectCommonHeaders: (headers: HeadersInit) => void;
+declare const expectRequestBody: (options: RequestInit, expectedBody: unknown) => void;
+declare const validateRequest: (call: FetchCallInfo | undefined, expectedPath: string, expectedBody?: unknown) => void;
+declare const testHttpErrorResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, errorData: {
+    error: boolean;
+    message?: string;
+}, statusCode: number) => Promise<void>;
+declare const testCommonHttpErrors: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, skipStatuses?: number[]) => Promise<void>;
+declare const testNetworkError: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testInvalidJsonResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testTimeoutError: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>) => Promise<void>;
+declare const testMalformedResponse: <T>(apiCall: () => Promise<T>, mockFn: MockedFunction<any> | MockedFunction<ApiClient["post"]> | MockedFunction<ApiClient["get"]>, malformedData: unknown) => Promise<void>;
+declare const createMockWalletResponse: (overrides?: Partial<CreateWalletResponse>) => CreateWalletResponse;
+declare const createMockSendResponse: (overrides?: Partial<SendResponse>) => SendResponse;
+interface ErrorResponse {
+    error: true;
+    message?: string;
+    details?: unknown;
+}
+interface SuccessWalletResponse {
+    address: string;
+    chainType: string;
+    type: string;
+    config?: {
+        adminSigner?: {
+            type: string;
+            address: string;
+        };
+    };
+}
+interface SuccessTransactionResponse {
+    id: string;
+    status: string;
+    chainType: string;
+}
+declare function isErrorResponse(response: unknown): response is ErrorResponse;
+declare function isSuccessWalletResponse(response: unknown): response is SuccessWalletResponse;
+declare function isSuccessTransactionResponse(response: unknown): response is SuccessTransactionResponse;
+declare const delay: (ms: number) => Promise<unknown>;
+declare const isValidEthereumAddress: (address: string) => boolean;
+declare const isValidSolanaAddress: (address: string) => boolean;
+/**
+ * Creates an API client for integration tests using environment variables.
+ * This is different from createTestApiClient which uses mocked data.
+ */
+declare const createIntegrationApiClient: (apiKey: string, baseUrl?: string, overrides?: Partial<Crossmint>) => ApiClient;
+declare class TestDataFactory {
+    private wallets;
+    private transactions;
+    addWallet(address: string): void;
+    addTransaction(id: string): void;
+    getWallet(index?: number): string | undefined;
+    getTransaction(index?: number): string | undefined;
+    hasWallets(): boolean;
+    clear(): void;
+}
+declare function ensureWalletExists(apiClient: ApiClient, testData: TestDataFactory, options?: {
+    chainType?: "evm" | "solana";
+    type?: "mpc" | "smart";
+    owner?: string;
+    testName?: string;
+}): Promise<string | undefined>;
+declare function createTestWallet(apiClient: ApiClient, testData: TestDataFactory, params: CreateWalletParams): Promise<CreateWalletResponse>;
+declare function expectErrorResponse(response: unknown, message?: string): asserts response is ErrorResponse;
+declare function expectSuccessWalletResponse(response: unknown): asserts response is SuccessWalletResponse;
+declare function expectSuccessTransactionResponse(response: unknown): asserts response is SuccessTransactionResponse;
+declare const fundWallet: (apiClient: ApiClient, walletLocator: WalletLocator, amount: number, token?: "usdc" | "usdxm", chain?: string) => Promise<FundWalletResponse>;
+declare const approveTransaction: (apiClient: ApiClient, walletLocator: WalletLocator, transactionId: string, maxRetries?: number) => Promise<GetTransactionResponse>;
+declare const fundWalletAndWait: (apiClient: ApiClient, walletLocator: WalletLocator, amount?: number, token?: "usdc" | "usdxm", chain?: string) => Promise<FundWalletResponse>;
+declare const sendTokenAndApprove: (apiClient: ApiClient, walletLocator: WalletLocator, tokenLocator: string, recipient: string, amount: string) => Promise<GetTransactionResponse>;
+declare const ensureWalletFunded: (apiClient: ApiClient, walletLocator: WalletLocator, amount?: number, token?: "usdc" | "usdxm", chain?: string) => Promise<void>;
+
+export { type ErrorResponse, type FetchCallInfo, type MockResponseOptions, type SuccessTransactionResponse, type SuccessWalletResponse, TestDataFactory, approveTransaction, createIntegrationApiClient, createMockCrossmint, createMockErrorResponse, createMockResponse, createMockSendResponse, createMockSuccessResponse, createMockWalletResponse, createServerSideApiClient, createTestApiClient, createTestWallet, delay, ensureWalletExists, ensureWalletFunded, expectCommonHeaders, expectErrorResponse, expectRequestBody, expectRequestPath, expectSuccessTransactionResponse, expectSuccessWalletResponse, extractFetchCall, fundWallet, fundWalletAndWait, isErrorResponse, isSuccessTransactionResponse, isSuccessWalletResponse, isValidEthereumAddress, isValidSolanaAddress, sendTokenAndApprove, testCommonHttpErrors, testHttpErrorResponse, testInvalidJsonResponse, testMalformedResponse, testNetworkError, testTimeoutError, validateRequest };

package/dist/api/__tests__/test-utils.js

@@ -0,0 +1,372 @@
+import {
+  DELAY_LONG,
+  DELAY_RATE_LIMIT_WINDOW,
+  HTTP_ERROR_STATUSES,
+  MOCK_API_KEY,
+  TEST_ADDRESSES,
+  TEST_VALUES,
+  WALLET_LOCATORS
+} from "../../chunk-PJOJIRTY.js";
+import {
+  ApiClient
+} from "../../chunk-6EP3PLGP.js";
+import "../../chunk-SGINWAB6.js";
+import "../../chunk-S2AKC2CK.js";
+import "../../chunk-KE6LX37B.js";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-ASE2FXWP.js";
+
+// src/api/__tests__/test-utils.ts
+import { expect, vi } from "vitest";
+var createMockResponse = ({
+  data,
+  status = 200,
+  ok = true,
+  statusText = "OK"
+}) => {
+  return {
+    json: vi.fn().mockResolvedValue(data),
+    ok,
+    status,
+    statusText
+  };
+};
+var createMockSuccessResponse = (data) => createMockResponse({ data });
+var createMockErrorResponse = (data, status = 400, statusText = "Bad Request") => createMockResponse({ data, status, ok: false, statusText });
+var createMockCrossmint = (overrides = {}) => {
+  const base = __spreadValues({
+    apiKey: MOCK_API_KEY
+  }, overrides);
+  return __spreadProps(__spreadValues({}, base), {
+    setJwt: vi.fn().mockReturnThis(),
+    experimental_setCustomAuth: vi.fn().mockReturnThis()
+  });
+};
+var createTestApiClient = (crossmint) => {
+  return new ApiClient(crossmint || createMockCrossmint());
+};
+var createServerSideApiClient = () => {
+  const apiClient = createTestApiClient();
+  Object.defineProperty(apiClient, "isServerSide", {
+    get: () => true,
+    configurable: true
+  });
+  return apiClient;
+};
+var extractFetchCall = (mockFn) => {
+  const calls = mockFn.mock.calls;
+  if (calls.length === 0) {
+    return void 0;
+  }
+  const lastCall = calls[calls.length - 1];
+  return {
+    path: lastCall[0],
+    options: lastCall[1]
+  };
+};
+var expectRequestPath = (call, expectedPath) => {
+  expect(call == null ? void 0 : call.path).toBe(expectedPath);
+};
+var expectCommonHeaders = (headers) => {
+  const headerObj = headers;
+  expect(headerObj["Content-Type"]).toBe("application/json");
+};
+var expectRequestBody = (options, expectedBody) => {
+  expect(options.body).toBe(JSON.stringify(expectedBody));
+};
+var validateRequest = (call, expectedPath, expectedBody) => {
+  expect(call).toBeDefined();
+  if (!call) {
+    return;
+  }
+  expectRequestPath(call, expectedPath);
+  if (call.options.headers) {
+    expectCommonHeaders(call.options.headers);
+  }
+  if (expectedBody !== void 0 && call.options) {
+    expectRequestBody(call.options, expectedBody);
+  }
+};
+var testHttpErrorResponse = (apiCall, mockFn, errorData, statusCode) => __async(void 0, null, function* () {
+  mockFn.mockResolvedValue(createMockErrorResponse(errorData, statusCode));
+  const result = yield apiCall();
+  expect(isErrorResponse(result)).toBe(true);
+  if (isErrorResponse(result)) {
+    expect(result.error).toBe(true);
+    if (errorData.message) {
+      expect(result.message).toBe(errorData.message);
+    }
+  }
+});
+var testCommonHttpErrors = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (apiCall, mockFn, skipStatuses = []) {
+  for (const { status, message } of HTTP_ERROR_STATUSES) {
+    if (skipStatuses.includes(status)) {
+      continue;
+    }
+    const errorResponse = { error: true, message };
+    mockFn.mockResolvedValueOnce(createMockErrorResponse(errorResponse, status));
+    const result = yield apiCall();
+    expect(isErrorResponse(result)).toBe(true);
+  }
+});
+var testNetworkError = (apiCall, mockFn) => __async(void 0, null, function* () {
+  mockFn.mockRejectedValue(new Error("Network error"));
+  yield expect(apiCall()).rejects.toThrow("Network error");
+});
+var testInvalidJsonResponse = (apiCall, mockFn) => __async(void 0, null, function* () {
+  const mockResponse = {
+    json: vi.fn().mockRejectedValue(new Error("Invalid JSON")),
+    ok: true,
+    status: 200
+  };
+  mockFn.mockResolvedValue(mockResponse);
+  yield expect(apiCall()).rejects.toThrow();
+});
+var testTimeoutError = (apiCall, mockFn) => __async(void 0, null, function* () {
+  mockFn.mockImplementation(
+    () => new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), 0))
+  );
+  yield expect(apiCall()).rejects.toThrow("Request timeout");
+});
+var testMalformedResponse = (apiCall, mockFn, malformedData) => __async(void 0, null, function* () {
+  mockFn.mockResolvedValue(createMockSuccessResponse(malformedData));
+  const result = yield apiCall();
+  expect(result).toEqual(malformedData);
+});
+var createMockWalletResponse = (overrides = {}) => __spreadValues({
+  address: WALLET_LOCATORS.evmAddress,
+  chainType: "evm",
+  type: "smart",
+  config: {
+    adminSigner: {
+      type: "external-wallet",
+      address: TEST_ADDRESSES.EVM_TEST
+    }
+  }
+}, overrides);
+var createMockSendResponse = (overrides = {}) => __spreadValues({
+  id: "txn-123",
+  status: "pending",
+  chainType: "evm",
+  walletType: "evm-smart-wallet",
+  params: {
+    transaction: "0x1234567890abcdef",
+    signer: "api-key:test"
+  },
+  onChain: {
+    txId: "0xabcdef1234567890abcdef1234567890abcdef12",
+    explorerLink: "https://explorer.example.com/tx/0xabcdef1234567890abcdef1234567890abcdef12"
+  },
+  createdAt: Date.now()
+}, overrides);
+function isErrorResponse(response) {
+  return typeof response === "object" && response !== null && "error" in response && response.error === true;
+}
+function isSuccessWalletResponse(response) {
+  return typeof response === "object" && response !== null && "address" in response && "chainType" in response && "type" in response;
+}
+function isSuccessTransactionResponse(response) {
+  return typeof response === "object" && response !== null && "id" in response && "status" in response && "chainType" in response;
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isValidEthereumAddress = (address) => {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+};
+var isValidSolanaAddress = (address) => {
+  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+};
+var createIntegrationApiClient = (apiKey, baseUrl, overrides = {}) => {
+  const base = __spreadValues(__spreadValues({
+    apiKey
+  }, baseUrl && { overrideBaseUrl: baseUrl }), overrides);
+  const crossmint = __spreadProps(__spreadValues({}, base), {
+    setJwt: () => crossmint,
+    experimental_setCustomAuth: () => crossmint
+  });
+  return new ApiClient(crossmint);
+};
+var TestDataFactory = class {
+  constructor() {
+    this.wallets = [];
+    this.transactions = [];
+  }
+  addWallet(address) {
+    if (address && !this.wallets.includes(address)) {
+      this.wallets.push(address);
+    }
+  }
+  addTransaction(id) {
+    if (id && !this.transactions.includes(id)) {
+      this.transactions.push(id);
+    }
+  }
+  getWallet(index = 0) {
+    return this.wallets[index];
+  }
+  getTransaction(index = 0) {
+    return this.transactions[index];
+  }
+  hasWallets() {
+    return this.wallets.length > 0;
+  }
+  clear() {
+    this.wallets = [];
+    this.transactions = [];
+  }
+};
+function ensureWalletExists(_0, _1) {
+  return __async(this, arguments, function* (apiClient, testData, options = {}) {
+    if (testData.hasWallets()) {
+      return testData.getWallet();
+    }
+    const { chainType = "evm", type = "mpc", owner, testName = "default" } = options;
+    const ownerId = owner || `userId:integration-${testName}-${Date.now()}`;
+    const createResult = yield apiClient.createWallet(__spreadValues({
+      chainType,
+      type
+    }, owner && { owner: ownerId }));
+    if (isSuccessWalletResponse(createResult)) {
+      testData.addWallet(createResult.address);
+      return createResult.address;
+    }
+    return void 0;
+  });
+}
+function createTestWallet(apiClient, testData, params) {
+  return __async(this, null, function* () {
+    const result = yield apiClient.createWallet(params);
+    if (isSuccessWalletResponse(result)) {
+      testData.addWallet(result.address);
+    }
+    return result;
+  });
+}
+function expectErrorResponse(response, message) {
+  expect(isErrorResponse(response)).toBe(true);
+  if (message) {
+    expect(response.message).toBeDefined();
+  }
+}
+function expectSuccessWalletResponse(response) {
+  expect(isSuccessWalletResponse(response)).toBe(true);
+}
+function expectSuccessTransactionResponse(response) {
+  expect(isSuccessTransactionResponse(response)).toBe(true);
+}
+var fundWallet = (apiClient, walletLocator, amount, token = "usdxm", chain = "base-sepolia") => __async(void 0, null, function* () {
+  const params = {
+    amount,
+    token,
+    chain
+  };
+  const result = yield apiClient.fundWallet(walletLocator, params);
+  if (isErrorResponse(result)) {
+    throw new Error(`Failed to fund wallet: ${result.message || "Unknown error"}`);
+  }
+  yield delay(DELAY_LONG);
+  return result;
+});
+var approveTransaction = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3], function* (apiClient, walletLocator, transactionId, maxRetries = TEST_VALUES.APPROVE_TRANSACTION_MAX_RETRIES) {
+  var _a;
+  for (let i = 0; i < maxRetries; i++) {
+    const transaction = yield apiClient.getTransaction(walletLocator, transactionId);
+    if (isErrorResponse(transaction)) {
+      throw new Error(`Transaction not found: ${transaction.message || "Unknown error"}`);
+    }
+    if ("status" in transaction && (transaction.status === "success" || transaction.status === "failed")) {
+      return transaction;
+    }
+    const pendingApprovals = "approvals" in transaction ? (_a = transaction.approvals) == null ? void 0 : _a.pending : void 0;
+    if (pendingApprovals && pendingApprovals.length > 0) {
+      const approvals = {
+        approvals: pendingApprovals.map((approval) => ({
+          signer: approval.signer.locator,
+          signature: ""
+        }))
+      };
+      const approvedTransaction = yield apiClient.approveTransaction(walletLocator, transactionId, approvals);
+      if (isErrorResponse(approvedTransaction)) {
+        throw new Error(`Failed to approve transaction: ${approvedTransaction.message || "Unknown error"}`);
+      }
+      yield delay(DELAY_RATE_LIMIT_WINDOW);
+      continue;
+    }
+    yield delay(DELAY_LONG);
+  }
+  const finalTransaction = yield apiClient.getTransaction(walletLocator, transactionId);
+  if (isErrorResponse(finalTransaction)) {
+    throw new Error(`Transaction not found after retries: ${finalTransaction.message || "Unknown error"}`);
+  }
+  if (!("status" in finalTransaction)) {
+    throw new Error("Transaction response missing status property");
+  }
+  return finalTransaction;
+});
+var fundWalletAndWait = (apiClient, walletLocator, amount = 1, token = "usdxm", chain = "base-sepolia") => __async(void 0, null, function* () {
+  return fundWallet(apiClient, walletLocator, amount, token, chain);
+});
+var sendTokenAndApprove = (apiClient, walletLocator, tokenLocator, recipient, amount) => __async(void 0, null, function* () {
+  const sendResult = yield apiClient.send(walletLocator, tokenLocator, {
+    recipient,
+    amount
+  });
+  if (isErrorResponse(sendResult)) {
+    throw new Error(`Failed to send token: ${sendResult.message || "Unknown error"}`);
+  }
+  if (typeof sendResult === "object" && sendResult !== null && "id" in sendResult && typeof sendResult.id === "string") {
+    return approveTransaction(apiClient, walletLocator, sendResult.id);
+  }
+  throw new Error("Transaction ID not found in send response");
+});
+var ensureWalletFunded = (apiClient, walletLocator, amount = 1, token = "usdxm", chain = "base-sepolia") => __async(void 0, null, function* () {
+  try {
+    yield fundWallet(apiClient, walletLocator, amount, token, chain);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!errorMessage.includes("already funded") && !errorMessage.includes("insufficient")) {
+      throw error;
+    }
+  }
+});
+export {
+  TestDataFactory,
+  approveTransaction,
+  createIntegrationApiClient,
+  createMockCrossmint,
+  createMockErrorResponse,
+  createMockResponse,
+  createMockSendResponse,
+  createMockSuccessResponse,
+  createMockWalletResponse,
+  createServerSideApiClient,
+  createTestApiClient,
+  createTestWallet,
+  delay,
+  ensureWalletExists,
+  ensureWalletFunded,
+  expectCommonHeaders,
+  expectErrorResponse,
+  expectRequestBody,
+  expectRequestPath,
+  expectSuccessTransactionResponse,
+  expectSuccessWalletResponse,
+  extractFetchCall,
+  fundWallet,
+  fundWalletAndWait,
+  isErrorResponse,
+  isSuccessTransactionResponse,
+  isSuccessWalletResponse,
+  isValidEthereumAddress,
+  isValidSolanaAddress,
+  sendTokenAndApprove,
+  testCommonHttpErrors,
+  testHttpErrorResponse,
+  testInvalidJsonResponse,
+  testMalformedResponse,
+  testNetworkError,
+  testTimeoutError,
+  validateRequest
+};

package/dist/api/client.cjs

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkPUXRHELKcjs = require('../chunk-PUXRHELK.cjs');
+var _chunkC5F6IECXcjs = require('../chunk-C5F6IECX.cjs');
 require('../chunk-XC2V34TS.cjs');
-require('../chunk-SWPJZ5JX.cjs');
-require('../chunk-ADCODBBF.cjs');
+require('../chunk-FQV77LH4.cjs');
+require('../chunk-5CBGJLA4.cjs');
 require('../chunk-UO2J2ZB2.cjs');
 
 
-exports.ApiClient = _chunkPUXRHELKcjs.ApiClient;
+exports.ApiClient = _chunkC5F6IECXcjs.ApiClient;

package/dist/api/client.js

@@ -1,9 +1,9 @@
 import {
   ApiClient
-} from "../chunk-CEFMURL3.js";
+} from "../chunk-6EP3PLGP.js";
 import "../chunk-SGINWAB6.js";
-import "../chunk-B24CPC6Y.js";
-import "../chunk-SEGDDAL2.js";
+import "../chunk-S2AKC2CK.js";
+import "../chunk-KE6LX37B.js";
 import "../chunk-ASE2FXWP.js";
 export {
   ApiClient

package/dist/api/gen/types.gen.d.cts

@@ -2610,6 +2610,10 @@ type SendTokenDto = {
      * Amount of tokens to transfer (in decimal format)
      */
     amount?: string;
+    /**
+     * Specifies the type of transaction. Choose 'direct' for standard interactions or 'regulated-transfer' for operations requiring compliance checks.
+     */
+    transactionType?: 'direct' | 'regulated-transfer' | 'onramp';
 };
 /**
  * Base fields for all token transfers
@@ -2649,6 +2653,10 @@ type SendTokenV2025Dto = {
         type: 'hash';
         value: string;
     };
+    /**
+     * Specifies the type of transaction. Choose 'direct' for standard interactions or 'regulated-transfer' for operations requiring compliance checks.
+     */
+    transactionType?: 'direct' | 'regulated-transfer' | 'onramp';
 };
 /**
  * Input for submitting one or more approvals

package/dist/api/gen/types.gen.d.ts

@@ -2610,6 +2610,10 @@ type SendTokenDto = {
      * Amount of tokens to transfer (in decimal format)
      */
     amount?: string;
+    /**
+     * Specifies the type of transaction. Choose 'direct' for standard interactions or 'regulated-transfer' for operations requiring compliance checks.
+     */
+    transactionType?: 'direct' | 'regulated-transfer' | 'onramp';
 };
 /**
  * Base fields for all token transfers
@@ -2649,6 +2653,10 @@ type SendTokenV2025Dto = {
         type: 'hash';
         value: string;
     };
+    /**
+     * Specifies the type of transaction. Choose 'direct' for standard interactions or 'regulated-transfer' for operations requiring compliance checks.
+     */
+    transactionType?: 'direct' | 'regulated-transfer' | 'onramp';
 };
 /**
  * Input for submitting one or more approvals

package/dist/api/index.cjs

@@ -1,12 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-6HXIZLEQ.cjs');
 
 
-var _chunkPUXRHELKcjs = require('../chunk-PUXRHELK.cjs');
+var _chunkC5F6IECXcjs = require('../chunk-C5F6IECX.cjs');
 require('../chunk-XC2V34TS.cjs');
 require('../chunk-ECAM5KTH.cjs');
-require('../chunk-SWPJZ5JX.cjs');
-require('../chunk-ADCODBBF.cjs');
+require('../chunk-FQV77LH4.cjs');
+require('../chunk-5CBGJLA4.cjs');
 require('../chunk-UO2J2ZB2.cjs');
 
 
-exports.ApiClient = _chunkPUXRHELKcjs.ApiClient;
+exports.ApiClient = _chunkC5F6IECXcjs.ApiClient;