@movebridge/core 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -12,7 +12,7 @@ var NETWORK_CONFIG = {
   testnet: {
     chainId: 250,
     rpcUrl: "https://testnet.movementnetwork.xyz/v1",
-    indexerUrl: null,
+    indexerUrl: "https://hasura.testnet.movementnetwork.xyz/v1/graphql",
     explorerUrl: "https://explorer.movementnetwork.xyz/?network=bardock+testnet",
     faucetUrl: "https://faucet.testnet.movementnetwork.xyz/"
   }
@@ -229,6 +229,56 @@ var SUPPORTED_WALLETS = {
   "okxwallet": "okx"
 };
 var STORAGE_KEY = "movebridge:lastWallet";
+function normalizeHash(data) {
+  if (data === null || data === void 0) {
+    throw new Error("Invalid hash: received null or undefined");
+  }
+  if (typeof data === "string") {
+    const trimmed = data.trim();
+    if (!trimmed) {
+      throw new Error("Invalid hash: received empty string");
+    }
+    return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+  }
+  if (data instanceof Uint8Array) {
+    if (data.length === 0) {
+      throw new Error("Invalid hash: received empty Uint8Array");
+    }
+    return "0x" + Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (data instanceof ArrayBuffer) {
+    const arr = new Uint8Array(data);
+    if (arr.length === 0) {
+      throw new Error("Invalid hash: received empty ArrayBuffer");
+    }
+    return "0x" + Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (data && typeof data === "object") {
+    if ("hash" in data) {
+      return normalizeHash(data.hash);
+    }
+    if ("txnHash" in data) {
+      return normalizeHash(data.txnHash);
+    }
+    if ("transactionHash" in data) {
+      return normalizeHash(data.transactionHash);
+    }
+    if ("output" in data) {
+      return normalizeHash(data.output);
+    }
+    if (typeof data.toString === "function") {
+      const str = data.toString();
+      if (str !== "[object Object]") {
+        return str.startsWith("0x") ? str : `0x${str}`;
+      }
+    }
+  }
+  const strValue = String(data);
+  if (strValue === "[object Object]" || !strValue) {
+    throw new Error("Invalid hash: could not extract hash from response");
+  }
+  return strValue.startsWith("0x") ? strValue : `0x${strValue}`;
+}
 function toHexString(data) {
   if (typeof data === "string") return data;
   if (data instanceof Uint8Array) {
@@ -239,56 +289,159 @@ function toHexString(data) {
   }
   return String(data);
 }
+function extractUserResponse(response) {
+  if (!response) {
+    throw new Error("Empty response from wallet");
+  }
+  if (typeof response === "string" || typeof response === "number") {
+    return response;
+  }
+  if (response instanceof Uint8Array) {
+    return response;
+  }
+  const resp = response;
+  if (resp.status === "rejected" || resp.status === "Rejected") {
+    throw new Error("User rejected the request");
+  }
+  if (resp.status === "error" || resp.error) {
+    const errorMsg = resp.error || resp.message || "Transaction failed";
+    throw new Error(String(errorMsg));
+  }
+  if (resp.args !== void 0) {
+    return resp.args;
+  }
+  if (resp.status === "approved" && resp.output !== void 0) {
+    return resp.output;
+  }
+  if (resp.result !== void 0) {
+    return resp.result;
+  }
+  if (resp.data !== void 0) {
+    return resp.data;
+  }
+  return response;
+}
 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"];
+  const features = wallet.features || {};
+  const connectFeature = features["aptos:connect"];
+  const disconnectFeature = features["aptos:disconnect"];
+  const signTxFeature = features["aptos:signAndSubmitTransaction"];
+  const signOnlyFeature = features["aptos:signTransaction"];
+  const accountChangeFeature = features["aptos:onAccountChange"];
+  const networkChangeFeature = 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");
+      if (!connectFeature) {
+        throw new Error("Wallet does not support connect");
       }
+      const response = await connectFeature.connect();
+      const result = extractUserResponse(response);
       return {
         address: toHexString(result.address),
         publicKey: toHexString(result.publicKey)
       };
     },
     async disconnect() {
-      if (disconnectFeature) await disconnectFeature.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");
+      if (!signTxFeature) {
+        throw new Error("Wallet does not support signAndSubmitTransaction");
+      }
+      const walletName = wallet.name.toLowerCase();
+      const isOKX = walletName.includes("okx");
+      let txPayload;
+      if (isOKX) {
+        txPayload = {
+          type: "entry_function_payload",
+          function: payload.payload.function,
+          type_arguments: payload.payload.typeArguments,
+          arguments: payload.payload.functionArguments
+        };
+      } else {
+        txPayload = payload;
+      }
+      let response;
+      try {
+        response = await signTxFeature.signAndSubmitTransaction(txPayload);
+      } catch (firstError) {
+        if (isOKX) {
+          try {
+            response = await signTxFeature.signAndSubmitTransaction(payload);
+          } catch {
+            throw firstError;
+          }
+        } else {
+          try {
+            const legacyPayload = {
+              type: "entry_function_payload",
+              function: payload.payload.function,
+              type_arguments: payload.payload.typeArguments,
+              arguments: payload.payload.functionArguments
+            };
+            response = await signTxFeature.signAndSubmitTransaction(legacyPayload);
+          } catch {
+            throw firstError;
+          }
+        }
+      }
+      const result = extractUserResponse(response);
+      try {
+        if (typeof result === "string") {
+          return { hash: normalizeHash(result) };
+        }
+        if (result && typeof result === "object") {
+          const hashObj = result;
+          if (hashObj.hash !== void 0) {
+            return { hash: normalizeHash(hashObj.hash) };
+          }
+          if (hashObj.txnHash !== void 0) {
+            return { hash: normalizeHash(hashObj.txnHash) };
+          }
+          if (hashObj.transactionHash !== void 0) {
+            return { hash: normalizeHash(hashObj.transactionHash) };
+          }
+          return { hash: normalizeHash(result) };
+        }
+        return { hash: normalizeHash(result) };
+      } catch (error) {
+        throw new Error(
+          `Failed to extract transaction hash from wallet response: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
       }
-      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");
+      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 = extractUserResponse(response);
+      if (result instanceof Uint8Array) {
+        return result;
       }
-      const result = response?.args ?? response;
-      return result.authenticator || result.signature || new Uint8Array();
+      if (result && typeof result === "object") {
+        if ("authenticator" in result && result.authenticator) {
+          return result.authenticator;
+        }
+        if ("signature" in result && result.signature) {
+          return result.signature;
+        }
+      }
+      return new Uint8Array();
     },
     onAccountChange(cb) {
       if (accountChangeFeature) {
         accountChangeFeature.onAccountChange((account) => {
-          if (account) {
-            cb({ address: toHexString(account.address), publicKey: toHexString(account.publicKey) });
+          if (account && typeof account === "object") {
+            const acc = account;
+            cb({
+              address: toHexString(acc.address),
+              publicKey: toHexString(acc.publicKey)
+            });
           } else {
             cb(null);
           }
@@ -298,7 +451,11 @@ function createStandardAdapter(wallet) {
     onNetworkChange(cb) {
       if (networkChangeFeature) {
         networkChangeFeature.onNetworkChange((network) => {
-          cb(network?.name || String(network));
+          if (network && typeof network === "object" && "name" in network) {
+            cb(network.name);
+          } else {
+            cb(String(network));
+          }
         });
       }
     }
@@ -308,17 +465,22 @@ 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;
+  /**
+   * Detects available wallets using AIP-62 standard
+   * @returns Array of detected wallet types
+   */
   detectWallets() {
     if (typeof window === "undefined") return [];
     const available = /* @__PURE__ */ new Set();
     this.standardWallets.clear();
     try {
       const { aptosWallets, on } = getAptosWallets();
-      if (this.unsubscribe) this.unsubscribe();
+      if (this.unsubscribe) {
+        this.unsubscribe();
+      }
       this.unsubscribe = on("register", () => this.detectWallets());
       for (const wallet of aptosWallets) {
         const normalizedName = wallet.name.toLowerCase();
@@ -334,21 +496,42 @@ var WalletManager = class extends EventEmitter {
     this.detectedWallets = Array.from(available);
     return this.detectedWallets;
   }
+  /**
+   * Gets detailed wallet information for UI display
+   * @returns Array of wallet info objects
+   */
   getWalletInfo() {
     return this.detectedWallets.map((type) => {
       const wallet = this.standardWallets.get(type);
-      return { type, name: wallet?.name || type, icon: wallet?.icon || "" };
+      return {
+        type,
+        name: wallet?.name || type,
+        icon: wallet?.icon || ""
+      };
     });
   }
+  /**
+   * Connects to a wallet
+   * @param wallet - Wallet type to connect to
+   * @throws MovementError if wallet not found or connection fails
+   */
   async connect(wallet) {
     const available = this.detectWallets();
-    if (!available.includes(wallet)) throw Errors.walletNotFound(wallet, available);
+    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`);
+      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.state = {
+        connected: true,
+        address: result.address,
+        publicKey: result.publicKey
+      };
       this.currentWallet = wallet;
       this.saveLastWallet(wallet);
       this.setupEventListeners();
@@ -358,6 +541,9 @@ var WalletManager = class extends EventEmitter {
       throw Errors.walletConnectionFailed(wallet, error);
     }
   }
+  /**
+   * Disconnects from the current wallet
+   */
   async disconnect() {
     if (this.adapter) {
       try {
@@ -371,15 +557,28 @@ var WalletManager = class extends EventEmitter {
     this.clearLastWallet();
     this.emit("disconnect");
   }
+  /**
+   * Gets the current wallet state
+   */
   getState() {
     return { ...this.state };
   }
+  /**
+   * Gets the currently connected wallet type
+   */
   getWallet() {
     return this.currentWallet;
   }
+  /**
+   * Gets the wallet adapter for direct access
+   * @internal
+   */
   getAdapter() {
     return this.adapter;
   }
+  /**
+   * Attempts to auto-connect to the last used wallet
+   */
   async autoConnect() {
     const lastWallet = this.getLastWallet();
     if (!lastWallet) return;
@@ -392,6 +591,9 @@ var WalletManager = class extends EventEmitter {
       }
     }
   }
+  /**
+   * Cleans up resources
+   */
   destroy() {
     if (this.unsubscribe) {
       this.unsubscribe();
@@ -402,18 +604,26 @@ var WalletManager = class extends EventEmitter {
     if (!this.adapter) return;
     this.adapter.onAccountChange((account) => {
       if (account) {
-        this.state = { connected: true, address: account.address, publicKey: account.publicKey };
+        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));
+    this.adapter.onNetworkChange((network) => {
+      this.emit("networkChanged", network);
+    });
   }
   saveLastWallet(wallet) {
     try {
-      if (typeof localStorage !== "undefined") localStorage.setItem(STORAGE_KEY, wallet);
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(STORAGE_KEY, wallet);
+      }
     } catch {
     }
   }
@@ -431,7 +641,9 @@ var WalletManager = class extends EventEmitter {
   }
   clearLastWallet() {
     try {
-      if (typeof localStorage !== "undefined") localStorage.removeItem(STORAGE_KEY);
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(STORAGE_KEY);
+      }
     } catch {
     }
   }
@@ -445,108 +657,70 @@ var TransactionBuilder = class {
   }
   /**
    * Builds a transfer transaction payload
+   * Uses 0x1::aptos_account::transfer which handles account creation
    * @param options - Transfer options
-   * @returns Transaction payload
+   * @returns Transaction payload ready for signing
    */
   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]
+      function: "0x1::aptos_account::transfer",
+      typeArguments: [],
+      functionArguments: [options.to, options.amount]
     };
   }
   /**
    * Builds a generic transaction payload
-   * @param options - Build options
-   * @returns Transaction payload
+   * @param options - Build options with function, typeArguments, and arguments
+   * @returns Transaction payload ready for signing
    */
   async build(options) {
     return {
-      type: "entry_function_payload",
       function: options.function,
       typeArguments: options.typeArguments,
-      arguments: options.arguments
+      functionArguments: 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
+   * This is the recommended method for most use cases
    * @param payload - Transaction payload
    * @returns Transaction hash
+   * @throws MovementError with code WALLET_NOT_CONNECTED if no wallet connected
+   * @throws MovementError with code TRANSACTION_FAILED if submission fails
+   * 
+   * Note: Transaction failures do NOT affect wallet connection state.
+   * The wallet remains connected even if a transaction fails.
    */
   async signAndSubmit(payload) {
     const adapter = this.walletManager.getAdapter();
-    if (!adapter) {
+    const stateBefore = this.walletManager.getState();
+    if (!adapter || !stateBefore.connected) {
       throw Errors.walletNotConnected();
     }
     try {
       const result = await adapter.signAndSubmitTransaction({
-        type: payload.type,
-        function: payload.function,
-        type_arguments: payload.typeArguments,
-        arguments: payload.arguments
+        payload: {
+          function: payload.function,
+          typeArguments: payload.typeArguments,
+          functionArguments: payload.functionArguments
+        }
       });
       return result.hash;
     } catch (error) {
-      throw wrapError(error, "TRANSACTION_FAILED", "Failed to sign and submit transaction");
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const isUserRejection = errorMessage.toLowerCase().includes("rejected") || errorMessage.toLowerCase().includes("cancelled") || errorMessage.toLowerCase().includes("canceled") || errorMessage.toLowerCase().includes("denied");
+      throw wrapError(
+        error,
+        "TRANSACTION_FAILED",
+        isUserRejection ? "Transaction was rejected by user" : "Failed to sign and submit transaction"
+      );
     }
   }
   /**
    * Simulates a transaction without submitting
+   * Useful for gas estimation and checking if transaction will succeed
    * @param payload - Transaction payload
-   * @returns Simulation result with gas estimate
+   * @returns Simulation result with success status and gas estimate
    */
   async simulate(payload) {
     const state = this.walletManager.getState();
@@ -554,16 +728,17 @@ var TransactionBuilder = class {
       throw Errors.walletNotConnected();
     }
     try {
-      const client = this.aptosClient;
-      const result = await client.transaction.simulate.simple({
+      const transaction = await this.aptosClient.transaction.build.simple({
         sender: state.address,
         data: {
           function: payload.function,
           typeArguments: payload.typeArguments,
-          functionArguments: payload.arguments
+          functionArguments: payload.functionArguments
         }
       });
-      const simResult = result[0];
+      const [simResult] = await this.aptosClient.transaction.simulate.simple({
+        transaction
+      });
       return {
         success: simResult?.success ?? false,
         gasUsed: String(simResult?.gas_used ?? "0"),
@@ -573,6 +748,15 @@ var TransactionBuilder = class {
       throw wrapError(error, "TRANSACTION_FAILED", "Failed to simulate transaction");
     }
   }
+  /**
+   * Convenience method: Transfer and wait for confirmation
+   * @param options - Transfer options
+   * @returns Transaction hash
+   */
+  async transferAndSubmit(options) {
+    const payload = await this.transfer(options);
+    return this.signAndSubmit(payload);
+  }
 };
 
 // src/contract.ts
@@ -589,17 +773,27 @@ var ContractInterface = class {
   module;
   /**
    * Calls a view function (read-only)
+   * View functions don't require a wallet connection
+   * 
    * @param functionName - Name of the view function
    * @param args - Function arguments
-   * @param typeArgs - Type arguments (optional)
+   * @param typeArgs - Type arguments for generic functions
    * @returns Function result
    * @throws MovementError with code VIEW_FUNCTION_FAILED if call fails
+   * 
+   * @example
+   * ```typescript
+   * // Get coin balance
+   * const balance = await contract.view('balance', [address], ['0x1::aptos_coin::AptosCoin']);
+   * 
+   * // Check if account exists
+   * const exists = await contract.view('exists_at', [address]);
+   * ```
    */
-  async view(functionName, args, typeArgs = []) {
+  async view(functionName, args = [], typeArgs = []) {
     const fullFunctionName = `${this.address}::${this.module}::${functionName}`;
     try {
-      const client = this.aptosClient;
-      const result = await client.view({
+      const result = await this.aptosClient.view({
         payload: {
           function: fullFunctionName,
           typeArguments: typeArgs,
@@ -613,14 +807,25 @@ var ContractInterface = class {
   }
   /**
    * Calls an entry function (write operation)
+   * Requires a connected wallet
+   * 
    * @param functionName - Name of the entry function
    * @param args - Function arguments
-   * @param typeArgs - Type arguments (optional)
+   * @param typeArgs - Type arguments for generic functions
    * @returns Transaction hash
-   * @throws MovementError with code WALLET_NOT_CONNECTED if no wallet is connected
+   * @throws MovementError with code WALLET_NOT_CONNECTED if no wallet connected
    * @throws MovementError with code TRANSACTION_FAILED if transaction fails
+   * 
+   * @example
+   * ```typescript
+   * // Transfer coins
+   * const txHash = await contract.call('transfer', [recipient, amount], ['0x1::aptos_coin::AptosCoin']);
+   * 
+   * // Call a custom function
+   * const txHash = await contract.call('increment', []);
+   * ```
    */
-  async call(functionName, args, typeArgs = []) {
+  async call(functionName, args = [], typeArgs = []) {
     const adapter = this.walletManager.getAdapter();
     const state = this.walletManager.getState();
     if (!adapter || !state.connected) {
@@ -629,10 +834,11 @@ var ContractInterface = class {
     const fullFunctionName = `${this.address}::${this.module}::${functionName}`;
     try {
       const result = await adapter.signAndSubmitTransaction({
-        type: "entry_function_payload",
-        function: fullFunctionName,
-        type_arguments: typeArgs,
-        arguments: args
+        payload: {
+          function: fullFunctionName,
+          typeArguments: typeArgs,
+          functionArguments: args
+        }
       });
       return result.hash;
     } catch (error) {
@@ -641,13 +847,17 @@ var ContractInterface = class {
   }
   /**
    * Checks if a resource exists at the contract address
-   * @param resourceType - Full resource type (e.g., '0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>')
+   * @param resourceType - Full resource type
    * @returns true if resource exists
+   * 
+   * @example
+   * ```typescript
+   * const hasCoin = await contract.hasResource('0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>');
+   * ```
    */
   async hasResource(resourceType) {
     try {
-      const client = this.aptosClient;
-      await client.getAccountResource({
+      await this.aptosClient.getAccountResource({
         accountAddress: this.address,
         resourceType
       });
@@ -660,11 +870,17 @@ var ContractInterface = class {
    * Gets a resource from the contract address
    * @param resourceType - Full resource type
    * @returns Resource data or null if not found
+   * 
+   * @example
+   * ```typescript
+   * const coinStore = await contract.getResource<{ coin: { value: string } }>(
+   *   '0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>'
+   * );
+   * ```
    */
   async getResource(resourceType) {
     try {
-      const client = this.aptosClient;
-      const resource = await client.getAccountResource({
+      const resource = await this.aptosClient.getAccountResource({
         accountAddress: this.address,
         resourceType
       });
@@ -693,31 +909,99 @@ var EventListener = class {
   subscriptionCounter = 0;
   pollIntervalMs;
   /**
-   * Subscribes to contract events
+   * Subscribes to blockchain events
+   * Supports both new format (accountAddress + eventType) and legacy format (eventHandle)
+   * 
    * @param subscription - Subscription configuration
-   * @returns Subscription ID
-   * @throws MovementError with code INVALID_EVENT_HANDLE if event handle is invalid
+   * @returns Subscription ID for unsubscribing
+   * 
+   * @example
+   * ```typescript
+   * // New format (recommended)
+   * const subId = events.subscribe({
+   *   accountAddress: '0x1',
+   *   eventType: '0x1::coin::DepositEvent',
+   *   callback: (event) => console.log(event),
+   * });
+   * 
+   * // Legacy format (backward compatible)
+   * const subId = events.subscribe({
+   *   eventHandle: '0x1::coin::DepositEvent',
+   *   callback: (event) => console.log(event),
+   * });
+   * ```
    */
   subscribe(subscription) {
-    if (!isValidEventHandle(subscription.eventHandle)) {
-      throw Errors.invalidEventHandle(subscription.eventHandle);
-    }
     const subscriptionId = `sub_${++this.subscriptionCounter}`;
+    let accountAddress;
+    let eventType;
+    if ("accountAddress" in subscription) {
+      accountAddress = subscription.accountAddress;
+      eventType = subscription.eventType;
+    } else {
+      const parsed = this.parseEventHandle(subscription.eventHandle);
+      accountAddress = parsed.accountAddress;
+      eventType = parsed.eventType;
+    }
+    if (!this.isValidEventType(eventType)) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn(
+          `[EventListener] Event type "${eventType}" may not be in the expected format (address::module::EventType). Subscription will proceed but may not receive events.`
+        );
+      }
+    }
     const internalSub = {
-      eventHandle: subscription.eventHandle,
+      accountAddress,
+      eventType,
       callback: subscription.callback,
-      lastSequenceNumber: "0",
+      lastSequenceNumber: BigInt(-1),
+      // Start at -1 to catch all events
       intervalId: null
     };
+    this.subscriptions.set(subscriptionId, internalSub);
     internalSub.intervalId = setInterval(() => {
       this.pollEvents(subscriptionId).catch(() => {
       });
     }, this.pollIntervalMs);
     this.pollEvents(subscriptionId).catch(() => {
     });
-    this.subscriptions.set(subscriptionId, internalSub);
     return subscriptionId;
   }
+  /**
+   * Parses a legacy event handle into account address and event type
+   * @internal
+   */
+  parseEventHandle(eventHandle) {
+    const parts = eventHandle.split("::");
+    if (parts.length >= 3 && parts[0]) {
+      return {
+        accountAddress: parts[0],
+        eventType: eventHandle
+      };
+    }
+    return {
+      accountAddress: eventHandle,
+      eventType: eventHandle
+    };
+  }
+  /**
+   * Validates event type format
+   * Expected format: address::module::EventType
+   * @internal
+   */
+  isValidEventType(eventType) {
+    const parts = eventType.split("::");
+    if (parts.length < 3) {
+      return false;
+    }
+    const address = parts[0];
+    if (!address || !address.startsWith("0x")) {
+      return false;
+    }
+    const module = parts[1];
+    const eventName = parts.slice(2).join("::");
+    return Boolean(module && eventName);
+  }
   /**
    * Unsubscribes from events
    * @param subscriptionId - Subscription ID to remove
@@ -727,6 +1011,7 @@ var EventListener = class {
     if (subscription) {
       if (subscription.intervalId) {
         clearInterval(subscription.intervalId);
+        subscription.intervalId = null;
       }
       this.subscriptions.delete(subscriptionId);
     }
@@ -755,8 +1040,8 @@ var EventListener = class {
     return this.subscriptions.has(subscriptionId);
   }
   /**
-   * Polls for new events
-   * @param subscriptionId - Subscription ID
+   * Polls for new events for a subscription
+   * @internal
    */
   async pollEvents(subscriptionId) {
     const subscription = this.subscriptions.get(subscriptionId);
@@ -764,33 +1049,199 @@ var EventListener = class {
       return;
     }
     try {
-      const parts = subscription.eventHandle.split("::");
-      if (parts.length !== 3) {
-        return;
+      const events = await this.fetchEvents(
+        subscription.accountAddress,
+        subscription.eventType
+      );
+      const sortedEvents = this.sortEventsBySequence(events);
+      for (const event of sortedEvents) {
+        const sequenceNumber = this.parseSequenceNumber(event.sequence_number);
+        if (sequenceNumber > subscription.lastSequenceNumber) {
+          const contractEvent = {
+            type: event.type || subscription.eventType,
+            sequenceNumber: String(event.sequence_number),
+            data: this.normalizeEventData(event.data)
+          };
+          this.safeInvokeCallback(subscription.callback, contractEvent);
+          subscription.lastSequenceNumber = sequenceNumber;
+        }
+      }
+    } catch (error) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn(`[EventListener] Polling error for ${subscriptionId}:`, error);
       }
-      const [address, module, eventType] = parts;
-      const eventHandleStruct = `${address}::${module}::${eventType}`;
-      const client = this.aptosClient;
-      const events = await client.getAccountEventsByEventType({
-        accountAddress: address,
-        eventType: eventHandleStruct,
+    }
+  }
+  /**
+   * Fetches events from the blockchain
+   * Handles different API response formats and fallback methods
+   * @internal
+   */
+  async fetchEvents(accountAddress, eventType) {
+    try {
+      const events = await this.aptosClient.getAccountEventsByEventType({
+        accountAddress,
+        eventType,
         options: {
-          limit: 25
+          limit: 25,
+          orderBy: [{ sequence_number: "desc" }]
         }
       });
-      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;
+      return events.map((e) => ({
+        type: e.type,
+        sequence_number: e.sequence_number,
+        data: e.data
+      }));
+    } catch (indexerError) {
+      try {
+        const events = await this.fetchEventsViaEventHandle(accountAddress, eventType);
+        return events;
+      } catch (handleError) {
+        try {
+          const events = await this.fetchEventsViaResources(accountAddress, eventType);
+          return events;
+        } catch (resourceError) {
+          if (process.env.NODE_ENV === "development") {
+            console.warn(
+              `[EventListener] Failed to fetch events for ${eventType}:`,
+              { indexerError, handleError, resourceError }
+            );
+          }
+          return [];
         }
       }
+    }
+  }
+  /**
+   * Fetches events using the event handle API
+   * @internal
+   */
+  async fetchEventsViaEventHandle(accountAddress, eventType) {
+    const parts = eventType.split("::");
+    if (parts.length < 3) {
+      throw new Error("Invalid event type format");
+    }
+    const structName = parts.slice(2).join("::");
+    const eventHandleMappings = {
+      "DepositEvent": { resource: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>", field: "deposit_events" },
+      "WithdrawEvent": { resource: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>", field: "withdraw_events" }
+    };
+    const mapping = eventHandleMappings[structName];
+    if (!mapping) {
+      throw new Error(`Unknown event type: ${structName}`);
+    }
+    const events = await this.aptosClient.getEventsByEventHandle({
+      accountAddress,
+      eventHandleStruct: mapping.resource,
+      fieldName: mapping.field,
+      options: { limit: 25 }
+    });
+    return events.map((e) => ({
+      type: e.type || eventType,
+      sequence_number: e.sequence_number,
+      data: e.data
+    }));
+  }
+  /**
+   * Fetches events by checking account resources
+   * This is a fallback method when indexer is not available
+   * @internal
+   */
+  async fetchEventsViaResources(accountAddress, eventType) {
+    const resources = await this.aptosClient.getAccountResources({
+      accountAddress
+    });
+    const coinStore = resources.find(
+      (r) => r.type === "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"
+    );
+    if (!coinStore) {
+      return [];
+    }
+    const data = coinStore.data;
+    const isDeposit = eventType.includes("Deposit");
+    const eventHandle = isDeposit ? data.deposit_events : data.withdraw_events;
+    if (!eventHandle) {
+      return [];
+    }
+    try {
+      const creationNum = eventHandle.guid.id.creation_num;
+      const addr = eventHandle.guid.id.addr;
+      const response = await fetch(
+        `${this.getFullnodeUrl()}/accounts/${accountAddress}/events/${addr}/${creationNum}?limit=25`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const events = await response.json();
+      return events.map((e) => ({
+        type: e.type || eventType,
+        sequence_number: e.sequence_number,
+        data: e.data
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Gets the fullnode URL from the Aptos client config
+   * @internal
+   */
+  getFullnodeUrl() {
+    const config = this.aptosClient.config;
+    return config?.fullnode || "https://testnet.movementnetwork.xyz/v1";
+  }
+  /**
+   * Sorts events by sequence number in ascending order
+   * @internal
+   */
+  sortEventsBySequence(events) {
+    return [...events].sort((a, b) => {
+      const seqA = this.parseSequenceNumber(a.sequence_number);
+      const seqB = this.parseSequenceNumber(b.sequence_number);
+      return seqA < seqB ? -1 : seqA > seqB ? 1 : 0;
+    });
+  }
+  /**
+   * Parses sequence number from various formats
+   * @internal
+   */
+  parseSequenceNumber(value) {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return BigInt(value);
+    }
+    try {
+      return BigInt(value);
     } catch {
+      return BigInt(0);
+    }
+  }
+  /**
+   * Normalizes event data to a consistent format
+   * @internal
+   */
+  normalizeEventData(data) {
+    if (data === null || data === void 0) {
+      return {};
+    }
+    if (typeof data === "object") {
+      return data;
+    }
+    return { value: data };
+  }
+  /**
+   * Safely invokes a callback without letting errors propagate
+   * @internal
+   */
+  safeInvokeCallback(callback, event) {
+    try {
+      callback(event);
+    } catch (error) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("[EventListener] Callback error:", error);
+      }
     }
   }
 };
@@ -902,10 +1353,9 @@ var Movement = class {
         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 ?? []
+          functionArguments: userTx.payload?.arguments ?? []
         },
         timestamp: userTx.timestamp
       };