@vleap/warps-adapter-fastset 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/index.mjs

@@ -211,7 +211,7 @@ var Wallet = class _Wallet {
 BigInt.prototype.toJSON = function() {
   return Number(this);
 };
-var FASTSET_VALIDATOR_URL = "http://157.90.201.117:8765";
+var FASTSET_VALIDATOR_URL = "https://rpc.fastset.xyz";
 var FASTSET_PROXY_URL = "http://136.243.61.168:44444";
 var FastsetClient = class {
   constructor(config) {
@@ -220,56 +220,55 @@ var FastsetClient = class {
       proxyUrl: FASTSET_PROXY_URL
     };
   }
-  async getAccountInfo(address) {
+  // Generic error handling wrapper for RPC calls
+  async handleRpcCall(method, params, errorMessage, useProxy = false, allowNull = true) {
     try {
-      const addressBytes = Wallet.decodeBech32Address(address);
-      const response = await this.requestValidator("set_getAccountInfo", {
-        address: Array.from(addressBytes)
-      });
+      const response = useProxy ? await this.requestProxy(method, params) : await this.requestValidator(method, params);
+      console.log(`RPC call to ${method} successful:`, response.result);
       return response.result;
     } catch (error) {
+      console.error(`${errorMessage}:`, error);
+      if (!allowNull) throw error;
       return null;
     }
   }
+  async getAccountInfo(address) {
+    const addressBytes = Wallet.decodeBech32Address(address);
+    return this.handleRpcCall("set_getAccountInfo", [Array.from(addressBytes)], `Failed to get account info for address ${address}`);
+  }
   async getNextNonce(senderAddress) {
     const accountInfo = await this.getAccountInfo(senderAddress);
     return accountInfo?.next_nonce ?? 0;
   }
   async getAssetBalance(accountId, assetId) {
-    try {
-      const response = await this.requestValidator("vsl_getAssetBalance", {
-        account_id: accountId,
-        assert_id: assetId
-      });
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+    return this.handleRpcCall(
+      "vsl_getAssetBalance",
+      [accountId, assetId],
+      `Failed to get asset balance for account ${accountId}, asset ${assetId}`
+    );
   }
   async getAssetBalances(accountId) {
-    try {
-      const response = await this.requestValidator("vsl_getAssetBalances", {
-        account_id: accountId
-      });
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+    return this.handleRpcCall("vsl_getAssetBalances", [accountId], `Failed to get asset balances for account ${accountId}`);
   }
   async fundFromFaucet(recipientAddress, amount) {
     const recipientBytes = Wallet.decodeBech32Address(recipientAddress);
-    const response = await this.requestProxy("faucetDrip", {
-      recipient: Array.from(recipientBytes),
-      amount
-    });
-    return response.result;
+    return this.handleRpcCall(
+      "faucetDrip",
+      [Array.from(recipientBytes), amount],
+      `Failed to fund from faucet for address ${recipientAddress}`,
+      true,
+      false
+    );
   }
   async submitTransaction(request) {
-    const response = await this.requestValidator("set_submitTransaction", {
-      transaction: request.transaction,
-      signature: Array.from(request.signature)
-    });
-    const result = response.result;
+    const response = await this.handleRpcCall(
+      "set_submitTransaction",
+      [request.transaction, Array.from(request.signature)],
+      "Failed to submit transaction",
+      false,
+      false
+    );
+    const result = response;
     return {
       transaction_hash: new Uint8Array(result.transaction_hash),
       validator: new Uint8Array(result.validator),
@@ -277,93 +276,105 @@ var FastsetClient = class {
     };
   }
   async submitCertificate(request) {
-    await this.requestValidator("set_submitTransactionCertificate", {
-      transaction: request.transaction,
-      signature: Array.from(request.signature),
-      validator_signatures: request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
-    });
+    await this.handleRpcCall(
+      "set_submitTransactionCertificate",
+      [
+        request.transaction,
+        Array.from(request.signature),
+        request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
+      ],
+      "Failed to submit certificate",
+      false,
+      false
+    );
   }
   async executeTransfer(senderPrivateKey, recipient, amount, userData) {
-    const senderPublicKey = await getPublicKey(senderPrivateKey);
-    const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
-    const nonce = await this.getNextNonce(senderAddress);
-    const recipientBytes = Wallet.decodeBech32Address(recipient);
-    const transaction = {
-      sender: senderPublicKey,
-      nonce,
-      timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim: {
-        Transfer: {
-          recipient: { FastSet: recipientBytes },
-          amount,
-          user_data: userData ?? null
+    try {
+      console.log(`Executing transfer from sender to ${recipient} for amount ${amount}`);
+      const senderPublicKey = getPublicKey(senderPrivateKey);
+      const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
+      console.log(`Sender address: ${senderAddress}`);
+      const nonce = await this.getNextNonce(senderAddress);
+      console.log(`Using nonce: ${nonce}`);
+      const recipientBytes = Wallet.decodeBech32Address(recipient);
+      console.log(`Recipient decoded successfully`);
+      const transaction = {
+        sender: senderPublicKey,
+        nonce,
+        timestamp_nanos: BigInt(Date.now()) * 1000000n,
+        claim: {
+          Transfer: {
+            recipient: { FastSet: recipientBytes },
+            amount,
+            user_data: userData ?? null
+          }
         }
-      }
-    };
-    const signature = await this.signTransaction(transaction, senderPrivateKey);
-    const submitResponse = await this.submitTransaction({
-      transaction,
-      signature
-    });
-    await this.submitCertificate({
-      transaction,
-      signature,
-      validator_signatures: [[submitResponse.validator, submitResponse.signature]]
-    });
-    return submitResponse.transaction_hash;
+      };
+      console.log("Signing transaction...");
+      const signature = await this.signTransaction(transaction, senderPrivateKey);
+      console.log("Submitting transaction...");
+      const submitResponse = await this.submitTransaction({
+        transaction,
+        signature
+      });
+      console.log("Submitting certificate...");
+      await this.submitCertificate({
+        transaction,
+        signature,
+        validator_signatures: [[submitResponse.validator, submitResponse.signature]]
+      });
+      console.log(`Transfer executed successfully. Transaction hash: ${submitResponse.transaction_hash}`);
+      return submitResponse.transaction_hash;
+    } catch (error) {
+      console.error(`Failed to execute transfer to ${recipient}:`, error);
+      throw error;
+    }
   }
   async submitClaim(senderPrivateKey, claim) {
-    const senderPublicKey = await getPublicKey(senderPrivateKey);
-    const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
-    const nonce = await this.getNextNonce(senderAddress);
-    const transaction = {
-      sender: senderPublicKey,
-      nonce,
-      timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim
-    };
-    const signature = await this.signTransaction(transaction, senderPrivateKey);
-    const submitResponse = await this.submitTransaction({
-      transaction,
-      signature
-    });
-    await this.submitCertificate({
-      transaction,
-      signature,
-      validator_signatures: [[submitResponse.validator, submitResponse.signature]]
-    });
-    return submitResponse.transaction_hash;
+    try {
+      console.log("Submitting claim...");
+      const senderPublicKey = await getPublicKey(senderPrivateKey);
+      const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
+      console.log(`Claim sender address: ${senderAddress}`);
+      const nonce = await this.getNextNonce(senderAddress);
+      console.log(`Using nonce: ${nonce}`);
+      const transaction = {
+        sender: senderPublicKey,
+        nonce,
+        timestamp_nanos: BigInt(Date.now()) * 1000000n,
+        claim
+      };
+      console.log("Signing claim transaction...");
+      const signature = await this.signTransaction(transaction, senderPrivateKey);
+      console.log("Submitting claim transaction...");
+      const submitResponse = await this.submitTransaction({
+        transaction,
+        signature
+      });
+      console.log("Submitting claim certificate...");
+      await this.submitCertificate({
+        transaction,
+        signature,
+        validator_signatures: [[submitResponse.validator, submitResponse.signature]]
+      });
+      console.log(`Claim submitted successfully. Transaction hash: ${submitResponse.transaction_hash}`);
+      return submitResponse.transaction_hash;
+    } catch (error) {
+      console.error("Failed to submit claim:", error);
+      throw error;
+    }
   }
   async signTransaction(transaction, privateKey) {
     return await TransactionSigner.signTransaction(transaction, privateKey);
   }
   async getTransactionStatus(txHash) {
-    try {
-      const response = await this.requestValidator("set_getTransactionStatus", {
-        hash: txHash
-      });
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+    return this.handleRpcCall("set_getTransactionStatus", [txHash], `Failed to get transaction status for hash ${txHash}`);
   }
   async getTransactionInfo(txHash) {
-    try {
-      const response = await this.requestValidator("set_getTransactionInfo", {
-        hash: txHash
-      });
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+    return this.handleRpcCall("set_getTransactionInfo", [txHash], `Failed to get transaction info for hash ${txHash}`);
   }
   async getNetworkInfo() {
-    try {
-      const response = await this.requestValidator("set_getNetworkInfo", {});
-      return response.result;
-    } catch (error) {
-      return null;
-    }
+    return this.handleRpcCall("set_getNetworkInfo", [], "Failed to get network info");
   }
   async requestValidator(method, params) {
     return this.request(this.config.validatorUrl, method, params);
@@ -373,27 +384,45 @@ var FastsetClient = class {
   }
   async request(url, method, params) {
     try {
+      if (params !== null && params !== void 0) {
+        if (Array.isArray(params)) {
+          for (let i = 0; i < params.length; i++) {
+            if (params[i] === void 0) {
+              throw new Error(`Parameter at index ${i} is undefined`);
+            }
+          }
+        } else if (typeof params === "object") {
+          const paramObj = params;
+          for (const [key, value] of Object.entries(paramObj)) {
+            if (value === void 0) {
+              throw new Error(`Parameter '${key}' is undefined`);
+            }
+          }
+        }
+      }
       const request = {
         jsonrpc: "2.0",
         id: 1,
         method,
         params
       };
+      console.log(`Making RPC request to ${method} with params:`, params);
       const response = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(request, this.jsonReplacer)
       });
       if (!response.ok) {
-        throw new Error(`HTTP request failed: ${response.statusText}`);
+        throw new Error(`HTTP request failed: ${response.status} ${response.statusText}`);
       }
       const jsonResponse = await response.json();
       if (jsonResponse.error) {
-        throw new Error(`RPC error: ${jsonResponse.error.message}`);
+        throw new Error(`RPC error: ${jsonResponse.error.message} (code: ${jsonResponse.error.code})`);
       }
+      console.log(`RPC request to ${method} successful:`, jsonResponse.result);
       return jsonResponse;
     } catch (error) {
-      console.error(`Fastset RPC request failed: ${error}`);
+      console.error(`Fastset RPC request failed for method ${method}:`, error);
       throw error;
     }
   }
@@ -461,6 +490,12 @@ var WarpFastsetDataLoader = class {
     }
     return assets;
   }
+  async getAsset(identifier) {
+    return null;
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
+  }
   async getAccountActions(address, options) {
     return [];
   }