@movebridge/testing 0.0.1

package/dist/index.js

@@ -0,0 +1,988 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PREDEFINED_SCHEMAS: () => PREDEFINED_SCHEMAS,
+  createCallTracker: () => createCallTracker,
+  createFaker: () => createFaker,
+  createIntegrationUtils: () => createIntegrationUtils,
+  createMockClient: () => createMockClient,
+  createNetworkSimulator: () => createNetworkSimulator,
+  createSnapshotUtils: () => createSnapshotUtils,
+  createTestHarness: () => createTestHarness,
+  getAddressValidationDetails: () => getAddressValidationDetails,
+  getValidationErrors: () => getValidationErrors,
+  hasSchema: () => hasSchema,
+  isValidAddress: () => isValidAddress,
+  normalizeAddress: () => normalizeAddress,
+  registerSchema: () => registerSchema,
+  validateAddress: () => validateAddress,
+  validateEntryFunctionPayload: () => validateEntryFunctionPayload,
+  validatePayload: () => validatePayload,
+  validateSchema: () => validateSchema,
+  validateTransferPayload: () => validateTransferPayload
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_core = require("@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 import_core.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 import_core.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 import_core.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 import_core.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 import_core.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
+var import_core2 = require("@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 import_core2.MovementError(
+      `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
+var import_core3 = require("@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 import_core3.MovementError(
+      `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 import_core3.MovementError(
+        "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 import_core3.MovementError(
+      `Invalid function identifier: ${payload.function}`,
+      "INVALID_ARGUMENT",
+      {
+        argument: "function",
+        value: payload.function,
+        expectedFormat: "0xADDRESS::module::function"
+      }
+    );
+  }
+  if (!Array.isArray(payload.typeArguments)) {
+    throw new import_core3.MovementError(
+      "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 import_core3.MovementError(
+        `typeArguments[${i}] must be a string`,
+        "INVALID_ARGUMENT",
+        { argument: `typeArguments[${i}]`, value: payload.typeArguments[i] }
+      );
+    }
+  }
+  if (!Array.isArray(payload.arguments)) {
+    throw new import_core3.MovementError(
+      "arguments must be an array",
+      "INVALID_ARGUMENT",
+      { argument: "arguments", value: payload.arguments }
+    );
+  }
+  return true;
+}
+function validatePayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new import_core3.MovementError(
+      "Payload must be an object",
+      "INVALID_ARGUMENT",
+      { argument: "payload", value: payload }
+    );
+  }
+  if (payload.type !== "entry_function_payload") {
+    throw new import_core3.MovementError(
+      `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 import_core3.MovementError(
+      "Amount must be a string",
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount }
+    );
+  }
+  const numValue = Number(amount);
+  if (isNaN(numValue)) {
+    throw new import_core3.MovementError(
+      `Invalid amount: "${amount}" is not a valid number`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "not a number" }
+    );
+  }
+  if (numValue < 0) {
+    throw new import_core3.MovementError(
+      `Invalid amount: "${amount}" cannot be negative`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "negative value" }
+    );
+  }
+  if (numValue === 0) {
+    throw new import_core3.MovementError(
+      `Invalid amount: "${amount}" cannot be zero`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "zero value" }
+    );
+  }
+  if (!Number.isInteger(numValue)) {
+    throw new import_core3.MovementError(
+      `Invalid amount: "${amount}" must be a whole number (no decimals)`,
+      "INVALID_ARGUMENT",
+      { argument: "amount", value: amount, reason: "contains decimals" }
+    );
+  }
+}
+
+// src/validators/schema.ts
+var import_superstruct = require("superstruct");
+var import_core4 = require("@movebridge/core");
+var PREDEFINED_SCHEMAS = {
+  Resource: (0, import_superstruct.object)({
+    type: (0, import_superstruct.string)(),
+    data: (0, import_superstruct.record)((0, import_superstruct.string)(), (0, import_superstruct.unknown)())
+  }),
+  Transaction: (0, import_superstruct.object)({
+    hash: (0, import_superstruct.string)(),
+    sender: (0, import_superstruct.string)(),
+    sequenceNumber: (0, import_superstruct.string)(),
+    payload: (0, import_superstruct.object)({
+      type: (0, import_superstruct.literal)("entry_function_payload"),
+      function: (0, import_superstruct.string)(),
+      typeArguments: (0, import_superstruct.array)((0, import_superstruct.string)()),
+      arguments: (0, import_superstruct.array)((0, import_superstruct.unknown)())
+    }),
+    timestamp: (0, import_superstruct.string)()
+  }),
+  TransactionResponse: (0, import_superstruct.object)({
+    hash: (0, import_superstruct.string)(),
+    success: (0, import_superstruct.boolean)(),
+    vmStatus: (0, import_superstruct.string)(),
+    gasUsed: (0, import_superstruct.string)(),
+    events: (0, import_superstruct.array)(
+      (0, import_superstruct.object)({
+        type: (0, import_superstruct.string)(),
+        sequenceNumber: (0, import_superstruct.string)(),
+        data: (0, import_superstruct.record)((0, import_superstruct.string)(), (0, import_superstruct.unknown)())
+      })
+    )
+  }),
+  WalletState: (0, import_superstruct.object)({
+    connected: (0, import_superstruct.boolean)(),
+    address: (0, import_superstruct.nullable)((0, import_superstruct.string)()),
+    publicKey: (0, import_superstruct.nullable)((0, import_superstruct.string)())
+  }),
+  ContractEvent: (0, import_superstruct.object)({
+    type: (0, import_superstruct.string)(),
+    sequenceNumber: (0, import_superstruct.string)(),
+    data: (0, import_superstruct.record)((0, import_superstruct.string)(), (0, import_superstruct.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 import_core4.MovementError(
+    `Unknown schema: ${name}`,
+    "INVALID_ARGUMENT",
+    {
+      schemaName: name,
+      availableSchemas: [
+        ...Object.keys(PREDEFINED_SCHEMAS),
+        ...customSchemas.keys()
+      ]
+    }
+  );
+}
+function validateSchema(data, schemaName) {
+  const schema = getSchema(schemaName);
+  const [error] = (0, import_superstruct.validate)(data, schema);
+  return error === void 0;
+}
+function getValidationErrors(data, schemaName) {
+  const schema = getSchema(schemaName);
+  const [error] = (0, import_superstruct.validate)(data, schema);
+  if (!error) {
+    return [];
+  }
+  return convertStructError(error);
+}
+function registerSchema(name, schema) {
+  if (name in PREDEFINED_SCHEMAS) {
+    throw new import_core4.MovementError(
+      `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
+var import_core5 = require("@movebridge/core");
+function createIntegrationUtils(network) {
+  if (network !== "testnet") {
+    throw new import_core5.MovementError(
+      "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 import_core5.MovementError(
+        "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 import_core5.MovementError(
+        "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 import_core5.MovementError(
+        "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);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PREDEFINED_SCHEMAS,
+  createCallTracker,
+  createFaker,
+  createIntegrationUtils,
+  createMockClient,
+  createNetworkSimulator,
+  createSnapshotUtils,
+  createTestHarness,
+  getAddressValidationDetails,
+  getValidationErrors,
+  hasSchema,
+  isValidAddress,
+  normalizeAddress,
+  registerSchema,
+  validateAddress,
+  validateEntryFunctionPayload,
+  validatePayload,
+  validateSchema,
+  validateTransferPayload
+});