@movebridge/testing 0.0.1

package/dist/index.mjs

@@ -0,0 +1,953 @@
+// src/faker.ts
+var SeededRandom = class {
+  state;
+  constructor(seed) {
+    this.state = seed;
+  }
+  next() {
+    let t = this.state += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  nextBigInt(min, max) {
+    const range = max - min + 1n;
+    const randomFraction = this.next();
+    return min + BigInt(Math.floor(Number(range) * randomFraction));
+  }
+  pick(array2) {
+    return array2[this.nextInt(0, array2.length - 1)];
+  }
+};
+function createFaker(options) {
+  const seed = options?.seed ?? Date.now();
+  const random = new SeededRandom(seed);
+  function randomHex(length) {
+    const chars = "0123456789abcdef";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[random.nextInt(0, 15)];
+    }
+    return result;
+  }
+  function randomTimestamp() {
+    const now = Date.now();
+    const dayAgo = now - 24 * 60 * 60 * 1e3;
+    return String(random.nextInt(dayAgo, now) * 1e3);
+  }
+  function randomSequenceNumber() {
+    return String(random.nextInt(0, 1e6));
+  }
+  return {
+    /**
+     * Generates a valid random Movement address
+     */
+    fakeAddress() {
+      return `0x${randomHex(64)}`;
+    },
+    /**
+     * Generates a random balance within optional bounds
+     */
+    fakeBalance(options2) {
+      const min = options2?.min ? BigInt(options2.min) : 0n;
+      const max = options2?.max ? BigInt(options2.max) : 10000000000n;
+      return random.nextBigInt(min, max).toString();
+    },
+    /**
+     * Generates a complete fake transaction
+     */
+    fakeTransaction() {
+      return {
+        hash: `0x${randomHex(64)}`,
+        sender: `0x${randomHex(64)}`,
+        sequenceNumber: randomSequenceNumber(),
+        payload: {
+          type: "entry_function_payload",
+          function: `0x${randomHex(64)}::module::function`,
+          typeArguments: [],
+          arguments: []
+        },
+        timestamp: randomTimestamp()
+      };
+    },
+    /**
+     * Generates a fake transaction response
+     */
+    fakeTransactionResponse(success = true) {
+      return {
+        hash: `0x${randomHex(64)}`,
+        success,
+        vmStatus: success ? "Executed successfully" : "Move abort",
+        gasUsed: String(random.nextInt(100, 1e4)),
+        events: []
+      };
+    },
+    /**
+     * Generates a fake resource with specified type
+     */
+    fakeResource(type) {
+      return {
+        type,
+        data: {
+          value: String(random.nextInt(0, 1e6))
+        }
+      };
+    },
+    /**
+     * Generates a fake contract event with specified type
+     */
+    fakeEvent(type) {
+      return {
+        type,
+        sequenceNumber: randomSequenceNumber(),
+        data: {
+          value: String(random.nextInt(0, 1e6))
+        }
+      };
+    },
+    /**
+     * Generates a fake wallet state
+     */
+    fakeWalletState(connected = false) {
+      if (connected) {
+        return {
+          connected: true,
+          address: `0x${randomHex(64)}`,
+          publicKey: `0x${randomHex(64)}`
+        };
+      }
+      return {
+        connected: false,
+        address: null,
+        publicKey: null
+      };
+    },
+    /**
+     * Generates a fake transaction hash
+     */
+    fakeTransactionHash() {
+      return `0x${randomHex(64)}`;
+    }
+  };
+}
+
+// src/tracker.ts
+import { MovementError } from "@movebridge/core";
+function createCallTracker() {
+  const calls = [];
+  function deepEqual(a, b) {
+    if (a === b) return true;
+    if (a === null || b === null) return false;
+    if (typeof a !== typeof b) return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      return a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length) return false;
+      return aKeys.every(
+        (key) => deepEqual(
+          a[key],
+          b[key]
+        )
+      );
+    }
+    return false;
+  }
+  return {
+    /**
+     * Records a method call
+     */
+    recordCall(method, args, result, error) {
+      calls.push({
+        method,
+        arguments: args,
+        timestamp: Date.now(),
+        result,
+        error
+      });
+    },
+    /**
+     * Gets all calls to a specific method
+     */
+    getCalls(method) {
+      return calls.filter((call) => call.method === method);
+    },
+    /**
+     * Gets the count of calls to a specific method
+     */
+    getCallCount(method) {
+      return calls.filter((call) => call.method === method).length;
+    },
+    /**
+     * Gets all recorded calls
+     */
+    getAllCalls() {
+      return [...calls];
+    },
+    /**
+     * Asserts that a method was called at least once
+     */
+    assertCalled(method) {
+      const count = this.getCallCount(method);
+      if (count === 0) {
+        throw new MovementError(
+          `Expected method "${method}" to be called, but it was never called`,
+          "INVALID_ARGUMENT",
+          { method, expected: "at least 1 call", actual: 0 }
+        );
+      }
+    },
+    /**
+     * Asserts that a method was called exactly N times
+     */
+    assertCalledTimes(method, times) {
+      const count = this.getCallCount(method);
+      if (count !== times) {
+        throw new MovementError(
+          `Expected method "${method}" to be called ${times} times, but it was called ${count} times`,
+          "INVALID_ARGUMENT",
+          { method, expected: times, actual: count }
+        );
+      }
+    },
+    /**
+     * Asserts that a method was called with specific arguments
+     */
+    assertCalledWith(method, ...expectedArgs) {
+      const methodCalls = this.getCalls(method);
+      if (methodCalls.length === 0) {
+        throw new MovementError(
+          `Expected method "${method}" to be called with arguments, but it was never called`,
+          "INVALID_ARGUMENT",
+          { method, expectedArgs, actualCalls: [] }
+        );
+      }
+      const hasMatch = methodCalls.some(
+        (call) => deepEqual(call.arguments, expectedArgs)
+      );
+      if (!hasMatch) {
+        throw new MovementError(
+          `Expected method "${method}" to be called with specific arguments, but no matching call found`,
+          "INVALID_ARGUMENT",
+          {
+            method,
+            expectedArgs,
+            actualCalls: methodCalls.map((c) => c.arguments)
+          }
+        );
+      }
+    },
+    /**
+     * Asserts that a method was never called
+     */
+    assertNotCalled(method) {
+      const count = this.getCallCount(method);
+      if (count > 0) {
+        throw new MovementError(
+          `Expected method "${method}" to not be called, but it was called ${count} times`,
+          "INVALID_ARGUMENT",
+          { method, expected: 0, actual: count }
+        );
+      }
+    },
+    /**
+     * Clears all recorded calls
+     */
+    clearCalls() {
+      calls.length = 0;
+    }
+  };
+}
+
+// src/simulator.ts
+function createNetworkSimulator() {
+  let latency = 0;
+  let networkErrorEnabled = false;
+  let rateLimitMax = null;
+  let rateLimitCalls = 0;
+  const timeoutMethods = /* @__PURE__ */ new Set();
+  return {
+    /**
+     * Sets the latency for all mock responses
+     */
+    simulateLatency(ms) {
+      latency = ms;
+    },
+    /**
+     * Causes a specific method to timeout
+     */
+    simulateTimeout(method) {
+      timeoutMethods.add(method);
+    },
+    /**
+     * Enables network error simulation for all calls
+     */
+    simulateNetworkError() {
+      networkErrorEnabled = true;
+    },
+    /**
+     * Sets up rate limiting after N calls
+     */
+    simulateRateLimit(maxCalls) {
+      rateLimitMax = maxCalls;
+      rateLimitCalls = 0;
+    },
+    /**
+     * Resets all simulation settings
+     */
+    resetSimulation() {
+      latency = 0;
+      networkErrorEnabled = false;
+      rateLimitMax = null;
+      rateLimitCalls = 0;
+      timeoutMethods.clear();
+    },
+    /**
+     * Gets the current latency setting
+     */
+    getLatency() {
+      return latency;
+    },
+    /**
+     * Checks if network error is enabled
+     */
+    isNetworkErrorEnabled() {
+      return networkErrorEnabled;
+    },
+    /**
+     * Checks if a method is set to timeout
+     */
+    isMethodTimedOut(method) {
+      return timeoutMethods.has(method);
+    },
+    /**
+     * Gets remaining rate limit calls (null if no limit)
+     */
+    getRateLimitRemaining() {
+      if (rateLimitMax === null) return null;
+      return Math.max(0, rateLimitMax - rateLimitCalls);
+    },
+    /**
+     * Increments the rate limit call counter
+     */
+    incrementRateLimitCalls() {
+      rateLimitCalls++;
+    }
+  };
+}
+async function applySimulation(simulator, method, fn) {
+  if (simulator.isNetworkErrorEnabled()) {
+    throw new Error("Network error: Connection failed");
+  }
+  if (simulator.isMethodTimedOut(method)) {
+    throw new Error(`Timeout: Method "${method}" timed out`);
+  }
+  const remaining = simulator.getRateLimitRemaining();
+  if (remaining !== null && remaining <= 0) {
+    throw new Error("Rate limited: Too many requests");
+  }
+  if (remaining !== null) {
+    simulator.incrementRateLimitCalls();
+  }
+  const latency = simulator.getLatency();
+  if (latency > 0) {
+    await new Promise((resolve) => setTimeout(resolve, latency));
+  }
+  return fn();
+}
+
+// src/mock-client.ts
+function createMockClient(deps) {
+  const { tracker, simulator, faker } = deps;
+  const mocks = /* @__PURE__ */ new Map();
+  const onceMocks = /* @__PURE__ */ new Map();
+  async function getResponse(method, defaultFn) {
+    const onceMock = onceMocks.get(method);
+    if (onceMock) {
+      onceMocks.delete(method);
+      if (onceMock.error) {
+        throw onceMock.error;
+      }
+      return onceMock.response;
+    }
+    const mock = mocks.get(method);
+    if (mock) {
+      if (mock.error) {
+        throw mock.error;
+      }
+      return mock.response;
+    }
+    return defaultFn();
+  }
+  async function wrapCall(method, args, defaultFn) {
+    try {
+      const result = await applySimulation(simulator, method, async () => {
+        return getResponse(method, defaultFn);
+      });
+      tracker.recordCall(method, args, result);
+      return result;
+    } catch (error) {
+      tracker.recordCall(method, args, void 0, error);
+      throw error;
+    }
+  }
+  return {
+    /**
+     * Configures a persistent mock response for a method
+     */
+    mockResponse(method, response) {
+      mocks.set(method, { response });
+    },
+    /**
+     * Configures a mock error for a method
+     */
+    mockError(method, error) {
+      mocks.set(method, { error });
+    },
+    /**
+     * Configures a one-time mock response for a method
+     */
+    mockResponseOnce(method, response) {
+      onceMocks.set(method, { response });
+    },
+    /**
+     * Clears all mock configurations
+     */
+    clearMocks() {
+      mocks.clear();
+      onceMocks.clear();
+    },
+    /**
+     * Gets account balance (mocked)
+     */
+    async getAccountBalance(address) {
+      return wrapCall(
+        "getAccountBalance",
+        [address],
+        () => faker.fakeBalance()
+      );
+    },
+    /**
+     * Gets account resources (mocked)
+     */
+    async getAccountResources(address) {
+      return wrapCall("getAccountResources", [address], () => [
+        faker.fakeResource("0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>")
+      ]);
+    },
+    /**
+     * Gets transaction by hash (mocked)
+     */
+    async getTransaction(hash) {
+      return wrapCall("getTransaction", [hash], () => {
+        const tx = faker.fakeTransaction();
+        return { ...tx, hash };
+      });
+    },
+    /**
+     * Waits for transaction confirmation (mocked)
+     */
+    async waitForTransaction(hash) {
+      return wrapCall("waitForTransaction", [hash], () => {
+        const response = faker.fakeTransactionResponse(true);
+        return { ...response, hash };
+      });
+    }
+  };
+}
+
+// src/harness.ts
+function createTestHarness(config) {
+  const seed = config?.seed ?? Date.now();
+  const defaultLatency = config?.defaultLatency ?? 0;
+  const faker = createFaker({ seed });
+  const tracker = createCallTracker();
+  const simulator = createNetworkSimulator();
+  if (defaultLatency > 0) {
+    simulator.simulateLatency(defaultLatency);
+  }
+  const client = createMockClient({ tracker, simulator, faker });
+  return {
+    client,
+    tracker,
+    simulator,
+    faker,
+    /**
+     * Cleans up all state - call after each test
+     */
+    cleanup() {
+      client.clearMocks();
+      tracker.clearCalls();
+      simulator.resetSimulation();
+    },
+    /**
+     * Resets to initial state while keeping configuration
+     */
+    reset() {
+      client.clearMocks();
+      tracker.clearCalls();
+    }
+  };
+}
+
+// src/validators/address.ts
+import { MovementError as MovementError2 } from "@movebridge/core";
+var ADDRESS_REGEX = /^(0[xX])?[a-fA-F0-9]{1,64}$/;
+function isValidAddress(address) {
+  if (typeof address !== "string") {
+    return false;
+  }
+  return ADDRESS_REGEX.test(address);
+}
+function validateAddress(address) {
+  const result = getAddressValidationDetails(address);
+  if (!result.valid) {
+    throw new MovementError2(
+      `Invalid address: ${address} - ${result.error}`,
+      "INVALID_ADDRESS",
+      { address, reason: result.error }
+    );
+  }
+}
+function normalizeAddress(address) {
+  validateAddress(address);
+  const withoutPrefix = address.startsWith("0x") || address.startsWith("0X") ? address.slice(2) : address;
+  const padded = withoutPrefix.padStart(64, "0");
+  return `0x${padded.toLowerCase()}`;
+}
+function getAddressValidationDetails(address) {
+  if (typeof address !== "string") {
+    return {
+      valid: false,
+      error: "Address must be a string"
+    };
+  }
+  if (address.length === 0) {
+    return {
+      valid: false,
+      error: "Address cannot be empty"
+    };
+  }
+  const hasPrefix = address.startsWith("0x") || address.startsWith("0X");
+  const hexPart = hasPrefix ? address.slice(2) : address;
+  if (hexPart.length === 0) {
+    return {
+      valid: false,
+      error: "Address must contain hex characters after 0x prefix"
+    };
+  }
+  if (hexPart.length > 64) {
+    return {
+      valid: false,
+      error: `Address too long: ${hexPart.length} hex characters (max 64)`
+    };
+  }
+  if (!/^[a-fA-F0-9]+$/.test(hexPart)) {
+    return {
+      valid: false,
+      error: "Address contains invalid characters (must be hex: 0-9, a-f, A-F)"
+    };
+  }
+  const normalized = `0x${hexPart.padStart(64, "0").toLowerCase()}`;
+  return {
+    valid: true,
+    normalized
+  };
+}
+
+// src/validators/transaction.ts
+import { MovementError as MovementError3 } from "@movebridge/core";
+var FUNCTION_REGEX = /^0x[a-fA-F0-9]{1,64}::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;
+function validateTransferPayload(payload) {
+  if (!isValidAddress(payload.to)) {
+    throw new MovementError3(
+      `Invalid recipient address: ${payload.to}`,
+      "INVALID_ADDRESS",
+      { address: payload.to, field: "to" }
+    );
+  }
+  validateAmount(payload.amount);
+  if (payload.coinType !== void 0) {
+    if (typeof payload.coinType !== "string" || payload.coinType.length === 0) {
+      throw new MovementError3(
+        "Invalid coin type: must be a non-empty string",
+        "INVALID_ARGUMENT",
+        { argument: "coinType", value: payload.coinType }
+      );
+    }
+  }
+  return true;
+}
+function validateEntryFunctionPayload(payload) {
+  if (!FUNCTION_REGEX.test(payload.function)) {
+    throw new MovementError3(
+      `Invalid function identifier: ${payload.function}`,
+      "INVALID_ARGUMENT",
+      {
+        argument: "function",
+        value: payload.function,
+        expectedFormat: "0xADDRESS::module::function"
+      }
+    );
+  }
+  if (!Array.isArray(payload.typeArguments)) {
+    throw new MovementError3(
+      "typeArguments must be an array",
+      "INVALID_ARGUMENT",
+      { argument: "typeArguments", value: payload.typeArguments }
+    );
+  }
+  for (let i = 0; i < payload.typeArguments.length; i++) {
+    if (typeof payload.typeArguments[i] !== "string") {
+      throw new MovementError3(
+        `typeArguments[${i}] must be a string`,
+        "INVALID_ARGUMENT",
+        { argument: `typeArguments[${i}]`, value: payload.typeArguments[i] }
+      );
+    }
+  }
+  if (!Array.isArray(payload.arguments)) {
+    throw new MovementError3(
+      "arguments must be an array",
+      "INVALID_ARGUMENT",
+      { argument: "arguments", value: payload.arguments }
+    );
+  }
+  return true;
+}
+function validatePayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new MovementError3(
+      "Payload must be an object",
+      "INVALID_ARGUMENT",
+      { argument: "payload", value: payload }
+    );
+  }
+  if (payload.type !== "entry_function_payload") {
+    throw new MovementError3(
+      `Unsupported payload type: ${payload.type}`,
+      "INVALID_ARGUMENT",
+      { argument: "type", value: payload.type, supported: ["entry_function_payload"] }
+    );
+  }
+  return validateEntryFunctionPayload({
+    function: payload.function,
+    typeArguments: payload.typeArguments,
+    arguments: payload.arguments
+  });
+}
+function validateAmount(amount) {
+  if (typeof amount !== "string") {
+    throw new MovementError3(
+      "Amount must be a string",
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount }
+    );
+  }
+  const numValue = Number(amount);
+  if (isNaN(numValue)) {
+    throw new MovementError3(
+      `Invalid amount: "${amount}" is not a valid number`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "not a number" }
+    );
+  }
+  if (numValue < 0) {
+    throw new MovementError3(
+      `Invalid amount: "${amount}" cannot be negative`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "negative value" }
+    );
+  }
+  if (numValue === 0) {
+    throw new MovementError3(
+      `Invalid amount: "${amount}" cannot be zero`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "zero value" }
+    );
+  }
+  if (!Number.isInteger(numValue)) {
+    throw new MovementError3(
+      `Invalid amount: "${amount}" must be a whole number (no decimals)`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "contains decimals" }
+    );
+  }
+}
+
+// src/validators/schema.ts
+import {
+  object,
+  string,
+  boolean,
+  array,
+  record,
+  unknown,
+  literal,
+  nullable,
+  validate
+} from "superstruct";
+import { MovementError as MovementError4 } from "@movebridge/core";
+var PREDEFINED_SCHEMAS = {
+  Resource: object({
+    type: string(),
+    data: record(string(), unknown())
+  }),
+  Transaction: object({
+    hash: string(),
+    sender: string(),
+    sequenceNumber: string(),
+    payload: object({
+      type: literal("entry_function_payload"),
+      function: string(),
+      typeArguments: array(string()),
+      arguments: array(unknown())
+    }),
+    timestamp: string()
+  }),
+  TransactionResponse: object({
+    hash: string(),
+    success: boolean(),
+    vmStatus: string(),
+    gasUsed: string(),
+    events: array(
+      object({
+        type: string(),
+        sequenceNumber: string(),
+        data: record(string(), unknown())
+      })
+    )
+  }),
+  WalletState: object({
+    connected: boolean(),
+    address: nullable(string()),
+    publicKey: nullable(string())
+  }),
+  ContractEvent: object({
+    type: string(),
+    sequenceNumber: string(),
+    data: record(string(), unknown())
+  })
+};
+var customSchemas = /* @__PURE__ */ new Map();
+function getSchema(name) {
+  if (name in PREDEFINED_SCHEMAS) {
+    return PREDEFINED_SCHEMAS[name];
+  }
+  const customSchema = customSchemas.get(name);
+  if (customSchema) {
+    return customSchema;
+  }
+  throw new MovementError4(
+    `Unknown schema: ${name}`,
+    "INVALID_ARGUMENT",
+    {
+      schemaName: name,
+      availableSchemas: [
+        ...Object.keys(PREDEFINED_SCHEMAS),
+        ...customSchemas.keys()
+      ]
+    }
+  );
+}
+function validateSchema(data, schemaName) {
+  const schema = getSchema(schemaName);
+  const [error] = validate(data, schema);
+  return error === void 0;
+}
+function getValidationErrors(data, schemaName) {
+  const schema = getSchema(schemaName);
+  const [error] = validate(data, schema);
+  if (!error) {
+    return [];
+  }
+  return convertStructError(error);
+}
+function registerSchema(name, schema) {
+  if (name in PREDEFINED_SCHEMAS) {
+    throw new MovementError4(
+      `Cannot override predefined schema: ${name}`,
+      "INVALID_ARGUMENT",
+      { schemaName: name }
+    );
+  }
+  customSchemas.set(name, schema);
+}
+function hasSchema(name) {
+  return name in PREDEFINED_SCHEMAS || customSchemas.has(name);
+}
+function convertStructError(error) {
+  const errors = [];
+  for (const failure of error.failures()) {
+    errors.push({
+      path: failure.path.join(".") || "(root)",
+      expected: failure.type,
+      received: getTypeOf(failure.value),
+      message: failure.message
+    });
+  }
+  return errors;
+}
+function getTypeOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+// src/snapshots.ts
+function createSnapshotUtils() {
+  const snapshots = /* @__PURE__ */ new Map();
+  function serialize(data) {
+    return JSON.stringify(data, null, 2);
+  }
+  function generateDiff(expected, actual) {
+    const expectedLines = expected.split("\n");
+    const actualLines = actual.split("\n");
+    const diff = [];
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    for (let i = 0; i < maxLines; i++) {
+      const expectedLine = expectedLines[i];
+      const actualLine = actualLines[i];
+      if (expectedLine === actualLine) {
+        diff.push(`  ${expectedLine ?? ""}`);
+      } else {
+        if (expectedLine !== void 0) {
+          diff.push(`- ${expectedLine}`);
+        }
+        if (actualLine !== void 0) {
+          diff.push(`+ ${actualLine}`);
+        }
+      }
+    }
+    return diff.join("\n");
+  }
+  return {
+    /**
+     * Creates a new snapshot
+     */
+    createSnapshot(data, name) {
+      snapshots.set(name, serialize(data));
+    },
+    /**
+     * Matches data against an existing snapshot
+     * Creates a new snapshot if one doesn't exist
+     */
+    matchSnapshot(data, name) {
+      const serialized = serialize(data);
+      const existing = snapshots.get(name);
+      if (existing === void 0) {
+        snapshots.set(name, serialized);
+        return { match: true };
+      }
+      if (existing === serialized) {
+        return { match: true };
+      }
+      return {
+        match: false,
+        diff: generateDiff(existing, serialized)
+      };
+    },
+    /**
+     * Updates an existing snapshot with new data
+     */
+    updateSnapshot(data, name) {
+      snapshots.set(name, serialize(data));
+    },
+    /**
+     * Deletes a snapshot
+     */
+    deleteSnapshot(name) {
+      snapshots.delete(name);
+    },
+    /**
+     * Lists all snapshot names
+     */
+    listSnapshots() {
+      return Array.from(snapshots.keys());
+    }
+  };
+}
+
+// src/integration.ts
+import { MovementError as MovementError5 } from "@movebridge/core";
+function createIntegrationUtils(network) {
+  if (network !== "testnet") {
+    throw new MovementError5(
+      "Integration tests can only be run on testnet to prevent accidental mainnet usage",
+      "INVALID_ARGUMENT",
+      { network, allowed: ["testnet"] }
+    );
+  }
+  return {
+    /**
+     * Creates a new test account and funds it from the faucet
+     * Note: This requires network access and should only be used in integration tests
+     */
+    async createTestAccount() {
+      throw new MovementError5(
+        "createTestAccount requires network access. Use in integration tests only.",
+        "NETWORK_ERROR",
+        { reason: "Not implemented for unit tests" }
+      );
+    },
+    /**
+     * Waits for an account to be funded
+     */
+    async waitForFunding(address, timeout = 3e4) {
+      throw new MovementError5(
+        "waitForFunding requires network access. Use in integration tests only.",
+        "NETWORK_ERROR",
+        { address, timeout, reason: "Not implemented for unit tests" }
+      );
+    },
+    /**
+     * Cleans up a test account by transferring remaining balance
+     */
+    async cleanupTestAccount(account) {
+      throw new MovementError5(
+        "cleanupTestAccount requires network access. Use in integration tests only.",
+        "NETWORK_ERROR",
+        { address: account.address, reason: "Not implemented for unit tests" }
+      );
+    },
+    /**
+     * Executes a callback with a temporary test account
+     */
+    async withTestAccount(callback) {
+      const account = await this.createTestAccount();
+      try {
+        return await callback(account);
+      } finally {
+        await this.cleanupTestAccount(account);
+      }
+    }
+  };
+}
+export {
+  PREDEFINED_SCHEMAS,
+  createCallTracker,
+  createFaker,
+  createIntegrationUtils,
+  createMockClient,
+  createNetworkSimulator,
+  createSnapshotUtils,
+  createTestHarness,
+  getAddressValidationDetails,
+  getValidationErrors,
+  hasSchema,
+  isValidAddress,
+  normalizeAddress,
+  registerSchema,
+  validateAddress,
+  validateEntryFunctionPayload,
+  validatePayload,
+  validateSchema,
+  validateTransferPayload
+};