@movebridge/core 0.0.1 → 0.2.0

package/dist/index.mjs

@@ -219,14 +219,32 @@ function wrapError(error, code, context) {
 import EventEmitter from "eventemitter3";
 import { getAptosWallets } from "@aptos-labs/wallet-standard";
 var SUPPORTED_WALLETS = {
-  "petra": "petra",
-  "petra wallet": "petra",
-  "pontem": "pontem",
-  "pontem wallet": "pontem",
+  "razor": "razor",
+  "razor wallet": "razor",
+  "razorwallet": "razor",
   "nightly": "nightly",
-  "nightly wallet": "nightly"
+  "nightly wallet": "nightly",
+  "okx": "okx",
+  "okx wallet": "okx",
+  "okxwallet": "okx"
 };
 var STORAGE_KEY = "movebridge:lastWallet";
+function normalizeHash(data) {
+  if (typeof data === "string") {
+    return data.startsWith("0x") ? data : `0x${data}`;
+  }
+  if (data instanceof Uint8Array) {
+    return "0x" + Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (data && typeof data === "object" && "hash" in data) {
+    return normalizeHash(data.hash);
+  }
+  if (data && typeof data.toString === "function") {
+    const str = data.toString();
+    return str.startsWith("0x") ? str : `0x${str}`;
+  }
+  return String(data);
+}
 function toHexString(data) {
   if (typeof data === "string") return data;
   if (data instanceof Uint8Array) {
@@ -237,56 +255,88 @@ function toHexString(data) {
   }
   return String(data);
 }
+function extractUserResponse(response) {
+  if (!response) {
+    throw new Error("Empty response from wallet");
+  }
+  const resp = response;
+  if (resp.status === "rejected") {
+    throw new Error("User rejected the request");
+  }
+  if (resp.args !== void 0) {
+    return resp.args;
+  }
+  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");
+      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 = extractUserResponse(response);
+      let hash;
+      if (result && typeof result === "object" && "hash" in result) {
+        hash = normalizeHash(result.hash);
+      } else {
+        hash = normalizeHash(result);
       }
-      const result = response?.args ?? response;
-      return { hash: result.hash || toHexString(result) };
+      return { hash };
     },
-    // 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;
+      }
+      if (result && typeof result === "object") {
+        if ("authenticator" in result && result.authenticator) {
+          return result.authenticator;
+        }
+        if ("signature" in result && result.signature) {
+          return result.signature;
+        }
       }
-      const result = response?.args ?? response;
-      return result.authenticator || result.signature || new Uint8Array();
+      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);
           }
@@ -296,7 +346,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));
+          }
         });
       }
     }
@@ -306,17 +360,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();
@@ -332,21 +391,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();
@@ -356,6 +436,9 @@ var WalletManager = class extends EventEmitter {
       throw Errors.walletConnectionFailed(wallet, error);
     }
   }
+  /**
+   * Disconnects from the current wallet
+   */
   async disconnect() {
     if (this.adapter) {
       try {
@@ -369,15 +452,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;
@@ -390,6 +486,9 @@ var WalletManager = class extends EventEmitter {
       }
     }
   }
+  /**
+   * Cleans up resources
+   */
   destroy() {
     if (this.unsubscribe) {
       this.unsubscribe();
@@ -400,18 +499,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 {
     }
   }
@@ -429,7 +536,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 {
     }
   }
@@ -443,98 +552,50 @@ 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
    */
   async signAndSubmit(payload) {
     const adapter = this.walletManager.getAdapter();
-    if (!adapter) {
+    const state = this.walletManager.getState();
+    if (!adapter || !state.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) {
@@ -543,8 +604,9 @@ var TransactionBuilder = class {
   }
   /**
    * 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();
@@ -552,16 +614,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"),
@@ -571,6 +634,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
@@ -587,17 +659,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,
@@ -611,14 +693,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) {
@@ -627,10 +720,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) {
@@ -639,13 +733,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
       });
@@ -658,11 +756,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
       });
@@ -691,29 +795,60 @@ 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 parts = subscription.eventHandle.split("::");
+      if (parts.length >= 3 && parts[0]) {
+        accountAddress = parts[0];
+        eventType = subscription.eventHandle;
+      } else {
+        accountAddress = subscription.eventHandle;
+        eventType = subscription.eventHandle;
+      }
+    }
     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;
   }
   /**
@@ -725,6 +860,7 @@ var EventListener = class {
     if (subscription) {
       if (subscription.intervalId) {
         clearInterval(subscription.intervalId);
+        subscription.intervalId = null;
       }
       this.subscriptions.delete(subscriptionId);
     }
@@ -753,8 +889,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);
@@ -762,29 +898,31 @@ var EventListener = class {
       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,
+      const events = await this.aptosClient.getAccountEventsByEventType({
+        accountAddress: subscription.accountAddress,
+        eventType: subscription.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 sortedEvents = [...events].sort((a, b) => {
+        const seqA = BigInt(a.sequence_number);
+        const seqB = BigInt(b.sequence_number);
+        return seqA < seqB ? -1 : seqA > seqB ? 1 : 0;
+      });
+      for (const event of sortedEvents) {
+        const sequenceNumber = BigInt(event.sequence_number);
+        if (sequenceNumber > subscription.lastSequenceNumber) {
           const contractEvent = {
             type: event.type,
-            sequenceNumber,
+            sequenceNumber: String(event.sequence_number),
             data: event.data
           };
-          subscription.callback(contractEvent);
+          try {
+            subscription.callback(contractEvent);
+          } catch {
+          }
           subscription.lastSequenceNumber = sequenceNumber;
         }
       }
@@ -900,10 +1038,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
       };