@movebridge/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,973 @@
+// src/client.ts
+import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+
+// src/config.ts
+var NETWORK_CONFIG = {
+  mainnet: {
+    chainId: 126,
+    rpcUrl: "https://full.mainnet.movementinfra.xyz/v1",
+    indexerUrl: "https://indexer.mainnet.movementnetwork.xyz/v1/graphql",
+    explorerUrl: "https://explorer.movementnetwork.xyz/?network=mainnet"
+  },
+  testnet: {
+    chainId: 250,
+    rpcUrl: "https://testnet.movementnetwork.xyz/v1",
+    indexerUrl: null,
+    explorerUrl: "https://explorer.movementnetwork.xyz/?network=bardock+testnet",
+    faucetUrl: "https://faucet.testnet.movementnetwork.xyz/"
+  }
+};
+var DEFAULT_COIN_TYPE = "0x1::aptos_coin::AptosCoin";
+function resolveConfig(config) {
+  const networkConfig = NETWORK_CONFIG[config.network];
+  return {
+    network: config.network,
+    chainId: networkConfig.chainId,
+    rpcUrl: config.rpcUrl ?? networkConfig.rpcUrl,
+    indexerUrl: config.indexerUrl ?? networkConfig.indexerUrl,
+    explorerUrl: networkConfig.explorerUrl,
+    autoConnect: config.autoConnect ?? false
+  };
+}
+function isValidAddress(address) {
+  const addressRegex = /^0x[a-fA-F0-9]{1,64}$/;
+  return addressRegex.test(address);
+}
+function isValidEventHandle(eventHandle) {
+  const eventHandleRegex = /^0x[a-fA-F0-9]{1,64}::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;
+  return eventHandleRegex.test(eventHandle);
+}
+function getExplorerTxUrl(network, txHash) {
+  const config = NETWORK_CONFIG[network];
+  return `${config.explorerUrl}&txn=${txHash}`;
+}
+function getExplorerAccountUrl(network, address) {
+  const config = NETWORK_CONFIG[network];
+  return `${config.explorerUrl}&account=${address}`;
+}
+
+// src/errors.ts
+var MovementError = class _MovementError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _MovementError);
+    }
+    Object.setPrototypeOf(this, _MovementError.prototype);
+  }
+  name = "MovementError";
+  /**
+   * Serializes the error to a JSON-compatible object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+  /**
+   * Creates a string representation of the error
+   */
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+};
+var Errors = {
+  /**
+   * Creates an invalid address error
+   */
+  invalidAddress(address, reason) {
+    return new MovementError(
+      `Invalid address: ${address}${reason ? ` - ${reason}` : ""}`,
+      "INVALID_ADDRESS",
+      { address, reason }
+    );
+  },
+  /**
+   * Creates a wallet not found error
+   */
+  walletNotFound(wallet, available) {
+    return new MovementError(
+      `Wallet "${wallet}" not found. Available wallets: ${available.join(", ") || "none"}`,
+      "WALLET_NOT_FOUND",
+      { wallet, available }
+    );
+  },
+  /**
+   * Creates a wallet connection failed error
+   */
+  walletConnectionFailed(wallet, originalError) {
+    const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+    return new MovementError(
+      `Failed to connect to wallet "${wallet}": ${errorMessage}`,
+      "WALLET_CONNECTION_FAILED",
+      { wallet, originalError }
+    );
+  },
+  /**
+   * Creates a wallet not connected error
+   */
+  walletNotConnected() {
+    return new MovementError(
+      "No wallet connected. Please connect a wallet first.",
+      "WALLET_NOT_CONNECTED"
+    );
+  },
+  /**
+   * Creates a transaction failed error
+   */
+  transactionFailed(hash, vmStatus, gasUsed) {
+    return new MovementError(
+      `Transaction ${hash} failed with status: ${vmStatus}`,
+      "TRANSACTION_FAILED",
+      { hash, vmStatus, gasUsed }
+    );
+  },
+  /**
+   * Creates a transaction timeout error
+   */
+  transactionTimeout(hash) {
+    return new MovementError(
+      `Transaction ${hash} timed out waiting for confirmation`,
+      "TRANSACTION_TIMEOUT",
+      { hash }
+    );
+  },
+  /**
+   * Creates a view function failed error
+   */
+  viewFunctionFailed(functionName, args, originalError) {
+    const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+    return new MovementError(
+      `View function "${functionName}" failed: ${errorMessage}`,
+      "VIEW_FUNCTION_FAILED",
+      { function: functionName, args, originalError }
+    );
+  },
+  /**
+   * Creates an invalid event handle error
+   */
+  invalidEventHandle(eventHandle) {
+    return new MovementError(
+      `Invalid event handle format: ${eventHandle}`,
+      "INVALID_EVENT_HANDLE",
+      { eventHandle, expectedFormat: "0xADDRESS::module::EventType" }
+    );
+  },
+  /**
+   * Creates a network error
+   */
+  networkError(url, httpStatus, responseBody) {
+    return new MovementError(
+      `Network request to ${url} failed${httpStatus ? ` with status ${httpStatus}` : ""}`,
+      "NETWORK_ERROR",
+      { url, httpStatus, responseBody }
+    );
+  },
+  /**
+   * Creates an ABI fetch failed error
+   */
+  abiFetchFailed(address, network, originalError) {
+    const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+    return new MovementError(
+      `Failed to fetch ABI for ${address} on ${network}: ${errorMessage}`,
+      "ABI_FETCH_FAILED",
+      { address, network, originalError }
+    );
+  },
+  /**
+   * Creates a codegen failed error
+   */
+  codegenFailed(reason, abi) {
+    return new MovementError(
+      `Code generation failed: ${reason}`,
+      "CODEGEN_FAILED",
+      { reason, abi }
+    );
+  },
+  /**
+   * Creates an invalid argument error
+   */
+  invalidArgument(argument, reason) {
+    return new MovementError(
+      `Invalid argument "${argument}": ${reason}`,
+      "INVALID_ARGUMENT",
+      { argument, reason }
+    );
+  }
+};
+function isMovementError(error) {
+  return error instanceof MovementError;
+}
+function wrapError(error, code, context) {
+  if (isMovementError(error)) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new MovementError(
+    context ? `${context}: ${message}` : message,
+    code,
+    { originalError: error }
+  );
+}
+
+// src/wallet.ts
+import EventEmitter from "eventemitter3";
+import { getAptosWallets } from "@aptos-labs/wallet-standard";
+var SUPPORTED_WALLETS = {
+  "petra": "petra",
+  "petra wallet": "petra",
+  "pontem": "pontem",
+  "pontem wallet": "pontem",
+  "nightly": "nightly",
+  "nightly wallet": "nightly"
+};
+var STORAGE_KEY = "movebridge:lastWallet";
+function toHexString(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof Uint8Array) {
+    return "0x" + Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (data && typeof data.toString === "function") {
+    return data.toString();
+  }
+  return String(data);
+}
+function createStandardAdapter(wallet) {
+  const connectFeature = wallet.features?.["aptos:connect"];
+  const disconnectFeature = wallet.features?.["aptos:disconnect"];
+  const signTxFeature = wallet.features?.["aptos:signAndSubmitTransaction"];
+  const signOnlyFeature = wallet.features?.["aptos:signTransaction"];
+  const accountChangeFeature = wallet.features?.["aptos:onAccountChange"];
+  const networkChangeFeature = wallet.features?.["aptos:onNetworkChange"];
+  return {
+    name: wallet.name,
+    icon: wallet.icon || "",
+    async connect() {
+      if (!connectFeature) throw new Error("Wallet does not support connect");
+      const response = await connectFeature.connect();
+      const result = response?.args ?? response;
+      if (response?.status === "rejected") {
+        throw new Error("User rejected the connection");
+      }
+      return {
+        address: toHexString(result.address),
+        publicKey: toHexString(result.publicKey)
+      };
+    },
+    async disconnect() {
+      if (disconnectFeature) await disconnectFeature.disconnect();
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async signAndSubmitTransaction(payload) {
+      if (!signTxFeature) throw new Error("Wallet does not support signAndSubmitTransaction");
+      const response = await signTxFeature.signAndSubmitTransaction(payload);
+      if (response?.status === "rejected") {
+        throw new Error("User rejected the transaction");
+      }
+      const result = response?.args ?? response;
+      return { hash: result.hash || toHexString(result) };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async signTransaction(payload) {
+      if (!signOnlyFeature) throw new Error("Wallet does not support signTransaction");
+      const response = await signOnlyFeature.signTransaction(payload);
+      if (response?.status === "rejected") {
+        throw new Error("User rejected the transaction");
+      }
+      const result = response?.args ?? response;
+      return result.authenticator || result.signature || new Uint8Array();
+    },
+    onAccountChange(cb) {
+      if (accountChangeFeature) {
+        accountChangeFeature.onAccountChange((account) => {
+          if (account) {
+            cb({ address: toHexString(account.address), publicKey: toHexString(account.publicKey) });
+          } else {
+            cb(null);
+          }
+        });
+      }
+    },
+    onNetworkChange(cb) {
+      if (networkChangeFeature) {
+        networkChangeFeature.onNetworkChange((network) => {
+          cb(network?.name || String(network));
+        });
+      }
+    }
+  };
+}
+var WalletManager = class extends EventEmitter {
+  state = { connected: false, address: null, publicKey: null };
+  currentWallet = null;
+  adapter = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  standardWallets = /* @__PURE__ */ new Map();
+  detectedWallets = [];
+  unsubscribe = null;
+  detectWallets() {
+    if (typeof window === "undefined") return [];
+    const available = /* @__PURE__ */ new Set();
+    this.standardWallets.clear();
+    try {
+      const { aptosWallets, on } = getAptosWallets();
+      if (this.unsubscribe) this.unsubscribe();
+      this.unsubscribe = on("register", () => this.detectWallets());
+      for (const wallet of aptosWallets) {
+        const normalizedName = wallet.name.toLowerCase();
+        const walletType = SUPPORTED_WALLETS[normalizedName];
+        if (walletType) {
+          available.add(walletType);
+          this.standardWallets.set(walletType, wallet);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to detect wallets via AIP-62 standard:", error);
+    }
+    this.detectedWallets = Array.from(available);
+    return this.detectedWallets;
+  }
+  getWalletInfo() {
+    return this.detectedWallets.map((type) => {
+      const wallet = this.standardWallets.get(type);
+      return { type, name: wallet?.name || type, icon: wallet?.icon || "" };
+    });
+  }
+  async connect(wallet) {
+    const available = this.detectWallets();
+    if (!available.includes(wallet)) throw Errors.walletNotFound(wallet, available);
+    try {
+      const standardWallet = this.standardWallets.get(wallet);
+      if (!standardWallet) throw new Error(`Wallet ${wallet} not found`);
+      this.adapter = createStandardAdapter(standardWallet);
+      const result = await this.adapter.connect();
+      this.state = { connected: true, address: result.address, publicKey: result.publicKey };
+      this.currentWallet = wallet;
+      this.saveLastWallet(wallet);
+      this.setupEventListeners();
+      this.emit("connect", result.address);
+    } catch (error) {
+      this.adapter = null;
+      throw Errors.walletConnectionFailed(wallet, error);
+    }
+  }
+  async disconnect() {
+    if (this.adapter) {
+      try {
+        await this.adapter.disconnect();
+      } catch {
+      }
+    }
+    this.state = { connected: false, address: null, publicKey: null };
+    this.currentWallet = null;
+    this.adapter = null;
+    this.clearLastWallet();
+    this.emit("disconnect");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getWallet() {
+    return this.currentWallet;
+  }
+  getAdapter() {
+    return this.adapter;
+  }
+  async autoConnect() {
+    const lastWallet = this.getLastWallet();
+    if (!lastWallet) return;
+    const available = this.detectWallets();
+    if (available.includes(lastWallet)) {
+      try {
+        await this.connect(lastWallet);
+      } catch {
+        this.clearLastWallet();
+      }
+    }
+  }
+  destroy() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+  }
+  setupEventListeners() {
+    if (!this.adapter) return;
+    this.adapter.onAccountChange((account) => {
+      if (account) {
+        this.state = { connected: true, address: account.address, publicKey: account.publicKey };
+        this.emit("accountChanged", account.address);
+      } else {
+        this.state = { connected: false, address: null, publicKey: null };
+        this.emit("disconnect");
+      }
+    });
+    this.adapter.onNetworkChange((network) => this.emit("networkChanged", network));
+  }
+  saveLastWallet(wallet) {
+    try {
+      if (typeof localStorage !== "undefined") localStorage.setItem(STORAGE_KEY, wallet);
+    } catch {
+    }
+  }
+  getLastWallet() {
+    try {
+      if (typeof localStorage !== "undefined") {
+        const wallet = localStorage.getItem(STORAGE_KEY);
+        if (wallet && Object.values(SUPPORTED_WALLETS).includes(wallet)) {
+          return wallet;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  clearLastWallet() {
+    try {
+      if (typeof localStorage !== "undefined") localStorage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+};
+
+// src/transaction.ts
+var TransactionBuilder = class {
+  constructor(aptosClient, walletManager) {
+    this.aptosClient = aptosClient;
+    this.walletManager = walletManager;
+  }
+  /**
+   * Builds a transfer transaction payload
+   * @param options - Transfer options
+   * @returns Transaction payload
+   */
+  async transfer(options) {
+    const coinType = options.coinType ?? DEFAULT_COIN_TYPE;
+    return {
+      type: "entry_function_payload",
+      function: "0x1::coin::transfer",
+      typeArguments: [coinType],
+      arguments: [options.to, options.amount]
+    };
+  }
+  /**
+   * Builds a generic transaction payload
+   * @param options - Build options
+   * @returns Transaction payload
+   */
+  async build(options) {
+    return {
+      type: "entry_function_payload",
+      function: options.function,
+      typeArguments: options.typeArguments,
+      arguments: options.arguments
+    };
+  }
+  /**
+   * Signs a transaction payload
+   * @param payload - Transaction payload to sign
+   * @returns Signed transaction
+   * @throws MovementError with code WALLET_NOT_CONNECTED if no wallet is connected
+   */
+  async sign(payload) {
+    const adapter = this.walletManager.getAdapter();
+    const state = this.walletManager.getState();
+    if (!adapter || !state.connected || !state.address) {
+      throw Errors.walletNotConnected();
+    }
+    try {
+      const signatureBytes = await adapter.signTransaction({
+        type: payload.type,
+        function: payload.function,
+        type_arguments: payload.typeArguments,
+        arguments: payload.arguments
+      });
+      const signature = Array.from(signatureBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+      return {
+        payload,
+        signature: `0x${signature}`,
+        sender: state.address
+      };
+    } catch (error) {
+      throw wrapError(error, "TRANSACTION_FAILED", "Failed to sign transaction");
+    }
+  }
+  /**
+   * Submits a signed transaction to the network
+   * @param signed - Signed transaction
+   * @returns Transaction hash
+   */
+  async submit(signed) {
+    const adapter = this.walletManager.getAdapter();
+    if (!adapter) {
+      throw Errors.walletNotConnected();
+    }
+    try {
+      const result = await adapter.signAndSubmitTransaction({
+        type: signed.payload.type,
+        function: signed.payload.function,
+        type_arguments: signed.payload.typeArguments,
+        arguments: signed.payload.arguments
+      });
+      return result.hash;
+    } catch (error) {
+      throw wrapError(error, "TRANSACTION_FAILED", "Failed to submit transaction");
+    }
+  }
+  /**
+   * Signs and submits a transaction in one step
+   * @param payload - Transaction payload
+   * @returns Transaction hash
+   */
+  async signAndSubmit(payload) {
+    const adapter = this.walletManager.getAdapter();
+    if (!adapter) {
+      throw Errors.walletNotConnected();
+    }
+    try {
+      const result = await adapter.signAndSubmitTransaction({
+        type: payload.type,
+        function: payload.function,
+        type_arguments: payload.typeArguments,
+        arguments: payload.arguments
+      });
+      return result.hash;
+    } catch (error) {
+      throw wrapError(error, "TRANSACTION_FAILED", "Failed to sign and submit transaction");
+    }
+  }
+  /**
+   * Simulates a transaction without submitting
+   * @param payload - Transaction payload
+   * @returns Simulation result with gas estimate
+   */
+  async simulate(payload) {
+    const state = this.walletManager.getState();
+    if (!state.connected || !state.address) {
+      throw Errors.walletNotConnected();
+    }
+    try {
+      const client = this.aptosClient;
+      const result = await client.transaction.simulate.simple({
+        sender: state.address,
+        data: {
+          function: payload.function,
+          typeArguments: payload.typeArguments,
+          functionArguments: payload.arguments
+        }
+      });
+      const simResult = result[0];
+      return {
+        success: simResult?.success ?? false,
+        gasUsed: String(simResult?.gas_used ?? "0"),
+        vmStatus: String(simResult?.vm_status ?? "unknown")
+      };
+    } catch (error) {
+      throw wrapError(error, "TRANSACTION_FAILED", "Failed to simulate transaction");
+    }
+  }
+};
+
+// src/contract.ts
+var ContractInterface = class {
+  constructor(aptosClient, walletManager, options) {
+    this.aptosClient = aptosClient;
+    this.walletManager = walletManager;
+    this.address = options.address;
+    this.module = options.module;
+  }
+  /** Contract address */
+  address;
+  /** Module name */
+  module;
+  /**
+   * Calls a view function (read-only)
+   * @param functionName - Name of the view function
+   * @param args - Function arguments
+   * @param typeArgs - Type arguments (optional)
+   * @returns Function result
+   * @throws MovementError with code VIEW_FUNCTION_FAILED if call fails
+   */
+  async view(functionName, args, typeArgs = []) {
+    const fullFunctionName = `${this.address}::${this.module}::${functionName}`;
+    try {
+      const client = this.aptosClient;
+      const result = await client.view({
+        payload: {
+          function: fullFunctionName,
+          typeArguments: typeArgs,
+          functionArguments: args
+        }
+      });
+      return result.length === 1 ? result[0] : result;
+    } catch (error) {
+      throw Errors.viewFunctionFailed(fullFunctionName, args, error);
+    }
+  }
+  /**
+   * Calls an entry function (write operation)
+   * @param functionName - Name of the entry function
+   * @param args - Function arguments
+   * @param typeArgs - Type arguments (optional)
+   * @returns Transaction hash
+   * @throws MovementError with code WALLET_NOT_CONNECTED if no wallet is connected
+   * @throws MovementError with code TRANSACTION_FAILED if transaction fails
+   */
+  async call(functionName, args, typeArgs = []) {
+    const adapter = this.walletManager.getAdapter();
+    const state = this.walletManager.getState();
+    if (!adapter || !state.connected) {
+      throw Errors.walletNotConnected();
+    }
+    const fullFunctionName = `${this.address}::${this.module}::${functionName}`;
+    try {
+      const result = await adapter.signAndSubmitTransaction({
+        type: "entry_function_payload",
+        function: fullFunctionName,
+        type_arguments: typeArgs,
+        arguments: args
+      });
+      return result.hash;
+    } catch (error) {
+      throw wrapError(error, "TRANSACTION_FAILED", `Failed to call ${fullFunctionName}`);
+    }
+  }
+  /**
+   * Checks if a resource exists at the contract address
+   * @param resourceType - Full resource type (e.g., '0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>')
+   * @returns true if resource exists
+   */
+  async hasResource(resourceType) {
+    try {
+      const client = this.aptosClient;
+      await client.getAccountResource({
+        accountAddress: this.address,
+        resourceType
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gets a resource from the contract address
+   * @param resourceType - Full resource type
+   * @returns Resource data or null if not found
+   */
+  async getResource(resourceType) {
+    try {
+      const client = this.aptosClient;
+      const resource = await client.getAccountResource({
+        accountAddress: this.address,
+        resourceType
+      });
+      return resource;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Gets the full function name for a function in this module
+   * @param functionName - Function name
+   * @returns Full function name (address::module::function)
+   */
+  getFullFunctionName(functionName) {
+    return `${this.address}::${this.module}::${functionName}`;
+  }
+};
+
+// src/events.ts
+var EventListener = class {
+  constructor(aptosClient, options) {
+    this.aptosClient = aptosClient;
+    this.pollIntervalMs = options?.pollIntervalMs ?? 3e3;
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  subscriptionCounter = 0;
+  pollIntervalMs;
+  /**
+   * Subscribes to contract events
+   * @param subscription - Subscription configuration
+   * @returns Subscription ID
+   * @throws MovementError with code INVALID_EVENT_HANDLE if event handle is invalid
+   */
+  subscribe(subscription) {
+    if (!isValidEventHandle(subscription.eventHandle)) {
+      throw Errors.invalidEventHandle(subscription.eventHandle);
+    }
+    const subscriptionId = `sub_${++this.subscriptionCounter}`;
+    const internalSub = {
+      eventHandle: subscription.eventHandle,
+      callback: subscription.callback,
+      lastSequenceNumber: "0",
+      intervalId: null
+    };
+    internalSub.intervalId = setInterval(() => {
+      this.pollEvents(subscriptionId).catch(() => {
+      });
+    }, this.pollIntervalMs);
+    this.pollEvents(subscriptionId).catch(() => {
+    });
+    this.subscriptions.set(subscriptionId, internalSub);
+    return subscriptionId;
+  }
+  /**
+   * Unsubscribes from events
+   * @param subscriptionId - Subscription ID to remove
+   */
+  unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (subscription) {
+      if (subscription.intervalId) {
+        clearInterval(subscription.intervalId);
+      }
+      this.subscriptions.delete(subscriptionId);
+    }
+  }
+  /**
+   * Unsubscribes from all events
+   */
+  unsubscribeAll() {
+    for (const [id] of this.subscriptions) {
+      this.unsubscribe(id);
+    }
+  }
+  /**
+   * Gets active subscription count
+   * @returns Number of active subscriptions
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Checks if a subscription exists
+   * @param subscriptionId - Subscription ID
+   * @returns true if subscription exists
+   */
+  hasSubscription(subscriptionId) {
+    return this.subscriptions.has(subscriptionId);
+  }
+  /**
+   * Polls for new events
+   * @param subscriptionId - Subscription ID
+   */
+  async pollEvents(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      return;
+    }
+    try {
+      const parts = subscription.eventHandle.split("::");
+      if (parts.length !== 3) {
+        return;
+      }
+      const [address, module, eventType] = parts;
+      const eventHandleStruct = `${address}::${module}::${eventType}`;
+      const client = this.aptosClient;
+      const events = await client.getAccountEventsByEventType({
+        accountAddress: address,
+        eventType: eventHandleStruct,
+        options: {
+          limit: 25
+        }
+      });
+      for (const event of events) {
+        const sequenceNumber = event.sequence_number?.toString() ?? "0";
+        if (BigInt(sequenceNumber) > BigInt(subscription.lastSequenceNumber)) {
+          const contractEvent = {
+            type: event.type,
+            sequenceNumber,
+            data: event.data
+          };
+          subscription.callback(contractEvent);
+          subscription.lastSequenceNumber = sequenceNumber;
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/client.ts
+var Movement = class {
+  /** Resolved configuration */
+  config;
+  /** Aptos SDK client instance */
+  aptosClient;
+  /** Wallet manager instance */
+  wallet;
+  /** Transaction builder instance */
+  transaction;
+  /** Event listener instance */
+  events;
+  /**
+   * Creates a new Movement client
+   * @param config - Configuration options
+   */
+  constructor(config) {
+    this.config = resolveConfig(config);
+    const aptosConfigOptions = {
+      network: Network.CUSTOM,
+      fullnode: this.config.rpcUrl
+    };
+    if (this.config.indexerUrl) {
+      aptosConfigOptions.indexer = this.config.indexerUrl;
+    }
+    const aptosConfig = new AptosConfig(aptosConfigOptions);
+    this.aptosClient = new Aptos(aptosConfig);
+    this.wallet = new WalletManager();
+    this.transaction = new TransactionBuilder(this.aptosClient, this.wallet);
+    this.events = new EventListener(this.aptosClient);
+    if (this.config.autoConnect) {
+      this.wallet.autoConnect().catch(() => {
+      });
+    }
+  }
+  /**
+   * Gets the underlying Aptos client
+   * @returns Aptos SDK client instance
+   */
+  getAptosClient() {
+    return this.aptosClient;
+  }
+  /**
+   * Gets the account balance for an address
+   * @param address - Account address
+   * @returns Balance as string in smallest unit (octas)
+   * @throws MovementError with code INVALID_ADDRESS if address is invalid
+   */
+  async getAccountBalance(address) {
+    if (!isValidAddress(address)) {
+      throw Errors.invalidAddress(address, "Invalid address format");
+    }
+    try {
+      const resources = await this.aptosClient.getAccountResources({
+        accountAddress: address
+      });
+      const coinResource = resources.find(
+        (r) => r.type === "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"
+      );
+      if (!coinResource) {
+        return "0";
+      }
+      const data = coinResource.data;
+      return data.coin.value;
+    } catch (error) {
+      throw wrapError(error, "NETWORK_ERROR", `Failed to get balance for ${address}`);
+    }
+  }
+  /**
+   * Gets all resources for an account
+   * @param address - Account address
+   * @returns Array of resources
+   * @throws MovementError with code INVALID_ADDRESS if address is invalid
+   */
+  async getAccountResources(address) {
+    if (!isValidAddress(address)) {
+      throw Errors.invalidAddress(address, "Invalid address format");
+    }
+    try {
+      const resources = await this.aptosClient.getAccountResources({
+        accountAddress: address
+      });
+      return resources.map((r) => ({
+        type: r.type,
+        data: r.data
+      }));
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Account not found")) {
+        return [];
+      }
+      throw wrapError(error, "NETWORK_ERROR", `Failed to get resources for ${address}`);
+    }
+  }
+  /**
+   * Gets a transaction by hash
+   * @param hash - Transaction hash
+   * @returns Transaction data
+   */
+  async getTransaction(hash) {
+    try {
+      const tx = await this.aptosClient.getTransactionByHash({ transactionHash: hash });
+      const userTx = tx;
+      return {
+        hash: userTx.hash,
+        sender: userTx.sender,
+        sequenceNumber: userTx.sequence_number,
+        payload: {
+          type: "entry_function_payload",
+          function: userTx.payload?.function ?? "",
+          typeArguments: userTx.payload?.type_arguments ?? [],
+          arguments: userTx.payload?.arguments ?? []
+        },
+        timestamp: userTx.timestamp
+      };
+    } catch (error) {
+      throw wrapError(error, "NETWORK_ERROR", `Failed to get transaction ${hash}`);
+    }
+  }
+  /**
+   * Waits for a transaction to be confirmed
+   * @param hash - Transaction hash
+   * @param options - Wait options
+   * @returns Transaction response
+   */
+  async waitForTransaction(hash, options) {
+    const timeoutMs = options?.timeoutMs ?? 3e4;
+    const checkIntervalMs = options?.checkIntervalMs ?? 1e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const tx = await this.aptosClient.getTransactionByHash({ transactionHash: hash });
+        if ("success" in tx) {
+          const committedTx = tx;
+          return {
+            hash: committedTx.hash,
+            success: committedTx.success,
+            vmStatus: committedTx.vm_status,
+            gasUsed: committedTx.gas_used,
+            events: committedTx.events.map((e) => ({
+              type: e.type,
+              sequenceNumber: e.sequence_number,
+              data: e.data
+            }))
+          };
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkIntervalMs));
+    }
+    throw Errors.transactionTimeout(hash);
+  }
+  /**
+   * Creates a contract interface for interacting with a Move module
+   * @param options - Contract options
+   * @returns Contract interface
+   */
+  contract(options) {
+    return new ContractInterface(this.aptosClient, this.wallet, options);
+  }
+};
+export {
+  ContractInterface,
+  DEFAULT_COIN_TYPE,
+  Errors,
+  EventListener,
+  Movement,
+  MovementError,
+  NETWORK_CONFIG,
+  TransactionBuilder,
+  WalletManager,
+  getExplorerAccountUrl,
+  getExplorerTxUrl,
+  isMovementError,
+  isValidAddress,
+  isValidEventHandle,
+  resolveConfig,
+  wrapError
+};