polkamarkets-js 3.3.1 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "polkamarkets-js",
-    "version": "3.3.1",
+    "version": "3.4.0",
     "description": "",
     "main": "index.js",
     "directories": {

package/src/Application.js

@@ -18,6 +18,7 @@ const WETH9Contract = require("./models/index").WETH9Contract;
 const ArbitrationContract = require("./models/index").ArbitrationContract;
 const ArbitrationProxyContract = require("./models/index").ArbitrationProxyContract;
 
+const DualProvider = require("./utils/DualProvider");
 const Account = require('./utils/Account');
 
 
@@ -38,7 +39,8 @@ class Application {
     isSocialLogin = false,
     socialLoginParams,
     startBlock,
-    defaultDecimals
+    defaultDecimals,
+    useDualProvider = false
   }) {
     this.web3Provider = web3Provider;
     // evm logs http source (optional)
@@ -48,6 +50,8 @@ class Application {
     this.isSocialLogin = isSocialLogin;
     this.startBlock = startBlock;
     this.defaultDecimals = defaultDecimals;
+    // use DualProvider to separate read (HttpProvider) and write (window.ethereum) operations
+    this.useDualProvider = useDualProvider;
 
     if (this.isSocialLogin) {
       this.socialLoginParams = socialLoginParams;
@@ -70,7 +74,14 @@ class Application {
    * @description Start the Application
    */
   start() {
-    this.web3 = new Web3(new Web3.providers.HttpProvider(this.web3Provider));
+    if (this.useDualProvider) {
+      // Store read provider for later use in DualProvider
+      this.readProvider = new Web3.providers.HttpProvider(this.web3Provider);
+      this.web3 = new Web3(this.readProvider);
+    } else {
+      // Backwards compatible: standard HttpProvider
+      this.web3 = new Web3(new Web3.providers.HttpProvider(this.web3Provider));
+    }
     this.web3.eth.handleRevert = true;
     if (typeof window !== "undefined") {
       window.web3 = this.web3;
@@ -97,8 +108,18 @@ class Application {
       try {
         if (typeof window === "undefined") { return false; }
         if (window.ethereum) {
-          window.web3 = new Web3(window.ethereum);
-          this.web3 = window.web3;
+          if (this.useDualProvider) {
+            // New approach: DualProvider for reads (HttpProvider) and writes (window.ethereum)
+            const dualProvider = new DualProvider(this.readProvider, window.ethereum);
+            this.web3 = new Web3(dualProvider);
+            this.web3.eth.handleRevert = true;
+            window.web3 = this.web3;
+          } else {
+            // Backwards compatible: replace web3 with window.ethereum
+            window.web3 = new Web3(window.ethereum);
+            this.web3 = window.web3;
+          }
+
           await window.ethereum.enable();
           return true;
         }

package/src/utils/DualProvider.js

@@ -0,0 +1,79 @@
+/**
+ * DualProvider - Routes requests to appropriate provider based on method type
+ * Read operations use HttpProvider, write operations use window.ethereum
+ */
+class DualProvider {
+  constructor(readProvider, writeProvider) {
+    this.readProvider = readProvider;
+    this.writeProvider = writeProvider;
+
+    // Methods that require user interaction/signing (write operations)
+    this.writeMethods = new Set([
+      "eth_sendTransaction",
+      "eth_sendRawTransaction",
+      "eth_sign",
+      "eth_signTransaction",
+      "personal_sign",
+      "eth_signTypedData",
+      "eth_signTypedData_v3",
+      "eth_signTypedData_v4",
+      "wallet_switchEthereumChain",
+      "wallet_addEthereumChain",
+      "eth_accounts",
+      "eth_requestAccounts",
+    ]);
+  }
+
+  send(payload, callback) {
+    const provider = this.writeMethods.has(payload.method)
+      ? this.writeProvider
+      : this.readProvider;
+
+    return provider.send(payload, callback);
+  }
+
+  sendAsync(payload, callback) {
+    const provider = this.writeMethods.has(payload.method)
+      ? this.writeProvider
+      : this.readProvider;
+
+    return provider.sendAsync(payload, callback);
+  }
+
+  // Support for modern request/send pattern
+  request(args) {
+    const provider = this.writeMethods.has(args.method)
+      ? this.writeProvider
+      : this.readProvider;
+
+    if (provider.request) {
+      return provider.request(args);
+    }
+
+    // Fallback for providers that don't support request()
+    return new Promise((resolve, reject) => {
+      const callback = (error, response) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(response.result);
+        }
+      };
+
+      if (provider.sendAsync) {
+        provider.sendAsync(
+          { jsonrpc: "2.0", id: Date.now(), ...args },
+          callback
+        );
+      } else if (provider.send) {
+        provider.send({ jsonrpc: "2.0", id: Date.now(), ...args }, callback);
+      } else {
+        reject(
+          new Error("Provider does not support request, send, or sendAsync")
+        );
+      }
+    });
+  }
+}
+
+module.exports = DualProvider;