@crossmint/wallets-sdk 0.18.14 → 0.18.15

package/dist/api/__tests__/constants.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkG6QJHFSYcjs = require('../../chunk-G6QJHFSY.cjs');
+require('../../chunk-UO2J2ZB2.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DELAY_LONG = _chunkG6QJHFSYcjs.DELAY_LONG; exports.DELAY_MEDIUM = _chunkG6QJHFSYcjs.DELAY_MEDIUM; exports.DELAY_RATE_LIMIT_WINDOW = _chunkG6QJHFSYcjs.DELAY_RATE_LIMIT_WINDOW; exports.DELAY_SHORT = _chunkG6QJHFSYcjs.DELAY_SHORT; exports.HTTP_ERROR_STATUSES = _chunkG6QJHFSYcjs.HTTP_ERROR_STATUSES; exports.MOCK_API_KEY = _chunkG6QJHFSYcjs.MOCK_API_KEY; exports.TEST_ADDRESSES = _chunkG6QJHFSYcjs.TEST_ADDRESSES; exports.TEST_VALUES = _chunkG6QJHFSYcjs.TEST_VALUES; exports.TIMEOUT_LONG = _chunkG6QJHFSYcjs.TIMEOUT_LONG; exports.TIMEOUT_MEDIUM = _chunkG6QJHFSYcjs.TIMEOUT_MEDIUM; exports.TIMEOUT_SHORT = _chunkG6QJHFSYcjs.TIMEOUT_SHORT; exports.TOKEN_LOCATORS = _chunkG6QJHFSYcjs.TOKEN_LOCATORS; exports.WALLET_LOCATORS = _chunkG6QJHFSYcjs.WALLET_LOCATORS;

package/dist/api/__tests__/constants.d.cts

@@ -0,0 +1,96 @@
+import { WalletLocator } from '../types.cjs';
+import 'viem';
+import '../gen/types.gen.cjs';
+
+declare const HTTP_ERROR_STATUSES: readonly [{
+    readonly status: 400;
+    readonly message: "Bad Request";
+}, {
+    readonly status: 401;
+    readonly message: "Unauthorized";
+}, {
+    readonly status: 403;
+    readonly message: "Forbidden";
+}, {
+    readonly status: 404;
+    readonly message: "Not Found";
+}, {
+    readonly status: 429;
+    readonly message: "Rate limit exceeded";
+}, {
+    readonly status: 500;
+    readonly message: "Internal server error";
+}, {
+    readonly status: 502;
+    readonly message: "Bad Gateway";
+}, {
+    readonly status: 503;
+    readonly message: "Service Unavailable";
+}];
+/**
+ * General-purpose wallet locators for unit and integration tests.
+ * Includes both locator format strings (me:chain:type) and actual addresses.
+ * Used for testing wallet operations that accept WalletLocator type.
+ */
+declare const WALLET_LOCATORS: {
+    readonly evmSmart: WalletLocator;
+    readonly evmMpc: WalletLocator;
+    readonly solanaSmart: WalletLocator;
+    readonly solanaAddress: WalletLocator;
+    readonly evmAddress: WalletLocator;
+    readonly evmAddressWithSpecialChars: WalletLocator;
+};
+declare const TOKEN_LOCATORS: {
+    readonly eth: "base-sepolia:eth";
+    readonly usdc: "base-sepolia:usdc";
+    readonly sol: "solana:sol";
+    readonly customContract: "base-sepolia:0x1234567890123456789012345678901234567890";
+    readonly tokenWithSpecialChars: "base-sepolia:0xABCDEFabcdef0123456789ABCDEFabcdef012345";
+};
+declare const TIMEOUT_SHORT = 30000;
+declare const TIMEOUT_MEDIUM = 60000;
+declare const TIMEOUT_LONG = 120000;
+declare const DELAY_SHORT = 200;
+declare const DELAY_MEDIUM = 500;
+declare const DELAY_LONG = 1000;
+declare const DELAY_RATE_LIMIT_WINDOW = 2000;
+/**
+ * Real blockchain addresses for integration tests with specific purposes.
+ * These are actual addresses used in integration tests for:
+ * - Admin signers (external wallet addresses for wallet creation)
+ * - Recipients (addresses to send tokens to)
+ * - Error testing (non-existent addresses)
+ * - General test operations
+ * Note: These are actual addresses, not locator format strings.
+ */
+declare const TEST_ADDRESSES: {
+    readonly EVM_ADMIN_SIGNER: "0xe5E91D9b21C3563011cc332B050150fb9211bBEB";
+    readonly SOLANA_ADMIN_SIGNER: "CsHuaddA9J8j9vSTdL9wpvBsyjYe4F7iQQLuPg3EUqsU";
+    readonly EVM_RECIPIENT: "0xDF8b5F9c19E187f1Ea00730a1e46180152244315";
+    readonly EVM_NON_EXISTENT: "0x0000000000000000000000000000000000000000";
+    readonly EVM_TEST: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd";
+};
+declare const TEST_VALUES: {
+    readonly FUNDING_AMOUNT_SMALL: 1;
+    readonly FUNDING_AMOUNT_LARGE: 10;
+    readonly SEND_AMOUNT_SMALL: "0.0001";
+    readonly SEND_AMOUNT_VERY_SMALL: "0.000000000000000001";
+    readonly SEND_AMOUNT_ZERO: "0";
+    readonly SEND_AMOUNT_INVALID: "999999999999999999.0";
+    readonly SEND_AMOUNT_EXTREME: "999999999999999999999999999999.999999999999999999";
+    readonly LONG_STRING_LENGTH: 10000;
+    readonly CONCURRENT_REQUESTS: 3;
+    readonly RAPID_SEQUENTIAL_COUNT: 3;
+    readonly RATE_LIMIT_BATCH_SIZE: 5;
+    readonly RATE_LIMIT_BATCHES: 3;
+    readonly RATE_LIMIT_RAPID_COUNT: 20;
+    readonly RATE_LIMIT_STRESS_COUNT: 50;
+    readonly APPROVE_TRANSACTION_MAX_RETRIES: 10;
+};
+/**
+ * Mock API key for unit tests.
+ * This is a valid development API key format used for testing purposes only.
+ */
+declare const MOCK_API_KEY = "ck_development_A61UZQnvjSQcM5qVBaBactgqebxafWAVsNdD2xLkgBxoYuH5q2guM8r9DUmZQzE1WYyoByGVYpEG2o9gVSzAZFsrLbfKGERUJ6D5CW6S9AsJGAc3ctgrsD4n2ioekzGj7KPbLwT3SysDjMamYXLxEroUbQSdwf6aLF4zeEpECq2crkTUQeLFzxzmjWNxFDHFYefDrfrFPCURvBXJLf5pCxCQ";
+
+export { DELAY_LONG, DELAY_MEDIUM, DELAY_RATE_LIMIT_WINDOW, DELAY_SHORT, HTTP_ERROR_STATUSES, MOCK_API_KEY, TEST_ADDRESSES, TEST_VALUES, TIMEOUT_LONG, TIMEOUT_MEDIUM, TIMEOUT_SHORT, TOKEN_LOCATORS, WALLET_LOCATORS };

package/dist/api/__tests__/constants.d.ts

@@ -0,0 +1,96 @@
+import { WalletLocator } from '../types.js';
+import 'viem';
+import '../gen/types.gen.js';
+
+declare const HTTP_ERROR_STATUSES: readonly [{
+    readonly status: 400;
+    readonly message: "Bad Request";
+}, {
+    readonly status: 401;
+    readonly message: "Unauthorized";
+}, {
+    readonly status: 403;
+    readonly message: "Forbidden";
+}, {
+    readonly status: 404;
+    readonly message: "Not Found";
+}, {
+    readonly status: 429;
+    readonly message: "Rate limit exceeded";
+}, {
+    readonly status: 500;
+    readonly message: "Internal server error";
+}, {
+    readonly status: 502;
+    readonly message: "Bad Gateway";
+}, {
+    readonly status: 503;
+    readonly message: "Service Unavailable";
+}];
+/**
+ * General-purpose wallet locators for unit and integration tests.
+ * Includes both locator format strings (me:chain:type) and actual addresses.
+ * Used for testing wallet operations that accept WalletLocator type.
+ */
+declare const WALLET_LOCATORS: {
+    readonly evmSmart: WalletLocator;
+    readonly evmMpc: WalletLocator;
+    readonly solanaSmart: WalletLocator;
+    readonly solanaAddress: WalletLocator;
+    readonly evmAddress: WalletLocator;
+    readonly evmAddressWithSpecialChars: WalletLocator;
+};
+declare const TOKEN_LOCATORS: {
+    readonly eth: "base-sepolia:eth";
+    readonly usdc: "base-sepolia:usdc";
+    readonly sol: "solana:sol";
+    readonly customContract: "base-sepolia:0x1234567890123456789012345678901234567890";
+    readonly tokenWithSpecialChars: "base-sepolia:0xABCDEFabcdef0123456789ABCDEFabcdef012345";
+};
+declare const TIMEOUT_SHORT = 30000;
+declare const TIMEOUT_MEDIUM = 60000;
+declare const TIMEOUT_LONG = 120000;
+declare const DELAY_SHORT = 200;
+declare const DELAY_MEDIUM = 500;
+declare const DELAY_LONG = 1000;
+declare const DELAY_RATE_LIMIT_WINDOW = 2000;
+/**
+ * Real blockchain addresses for integration tests with specific purposes.
+ * These are actual addresses used in integration tests for:
+ * - Admin signers (external wallet addresses for wallet creation)
+ * - Recipients (addresses to send tokens to)
+ * - Error testing (non-existent addresses)
+ * - General test operations
+ * Note: These are actual addresses, not locator format strings.
+ */
+declare const TEST_ADDRESSES: {
+    readonly EVM_ADMIN_SIGNER: "0xe5E91D9b21C3563011cc332B050150fb9211bBEB";
+    readonly SOLANA_ADMIN_SIGNER: "CsHuaddA9J8j9vSTdL9wpvBsyjYe4F7iQQLuPg3EUqsU";
+    readonly EVM_RECIPIENT: "0xDF8b5F9c19E187f1Ea00730a1e46180152244315";
+    readonly EVM_NON_EXISTENT: "0x0000000000000000000000000000000000000000";
+    readonly EVM_TEST: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd";
+};
+declare const TEST_VALUES: {
+    readonly FUNDING_AMOUNT_SMALL: 1;
+    readonly FUNDING_AMOUNT_LARGE: 10;
+    readonly SEND_AMOUNT_SMALL: "0.0001";
+    readonly SEND_AMOUNT_VERY_SMALL: "0.000000000000000001";
+    readonly SEND_AMOUNT_ZERO: "0";
+    readonly SEND_AMOUNT_INVALID: "999999999999999999.0";
+    readonly SEND_AMOUNT_EXTREME: "999999999999999999999999999999.999999999999999999";
+    readonly LONG_STRING_LENGTH: 10000;
+    readonly CONCURRENT_REQUESTS: 3;
+    readonly RAPID_SEQUENTIAL_COUNT: 3;
+    readonly RATE_LIMIT_BATCH_SIZE: 5;
+    readonly RATE_LIMIT_BATCHES: 3;
+    readonly RATE_LIMIT_RAPID_COUNT: 20;
+    readonly RATE_LIMIT_STRESS_COUNT: 50;
+    readonly APPROVE_TRANSACTION_MAX_RETRIES: 10;
+};
+/**
+ * Mock API key for unit tests.
+ * This is a valid development API key format used for testing purposes only.
+ */
+declare const MOCK_API_KEY = "ck_development_A61UZQnvjSQcM5qVBaBactgqebxafWAVsNdD2xLkgBxoYuH5q2guM8r9DUmZQzE1WYyoByGVYpEG2o9gVSzAZFsrLbfKGERUJ6D5CW6S9AsJGAc3ctgrsD4n2ioekzGj7KPbLwT3SysDjMamYXLxEroUbQSdwf6aLF4zeEpECq2crkTUQeLFzxzmjWNxFDHFYefDrfrFPCURvBXJLf5pCxCQ";
+
+export { DELAY_LONG, DELAY_MEDIUM, DELAY_RATE_LIMIT_WINDOW, DELAY_SHORT, HTTP_ERROR_STATUSES, MOCK_API_KEY, TEST_ADDRESSES, TEST_VALUES, TIMEOUT_LONG, TIMEOUT_MEDIUM, TIMEOUT_SHORT, TOKEN_LOCATORS, WALLET_LOCATORS };

package/dist/api/__tests__/constants.js

@@ -0,0 +1,31 @@
+import {
+  DELAY_LONG,
+  DELAY_MEDIUM,
+  DELAY_RATE_LIMIT_WINDOW,
+  DELAY_SHORT,
+  HTTP_ERROR_STATUSES,
+  MOCK_API_KEY,
+  TEST_ADDRESSES,
+  TEST_VALUES,
+  TIMEOUT_LONG,
+  TIMEOUT_MEDIUM,
+  TIMEOUT_SHORT,
+  TOKEN_LOCATORS,
+  WALLET_LOCATORS
+} from "../../chunk-PJOJIRTY.js";
+import "../../chunk-ASE2FXWP.js";
+export {
+  DELAY_LONG,
+  DELAY_MEDIUM,
+  DELAY_RATE_LIMIT_WINDOW,
+  DELAY_SHORT,
+  HTTP_ERROR_STATUSES,
+  MOCK_API_KEY,
+  TEST_ADDRESSES,
+  TEST_VALUES,
+  TIMEOUT_LONG,
+  TIMEOUT_MEDIUM,
+  TIMEOUT_SHORT,
+  TOKEN_LOCATORS,
+  WALLET_LOCATORS
+};

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

@@ -0,0 +1,372 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunkG6QJHFSYcjs = require('../../chunk-G6QJHFSY.cjs');
+
+
+var _chunkNFQT5TFOcjs = require('../../chunk-NFQT5TFO.cjs');
+require('../../chunk-XC2V34TS.cjs');
+require('../../chunk-WMUNQJYD.cjs');
+require('../../chunk-PJTTM5QQ.cjs');
+
+
+
+
+var _chunkUO2J2ZB2cjs = require('../../chunk-UO2J2ZB2.cjs');
+
+// src/api/__tests__/test-utils.ts
+var _vitest = require('vitest');
+var createMockResponse = ({
+  data,
+  status = 200,
+  ok = true,
+  statusText = "OK"
+}) => {
+  return {
+    json: _vitest.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 = _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {
+    apiKey: _chunkG6QJHFSYcjs.MOCK_API_KEY
+  }, overrides);
+  return _chunkUO2J2ZB2cjs.__spreadProps.call(void 0, _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {}, base), {
+    setJwt: _vitest.vi.fn().mockReturnThis(),
+    experimental_setCustomAuth: _vitest.vi.fn().mockReturnThis()
+  });
+};
+var createTestApiClient = (crossmint) => {
+  return new (0, _chunkNFQT5TFOcjs.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) => {
+  _vitest.expect.call(void 0, call == null ? void 0 : call.path).toBe(expectedPath);
+};
+var expectCommonHeaders = (headers) => {
+  const headerObj = headers;
+  _vitest.expect.call(void 0, headerObj["Content-Type"]).toBe("application/json");
+};
+var expectRequestBody = (options, expectedBody) => {
+  _vitest.expect.call(void 0, options.body).toBe(JSON.stringify(expectedBody));
+};
+var validateRequest = (call, expectedPath, expectedBody) => {
+  _vitest.expect.call(void 0, 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) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  mockFn.mockResolvedValue(createMockErrorResponse(errorData, statusCode));
+  const result = yield apiCall();
+  _vitest.expect.call(void 0, isErrorResponse(result)).toBe(true);
+  if (isErrorResponse(result)) {
+    _vitest.expect.call(void 0, result.error).toBe(true);
+    if (errorData.message) {
+      _vitest.expect.call(void 0, result.message).toBe(errorData.message);
+    }
+  }
+});
+var testCommonHttpErrors = (_0, _1, ..._2) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, [_0, _1, ..._2], function* (apiCall, mockFn, skipStatuses = []) {
+  for (const { status, message } of _chunkG6QJHFSYcjs.HTTP_ERROR_STATUSES) {
+    if (skipStatuses.includes(status)) {
+      continue;
+    }
+    const errorResponse = { error: true, message };
+    mockFn.mockResolvedValueOnce(createMockErrorResponse(errorResponse, status));
+    const result = yield apiCall();
+    _vitest.expect.call(void 0, isErrorResponse(result)).toBe(true);
+  }
+});
+var testNetworkError = (apiCall, mockFn) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  mockFn.mockRejectedValue(new Error("Network error"));
+  yield _vitest.expect.call(void 0, apiCall()).rejects.toThrow("Network error");
+});
+var testInvalidJsonResponse = (apiCall, mockFn) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  const mockResponse = {
+    json: _vitest.vi.fn().mockRejectedValue(new Error("Invalid JSON")),
+    ok: true,
+    status: 200
+  };
+  mockFn.mockResolvedValue(mockResponse);
+  yield _vitest.expect.call(void 0, apiCall()).rejects.toThrow();
+});
+var testTimeoutError = (apiCall, mockFn) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  mockFn.mockImplementation(
+    () => new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), 0))
+  );
+  yield _vitest.expect.call(void 0, apiCall()).rejects.toThrow("Request timeout");
+});
+var testMalformedResponse = (apiCall, mockFn, malformedData) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  mockFn.mockResolvedValue(createMockSuccessResponse(malformedData));
+  const result = yield apiCall();
+  _vitest.expect.call(void 0, result).toEqual(malformedData);
+});
+var createMockWalletResponse = (overrides = {}) => _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {
+  address: _chunkG6QJHFSYcjs.WALLET_LOCATORS.evmAddress,
+  chainType: "evm",
+  type: "smart",
+  config: {
+    adminSigner: {
+      type: "external-wallet",
+      address: _chunkG6QJHFSYcjs.TEST_ADDRESSES.EVM_TEST
+    }
+  }
+}, overrides);
+var createMockSendResponse = (overrides = {}) => _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {
+  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 = _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {
+    apiKey
+  }, baseUrl && { overrideBaseUrl: baseUrl }), overrides);
+  const crossmint = _chunkUO2J2ZB2cjs.__spreadProps.call(void 0, _chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {}, base), {
+    setJwt: () => crossmint,
+    experimental_setCustomAuth: () => crossmint
+  });
+  return new (0, _chunkNFQT5TFOcjs.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 _chunkUO2J2ZB2cjs.__async.call(void 0, 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(_chunkUO2J2ZB2cjs.__spreadValues.call(void 0, {
+      chainType,
+      type
+    }, owner && { owner: ownerId }));
+    if (isSuccessWalletResponse(createResult)) {
+      testData.addWallet(createResult.address);
+      return createResult.address;
+    }
+    return void 0;
+  });
+}
+function createTestWallet(apiClient, testData, params) {
+  return _chunkUO2J2ZB2cjs.__async.call(void 0, this, null, function* () {
+    const result = yield apiClient.createWallet(params);
+    if (isSuccessWalletResponse(result)) {
+      testData.addWallet(result.address);
+    }
+    return result;
+  });
+}
+function expectErrorResponse(response, message) {
+  _vitest.expect.call(void 0, isErrorResponse(response)).toBe(true);
+  if (message) {
+    _vitest.expect.call(void 0, response.message).toBeDefined();
+  }
+}
+function expectSuccessWalletResponse(response) {
+  _vitest.expect.call(void 0, isSuccessWalletResponse(response)).toBe(true);
+}
+function expectSuccessTransactionResponse(response) {
+  _vitest.expect.call(void 0, isSuccessTransactionResponse(response)).toBe(true);
+}
+var fundWallet = (apiClient, walletLocator, amount, token = "usdxm", chain = "base-sepolia") => _chunkUO2J2ZB2cjs.__async.call(void 0, 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(_chunkG6QJHFSYcjs.DELAY_LONG);
+  return result;
+});
+var approveTransaction = (_0, _1, _2, ..._3) => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, [_0, _1, _2, ..._3], function* (apiClient, walletLocator, transactionId, maxRetries = _chunkG6QJHFSYcjs.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(_chunkG6QJHFSYcjs.DELAY_RATE_LIMIT_WINDOW);
+      continue;
+    }
+    yield delay(_chunkG6QJHFSYcjs.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") => _chunkUO2J2ZB2cjs.__async.call(void 0, void 0, null, function* () {
+  return fundWallet(apiClient, walletLocator, amount, token, chain);
+});
+var sendTokenAndApprove = (apiClient, walletLocator, tokenLocator, recipient, amount) => _chunkUO2J2ZB2cjs.__async.call(void 0, 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") => _chunkUO2J2ZB2cjs.__async.call(void 0, 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;
+    }
+  }
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TestDataFactory = TestDataFactory; exports.approveTransaction = approveTransaction; exports.createIntegrationApiClient = createIntegrationApiClient; exports.createMockCrossmint = createMockCrossmint; exports.createMockErrorResponse = createMockErrorResponse; exports.createMockResponse = createMockResponse; exports.createMockSendResponse = createMockSendResponse; exports.createMockSuccessResponse = createMockSuccessResponse; exports.createMockWalletResponse = createMockWalletResponse; exports.createServerSideApiClient = createServerSideApiClient; exports.createTestApiClient = createTestApiClient; exports.createTestWallet = createTestWallet; exports.delay = delay; exports.ensureWalletExists = ensureWalletExists; exports.ensureWalletFunded = ensureWalletFunded; exports.expectCommonHeaders = expectCommonHeaders; exports.expectErrorResponse = expectErrorResponse; exports.expectRequestBody = expectRequestBody; exports.expectRequestPath = expectRequestPath; exports.expectSuccessTransactionResponse = expectSuccessTransactionResponse; exports.expectSuccessWalletResponse = expectSuccessWalletResponse; exports.extractFetchCall = extractFetchCall; exports.fundWallet = fundWallet; exports.fundWalletAndWait = fundWalletAndWait; exports.isErrorResponse = isErrorResponse; exports.isSuccessTransactionResponse = isSuccessTransactionResponse; exports.isSuccessWalletResponse = isSuccessWalletResponse; exports.isValidEthereumAddress = isValidEthereumAddress; exports.isValidSolanaAddress = isValidSolanaAddress; exports.sendTokenAndApprove = sendTokenAndApprove; exports.testCommonHttpErrors = testCommonHttpErrors; exports.testHttpErrorResponse = testHttpErrorResponse; exports.testInvalidJsonResponse = testInvalidJsonResponse; exports.testMalformedResponse = testMalformedResponse; exports.testNetworkError = testNetworkError; exports.testTimeoutError = testTimeoutError; exports.validateRequest = validateRequest;