@depay/web3-wallets-evm 14.5.2 → 14.6.1

package/dist/esm/index.evm.js

@@ -59891,6 +59891,97 @@ const getProvider = async (blockchain)=>{
   }
 };
 
+class Argent {
+
+  constructor ({ address, blockchain }) {
+    this.address = address;
+    this.blockchain = blockchain;
+  }
+
+  async transactionCount() {
+    return 1 // irrelevant as proxy address/relayer actually sending the transaction is not known yet (but needs to be something)
+  }
+}
+
+const blockchainNames = {
+  'ethereum': 'mainnet',
+  'bsc': 'bsc',
+  'polygon': 'polygon',
+};
+
+class Safe {
+
+  constructor ({ address, blockchain }) {
+    this.address = address;
+    this.blockchain = blockchain;
+  }
+
+  async transactionCount() {
+    return parseInt((await request({
+      blockchain: this.blockchain,
+      address: this.address,
+      api: [{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],
+      method: 'nonce',
+    })).toString(), 10)
+  }
+
+  async retrieveTransaction({ blockchain, tx }) {
+    const provider = await getProvider(blockchain);
+    let jsonResult = await fetch(`https://safe-transaction-${blockchainNames[blockchain]}.safe.global/api/v1/multisig-transactions/${tx}/`)
+      .then((response) => response.json())
+      .catch((error) => { console.error('Error:', error); });
+    if(jsonResult && jsonResult.isExecuted && jsonResult.transactionHash) {
+      return await provider.getTransaction(jsonResult.transactionHash)
+    } else {
+      return undefined
+    }
+  }
+}
+
+const isSmartContractWallet = async(blockchain, address)=>{
+  const provider = await getProvider(blockchain);
+  const code = await provider.getCode(address);
+  return (code != '0x')
+};
+
+const identifySmartContractWallet = async (blockchain, address)=>{
+  let name; 
+  try {
+    name = await request({
+      blockchain,
+      address,
+      api: [{ "constant": true, "inputs": [], "name": "NAME", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "payable": false, "stateMutability": "view", "type": "function"}],
+      method: 'NAME'
+    });
+  } catch (e) {}
+  if(name == 'Default Callback Handler') { return 'Safe' }
+  
+  let executor; 
+  try {
+    executor = await request({
+      blockchain,
+      address,
+      api: [{ "constant": true, "inputs": [], "name": "staticCallExecutor", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "payable": false, "stateMutability": "view", "type": "function"}],
+      method: 'staticCallExecutor'
+    });
+  } catch (e2) {}
+  if(executor) { return 'Argent' }
+  
+};
+
+const getSmartContractWallet = async(blockchain, address)=> {
+  if(!await isSmartContractWallet(blockchain, address)){ return }
+
+  const type = await identifySmartContractWallet(blockchain, address);
+  if(type == 'Safe') {
+    return new Safe({ blockchain, address })
+  } else if(type == 'Argent') {
+    return new Argent({ blockchain, address })
+  } else {
+    throw('Unrecognized smart contract wallet not supported!')
+  }
+};
+
 const sendTransaction$3 = async ({ transaction, wallet })=> {
   transaction = new Transaction$1(transaction);
   if((await wallet.connectedTo(transaction.blockchain)) == false) {
@@ -59900,7 +59991,8 @@ const sendTransaction$3 = async ({ transaction, wallet })=> {
     throw({ code: 'WRONG_NETWORK' })
   }
   await transaction.prepare({ wallet });
-  let transactionCount = await request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
+  const smartContractWallet = await getSmartContractWallet(transaction.blockchain, transaction.from);
+  const transactionCount = smartContractWallet ? await smartContractWallet.transactionCount() : await request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
   transaction.nonce = transactionCount;
   await submit$3({ transaction, wallet }).then(async (tx)=>{
     if (tx) {
@@ -59908,33 +60000,29 @@ const sendTransaction$3 = async ({ transaction, wallet })=> {
       transaction.id = tx;
       transaction.url = blockchain.explorerUrlFor({ transaction });
       if (transaction.sent) transaction.sent(transaction);
-      let sentTransaction = await retrieveTransaction$1(tx, transaction.blockchain);
+      let sentTransaction = await retrieveTransaction$1({ blockchain: transaction.blockchain, tx, smartContractWallet });
+      transaction.id = sentTransaction.hash || transaction.id;
+      transaction.url = blockchain.explorerUrlFor({ transaction });
       transaction.nonce = sentTransaction.nonce || transactionCount;
-      if(!sentTransaction) {
-        transaction._failed = true;
-        console.log('Error retrieving transaction');
-        if(transaction.failed) transaction.failed(transaction, 'Error retrieving transaction');
-      } else {
-        sentTransaction.wait(1).then(() => {
-          transaction._succeeded = true;
-          if (transaction.succeeded) transaction.succeeded(transaction);
-        }).catch((error)=>{
-          if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
-            if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
-              transaction.id = error.replacement.hash;
-              transaction._succeeded = true;
-              if (transaction.succeeded) transaction.succeeded(transaction);
-            } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
-              transaction.id = error.replacement.hash;
-              transaction._failed = true;
-              if(transaction.failed) transaction.failed(transaction, error);  
-            }
-          } else {
+      sentTransaction.wait(1).then(() => {
+        transaction._succeeded = true;
+        if (transaction.succeeded) transaction.succeeded(transaction);
+      }).catch((error)=>{
+        if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
+          if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
+            transaction.id = error.replacement.hash;
+            transaction._succeeded = true;
+            if (transaction.succeeded) transaction.succeeded(transaction);
+          } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
+            transaction.id = error.replacement.hash;
             transaction._failed = true;
-            if(transaction.failed) transaction.failed(transaction, error);
+            if(transaction.failed) transaction.failed(transaction, error);  
           }
-        });
-      }
+        } else {
+          transaction._failed = true;
+          if(transaction.failed) transaction.failed(transaction, error);
+        }
+      });
     } else {
       throw('Submitting transaction failed!')
     }
@@ -59942,16 +60030,23 @@ const sendTransaction$3 = async ({ transaction, wallet })=> {
   return transaction
 };
 
-const retrieveTransaction$1 = async (tx, blockchain)=>{
-  let sentTransaction;
+const retrieveTransaction$1 = async ({ blockchain, tx, smartContractWallet })=>{
   const provider = await getProvider(blockchain);
-  sentTransaction = await provider.getTransaction(tx);
-  const maxRetries = 120;
-  let attempt = 1;
-  while (attempt <= maxRetries && !sentTransaction) {
-    sentTransaction = await provider.getTransaction(tx);
-    await (new Promise((resolve)=>setTimeout(resolve, 5000)));
-    attempt++;
+  let retrieve = async()=>{
+    try {
+      if(smartContractWallet && smartContractWallet.retrieveTransaction) {
+        return await smartContractWallet.retrieveTransaction({ blockchain, tx })
+      } else {
+        return await provider.getTransaction(tx)
+      }
+    } catch (e) {}
+  };
+  
+  let sentTransaction;
+  sentTransaction = await retrieve();
+  while (!sentTransaction) {
+    await (new Promise((resolve)=>setTimeout(resolve, 3000)));
+    sentTransaction = await retrieve();
   }
   return sentTransaction
 };
@@ -59971,15 +60066,6 @@ const submitContractInteraction$2 = async ({ transaction, wallet })=>{
   const data = await transaction.getData();
   const value = transaction.value ? ethers.utils.hexlify(ethers.BigNumber.from(transaction.value)) : undefined;
   const nonce = ethers.utils.hexlify(transaction.nonce);
-  console.log({
-    from: transaction.from,
-    to: transaction.to,
-    value,
-    data,
-    gas: gas.toHexString(),
-    gasPrice: gasPrice.toHexString(),
-    nonce,
-  });
   return wallet.connector.sendTransaction({
     from: transaction.from,
     to: transaction.to,
@@ -59997,15 +60083,6 @@ const submitSimpleTransfer$3 = async ({ transaction, wallet })=>{
   const gas = await estimate(transaction);
   const value = ethers.utils.hexlify(ethers.BigNumber.from(transaction.value));
   const nonce = ethers.utils.hexlify(transaction.nonce);
-  console.log({
-    from: transaction.from,
-    to: transaction.to,
-    value,
-    data: '0x',
-    gas: gas.toHexString(),
-    gasPrice: gasPrice.toHexString(),
-    nonce,
-  });
   return wallet.connector.sendTransaction({
     from: transaction.from,
     to: transaction.to,

package/dist/esm/index.js

@@ -985,6 +985,97 @@ class Trust extends WindowEthereum {
   static __initStatic2() {this.isAvailable = ()=>{ return (_optionalChain$3([window, 'optionalAccess', _5 => _5.ethereum, 'optionalAccess', _6 => _6.isTrust]) || _optionalChain$3([window, 'optionalAccess', _7 => _7.ethereum, 'optionalAccess', _8 => _8.isTrustWallet])) };}
 } Trust.__initStatic(); Trust.__initStatic2();
 
+class Argent {
+
+  constructor ({ address, blockchain }) {
+    this.address = address;
+    this.blockchain = blockchain;
+  }
+
+  async transactionCount() {
+    return 1 // irrelevant as proxy address/relayer actually sending the transaction is not known yet (but needs to be something)
+  }
+}
+
+const blockchainNames = {
+  'ethereum': 'mainnet',
+  'bsc': 'bsc',
+  'polygon': 'polygon',
+};
+
+class Safe {
+
+  constructor ({ address, blockchain }) {
+    this.address = address;
+    this.blockchain = blockchain;
+  }
+
+  async transactionCount() {
+    return parseInt((await request$1({
+      blockchain: this.blockchain,
+      address: this.address,
+      api: [{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],
+      method: 'nonce',
+    })).toString(), 10)
+  }
+
+  async retrieveTransaction({ blockchain, tx }) {
+    const provider = await getProvider(blockchain);
+    let jsonResult = await fetch(`https://safe-transaction-${blockchainNames[blockchain]}.safe.global/api/v1/multisig-transactions/${tx}/`)
+      .then((response) => response.json())
+      .catch((error) => { console.error('Error:', error); });
+    if(jsonResult && jsonResult.isExecuted && jsonResult.transactionHash) {
+      return await provider.getTransaction(jsonResult.transactionHash)
+    } else {
+      return undefined
+    }
+  }
+}
+
+const isSmartContractWallet = async(blockchain, address)=>{
+  const provider = await getProvider(blockchain);
+  const code = await provider.getCode(address);
+  return (code != '0x')
+};
+
+const identifySmartContractWallet = async (blockchain, address)=>{
+  let name; 
+  try {
+    name = await request$1({
+      blockchain,
+      address,
+      api: [{ "constant": true, "inputs": [], "name": "NAME", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "payable": false, "stateMutability": "view", "type": "function"}],
+      method: 'NAME'
+    });
+  } catch (e) {}
+  if(name == 'Default Callback Handler') { return 'Safe' }
+  
+  let executor; 
+  try {
+    executor = await request$1({
+      blockchain,
+      address,
+      api: [{ "constant": true, "inputs": [], "name": "staticCallExecutor", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "payable": false, "stateMutability": "view", "type": "function"}],
+      method: 'staticCallExecutor'
+    });
+  } catch (e2) {}
+  if(executor) { return 'Argent' }
+  
+};
+
+const getSmartContractWallet = async(blockchain, address)=> {
+  if(!await isSmartContractWallet(blockchain, address)){ return }
+
+  const type = await identifySmartContractWallet(blockchain, address);
+  if(type == 'Safe') {
+    return new Safe({ blockchain, address })
+  } else if(type == 'Argent') {
+    return new Argent({ blockchain, address })
+  } else {
+    throw('Unrecognized smart contract wallet not supported!')
+  }
+};
+
 const sendTransaction$2 = async ({ transaction, wallet })=> {
   transaction = new Transaction(transaction);
   if((await wallet.connectedTo(transaction.blockchain)) == false) {
@@ -994,7 +1085,8 @@ const sendTransaction$2 = async ({ transaction, wallet })=> {
     throw({ code: 'WRONG_NETWORK' })
   }
   await transaction.prepare({ wallet });
-  let transactionCount = await request$1({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
+  const smartContractWallet = await getSmartContractWallet(transaction.blockchain, transaction.from);
+  const transactionCount = smartContractWallet ? await smartContractWallet.transactionCount() : await request$1({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
   transaction.nonce = transactionCount;
   await submit$2({ transaction, wallet }).then(async (tx)=>{
     if (tx) {
@@ -1002,33 +1094,29 @@ const sendTransaction$2 = async ({ transaction, wallet })=> {
       transaction.id = tx;
       transaction.url = blockchain.explorerUrlFor({ transaction });
       if (transaction.sent) transaction.sent(transaction);
-      let sentTransaction = await retrieveTransaction$1(tx, transaction.blockchain);
+      let sentTransaction = await retrieveTransaction$1({ blockchain: transaction.blockchain, tx, smartContractWallet });
+      transaction.id = sentTransaction.hash || transaction.id;
+      transaction.url = blockchain.explorerUrlFor({ transaction });
       transaction.nonce = sentTransaction.nonce || transactionCount;
-      if(!sentTransaction) {
-        transaction._failed = true;
-        console.log('Error retrieving transaction');
-        if(transaction.failed) transaction.failed(transaction, 'Error retrieving transaction');
-      } else {
-        sentTransaction.wait(1).then(() => {
-          transaction._succeeded = true;
-          if (transaction.succeeded) transaction.succeeded(transaction);
-        }).catch((error)=>{
-          if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
-            if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
-              transaction.id = error.replacement.hash;
-              transaction._succeeded = true;
-              if (transaction.succeeded) transaction.succeeded(transaction);
-            } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
-              transaction.id = error.replacement.hash;
-              transaction._failed = true;
-              if(transaction.failed) transaction.failed(transaction, error);  
-            }
-          } else {
+      sentTransaction.wait(1).then(() => {
+        transaction._succeeded = true;
+        if (transaction.succeeded) transaction.succeeded(transaction);
+      }).catch((error)=>{
+        if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
+          if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
+            transaction.id = error.replacement.hash;
+            transaction._succeeded = true;
+            if (transaction.succeeded) transaction.succeeded(transaction);
+          } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
+            transaction.id = error.replacement.hash;
             transaction._failed = true;
-            if(transaction.failed) transaction.failed(transaction, error);
+            if(transaction.failed) transaction.failed(transaction, error);  
           }
-        });
-      }
+        } else {
+          transaction._failed = true;
+          if(transaction.failed) transaction.failed(transaction, error);
+        }
+      });
     } else {
       throw('Submitting transaction failed!')
     }
@@ -1036,16 +1124,23 @@ const sendTransaction$2 = async ({ transaction, wallet })=> {
   return transaction
 };
 
-const retrieveTransaction$1 = async (tx, blockchain)=>{
-  let sentTransaction;
+const retrieveTransaction$1 = async ({ blockchain, tx, smartContractWallet })=>{
   const provider = await getProvider(blockchain);
-  sentTransaction = await provider.getTransaction(tx);
-  const maxRetries = 120;
-  let attempt = 1;
-  while (attempt <= maxRetries && !sentTransaction) {
-    sentTransaction = await provider.getTransaction(tx);
-    await (new Promise((resolve)=>setTimeout(resolve, 5000)));
-    attempt++;
+  let retrieve = async()=>{
+    try {
+      if(smartContractWallet && smartContractWallet.retrieveTransaction) {
+        return await smartContractWallet.retrieveTransaction({ blockchain, tx })
+      } else {
+        return await provider.getTransaction(tx)
+      }
+    } catch (e) {}
+  };
+  
+  let sentTransaction;
+  sentTransaction = await retrieve();
+  while (!sentTransaction) {
+    await (new Promise((resolve)=>setTimeout(resolve, 3000)));
+    sentTransaction = await retrieve();
   }
   return sentTransaction
 };
@@ -1065,15 +1160,6 @@ const submitContractInteraction$2 = async ({ transaction, wallet })=>{
   const data = await transaction.getData();
   const value = transaction.value ? ethers.utils.hexlify(ethers.BigNumber.from(transaction.value)) : undefined;
   const nonce = ethers.utils.hexlify(transaction.nonce);
-  console.log({
-    from: transaction.from,
-    to: transaction.to,
-    value,
-    data,
-    gas: gas.toHexString(),
-    gasPrice: gasPrice.toHexString(),
-    nonce,
-  });
   return wallet.connector.sendTransaction({
     from: transaction.from,
     to: transaction.to,
@@ -1091,15 +1177,6 @@ const submitSimpleTransfer$2 = async ({ transaction, wallet })=>{
   const gas = await estimate(transaction);
   const value = ethers.utils.hexlify(ethers.BigNumber.from(transaction.value));
   const nonce = ethers.utils.hexlify(transaction.nonce);
-  console.log({
-    from: transaction.from,
-    to: transaction.to,
-    value,
-    data: '0x',
-    gas: gas.toHexString(),
-    gasPrice: gasPrice.toHexString(),
-    nonce,
-  });
   return wallet.connector.sendTransaction({
     from: transaction.from,
     to: transaction.to,

package/dist/umd/index.evm.js

@@ -59889,6 +59889,97 @@
     }
   };
 
+  class Argent {
+
+    constructor ({ address, blockchain }) {
+      this.address = address;
+      this.blockchain = blockchain;
+    }
+
+    async transactionCount() {
+      return 1 // irrelevant as proxy address/relayer actually sending the transaction is not known yet (but needs to be something)
+    }
+  }
+
+  const blockchainNames = {
+    'ethereum': 'mainnet',
+    'bsc': 'bsc',
+    'polygon': 'polygon',
+  };
+
+  class Safe {
+
+    constructor ({ address, blockchain }) {
+      this.address = address;
+      this.blockchain = blockchain;
+    }
+
+    async transactionCount() {
+      return parseInt((await request({
+        blockchain: this.blockchain,
+        address: this.address,
+        api: [{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],
+        method: 'nonce',
+      })).toString(), 10)
+    }
+
+    async retrieveTransaction({ blockchain, tx }) {
+      const provider = await getProvider(blockchain);
+      let jsonResult = await fetch(`https://safe-transaction-${blockchainNames[blockchain]}.safe.global/api/v1/multisig-transactions/${tx}/`)
+        .then((response) => response.json())
+        .catch((error) => { console.error('Error:', error); });
+      if(jsonResult && jsonResult.isExecuted && jsonResult.transactionHash) {
+        return await provider.getTransaction(jsonResult.transactionHash)
+      } else {
+        return undefined
+      }
+    }
+  }
+
+  const isSmartContractWallet = async(blockchain, address)=>{
+    const provider = await getProvider(blockchain);
+    const code = await provider.getCode(address);
+    return (code != '0x')
+  };
+
+  const identifySmartContractWallet = async (blockchain, address)=>{
+    let name; 
+    try {
+      name = await request({
+        blockchain,
+        address,
+        api: [{ "constant": true, "inputs": [], "name": "NAME", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "payable": false, "stateMutability": "view", "type": "function"}],
+        method: 'NAME'
+      });
+    } catch (e) {}
+    if(name == 'Default Callback Handler') { return 'Safe' }
+    
+    let executor; 
+    try {
+      executor = await request({
+        blockchain,
+        address,
+        api: [{ "constant": true, "inputs": [], "name": "staticCallExecutor", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "payable": false, "stateMutability": "view", "type": "function"}],
+        method: 'staticCallExecutor'
+      });
+    } catch (e2) {}
+    if(executor) { return 'Argent' }
+    
+  };
+
+  const getSmartContractWallet = async(blockchain, address)=> {
+    if(!await isSmartContractWallet(blockchain, address)){ return }
+
+    const type = await identifySmartContractWallet(blockchain, address);
+    if(type == 'Safe') {
+      return new Safe({ blockchain, address })
+    } else if(type == 'Argent') {
+      return new Argent({ blockchain, address })
+    } else {
+      throw('Unrecognized smart contract wallet not supported!')
+    }
+  };
+
   const sendTransaction$3 = async ({ transaction, wallet })=> {
     transaction = new Transaction$1(transaction);
     if((await wallet.connectedTo(transaction.blockchain)) == false) {
@@ -59898,7 +59989,8 @@
       throw({ code: 'WRONG_NETWORK' })
     }
     await transaction.prepare({ wallet });
-    let transactionCount = await request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
+    const smartContractWallet = await getSmartContractWallet(transaction.blockchain, transaction.from);
+    const transactionCount = smartContractWallet ? await smartContractWallet.transactionCount() : await request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
     transaction.nonce = transactionCount;
     await submit$3({ transaction, wallet }).then(async (tx)=>{
       if (tx) {
@@ -59906,33 +59998,29 @@
         transaction.id = tx;
         transaction.url = blockchain.explorerUrlFor({ transaction });
         if (transaction.sent) transaction.sent(transaction);
-        let sentTransaction = await retrieveTransaction$1(tx, transaction.blockchain);
+        let sentTransaction = await retrieveTransaction$1({ blockchain: transaction.blockchain, tx, smartContractWallet });
+        transaction.id = sentTransaction.hash || transaction.id;
+        transaction.url = blockchain.explorerUrlFor({ transaction });
         transaction.nonce = sentTransaction.nonce || transactionCount;
-        if(!sentTransaction) {
-          transaction._failed = true;
-          console.log('Error retrieving transaction');
-          if(transaction.failed) transaction.failed(transaction, 'Error retrieving transaction');
-        } else {
-          sentTransaction.wait(1).then(() => {
-            transaction._succeeded = true;
-            if (transaction.succeeded) transaction.succeeded(transaction);
-          }).catch((error)=>{
-            if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
-              if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
-                transaction.id = error.replacement.hash;
-                transaction._succeeded = true;
-                if (transaction.succeeded) transaction.succeeded(transaction);
-              } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
-                transaction.id = error.replacement.hash;
-                transaction._failed = true;
-                if(transaction.failed) transaction.failed(transaction, error);  
-              }
-            } else {
+        sentTransaction.wait(1).then(() => {
+          transaction._succeeded = true;
+          if (transaction.succeeded) transaction.succeeded(transaction);
+        }).catch((error)=>{
+          if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
+            if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
+              transaction.id = error.replacement.hash;
+              transaction._succeeded = true;
+              if (transaction.succeeded) transaction.succeeded(transaction);
+            } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
+              transaction.id = error.replacement.hash;
               transaction._failed = true;
-              if(transaction.failed) transaction.failed(transaction, error);
+              if(transaction.failed) transaction.failed(transaction, error);  
             }
-          });
-        }
+          } else {
+            transaction._failed = true;
+            if(transaction.failed) transaction.failed(transaction, error);
+          }
+        });
       } else {
         throw('Submitting transaction failed!')
       }
@@ -59940,16 +60028,23 @@
     return transaction
   };
 
-  const retrieveTransaction$1 = async (tx, blockchain)=>{
-    let sentTransaction;
+  const retrieveTransaction$1 = async ({ blockchain, tx, smartContractWallet })=>{
     const provider = await getProvider(blockchain);
-    sentTransaction = await provider.getTransaction(tx);
-    const maxRetries = 120;
-    let attempt = 1;
-    while (attempt <= maxRetries && !sentTransaction) {
-      sentTransaction = await provider.getTransaction(tx);
-      await (new Promise((resolve)=>setTimeout(resolve, 5000)));
-      attempt++;
+    let retrieve = async()=>{
+      try {
+        if(smartContractWallet && smartContractWallet.retrieveTransaction) {
+          return await smartContractWallet.retrieveTransaction({ blockchain, tx })
+        } else {
+          return await provider.getTransaction(tx)
+        }
+      } catch (e) {}
+    };
+    
+    let sentTransaction;
+    sentTransaction = await retrieve();
+    while (!sentTransaction) {
+      await (new Promise((resolve)=>setTimeout(resolve, 3000)));
+      sentTransaction = await retrieve();
     }
     return sentTransaction
   };
@@ -59969,15 +60064,6 @@
     const data = await transaction.getData();
     const value = transaction.value ? ethers.ethers.utils.hexlify(ethers.ethers.BigNumber.from(transaction.value)) : undefined;
     const nonce = ethers.ethers.utils.hexlify(transaction.nonce);
-    console.log({
-      from: transaction.from,
-      to: transaction.to,
-      value,
-      data,
-      gas: gas.toHexString(),
-      gasPrice: gasPrice.toHexString(),
-      nonce,
-    });
     return wallet.connector.sendTransaction({
       from: transaction.from,
       to: transaction.to,
@@ -59995,15 +60081,6 @@
     const gas = await estimate(transaction);
     const value = ethers.ethers.utils.hexlify(ethers.ethers.BigNumber.from(transaction.value));
     const nonce = ethers.ethers.utils.hexlify(transaction.nonce);
-    console.log({
-      from: transaction.from,
-      to: transaction.to,
-      value,
-      data: '0x',
-      gas: gas.toHexString(),
-      gasPrice: gasPrice.toHexString(),
-      nonce,
-    });
     return wallet.connector.sendTransaction({
       from: transaction.from,
       to: transaction.to,

package/dist/umd/index.js

@@ -982,6 +982,97 @@
     static __initStatic2() {this.isAvailable = ()=>{ return (_optionalChain$3([window, 'optionalAccess', _5 => _5.ethereum, 'optionalAccess', _6 => _6.isTrust]) || _optionalChain$3([window, 'optionalAccess', _7 => _7.ethereum, 'optionalAccess', _8 => _8.isTrustWallet])) };}
   } Trust.__initStatic(); Trust.__initStatic2();
 
+  class Argent {
+
+    constructor ({ address, blockchain }) {
+      this.address = address;
+      this.blockchain = blockchain;
+    }
+
+    async transactionCount() {
+      return 1 // irrelevant as proxy address/relayer actually sending the transaction is not known yet (but needs to be something)
+    }
+  }
+
+  const blockchainNames = {
+    'ethereum': 'mainnet',
+    'bsc': 'bsc',
+    'polygon': 'polygon',
+  };
+
+  class Safe {
+
+    constructor ({ address, blockchain }) {
+      this.address = address;
+      this.blockchain = blockchain;
+    }
+
+    async transactionCount() {
+      return parseInt((await web3Client.request({
+        blockchain: this.blockchain,
+        address: this.address,
+        api: [{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],
+        method: 'nonce',
+      })).toString(), 10)
+    }
+
+    async retrieveTransaction({ blockchain, tx }) {
+      const provider = await web3Client.getProvider(blockchain);
+      let jsonResult = await fetch(`https://safe-transaction-${blockchainNames[blockchain]}.safe.global/api/v1/multisig-transactions/${tx}/`)
+        .then((response) => response.json())
+        .catch((error) => { console.error('Error:', error); });
+      if(jsonResult && jsonResult.isExecuted && jsonResult.transactionHash) {
+        return await provider.getTransaction(jsonResult.transactionHash)
+      } else {
+        return undefined
+      }
+    }
+  }
+
+  const isSmartContractWallet = async(blockchain, address)=>{
+    const provider = await web3Client.getProvider(blockchain);
+    const code = await provider.getCode(address);
+    return (code != '0x')
+  };
+
+  const identifySmartContractWallet = async (blockchain, address)=>{
+    let name; 
+    try {
+      name = await web3Client.request({
+        blockchain,
+        address,
+        api: [{ "constant": true, "inputs": [], "name": "NAME", "outputs": [{ "internalType": "string", "name": "", "type": "string" }], "payable": false, "stateMutability": "view", "type": "function"}],
+        method: 'NAME'
+      });
+    } catch (e) {}
+    if(name == 'Default Callback Handler') { return 'Safe' }
+    
+    let executor; 
+    try {
+      executor = await web3Client.request({
+        blockchain,
+        address,
+        api: [{ "constant": true, "inputs": [], "name": "staticCallExecutor", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "payable": false, "stateMutability": "view", "type": "function"}],
+        method: 'staticCallExecutor'
+      });
+    } catch (e2) {}
+    if(executor) { return 'Argent' }
+    
+  };
+
+  const getSmartContractWallet = async(blockchain, address)=> {
+    if(!await isSmartContractWallet(blockchain, address)){ return }
+
+    const type = await identifySmartContractWallet(blockchain, address);
+    if(type == 'Safe') {
+      return new Safe({ blockchain, address })
+    } else if(type == 'Argent') {
+      return new Argent({ blockchain, address })
+    } else {
+      throw('Unrecognized smart contract wallet not supported!')
+    }
+  };
+
   const sendTransaction$2 = async ({ transaction, wallet })=> {
     transaction = new Transaction(transaction);
     if((await wallet.connectedTo(transaction.blockchain)) == false) {
@@ -991,7 +1082,8 @@
       throw({ code: 'WRONG_NETWORK' })
     }
     await transaction.prepare({ wallet });
-    let transactionCount = await web3Client.request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
+    const smartContractWallet = await getSmartContractWallet(transaction.blockchain, transaction.from);
+    const transactionCount = smartContractWallet ? await smartContractWallet.transactionCount() : await web3Client.request({ blockchain: transaction.blockchain, method: 'transactionCount', address: transaction.from });
     transaction.nonce = transactionCount;
     await submit$2({ transaction, wallet }).then(async (tx)=>{
       if (tx) {
@@ -999,33 +1091,29 @@
         transaction.id = tx;
         transaction.url = blockchain.explorerUrlFor({ transaction });
         if (transaction.sent) transaction.sent(transaction);
-        let sentTransaction = await retrieveTransaction$1(tx, transaction.blockchain);
+        let sentTransaction = await retrieveTransaction$1({ blockchain: transaction.blockchain, tx, smartContractWallet });
+        transaction.id = sentTransaction.hash || transaction.id;
+        transaction.url = blockchain.explorerUrlFor({ transaction });
         transaction.nonce = sentTransaction.nonce || transactionCount;
-        if(!sentTransaction) {
-          transaction._failed = true;
-          console.log('Error retrieving transaction');
-          if(transaction.failed) transaction.failed(transaction, 'Error retrieving transaction');
-        } else {
-          sentTransaction.wait(1).then(() => {
-            transaction._succeeded = true;
-            if (transaction.succeeded) transaction.succeeded(transaction);
-          }).catch((error)=>{
-            if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
-              if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
-                transaction.id = error.replacement.hash;
-                transaction._succeeded = true;
-                if (transaction.succeeded) transaction.succeeded(transaction);
-              } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
-                transaction.id = error.replacement.hash;
-                transaction._failed = true;
-                if(transaction.failed) transaction.failed(transaction, error);  
-              }
-            } else {
+        sentTransaction.wait(1).then(() => {
+          transaction._succeeded = true;
+          if (transaction.succeeded) transaction.succeeded(transaction);
+        }).catch((error)=>{
+          if(error && error.code && error.code == 'TRANSACTION_REPLACED') {
+            if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 1) {
+              transaction.id = error.replacement.hash;
+              transaction._succeeded = true;
+              if (transaction.succeeded) transaction.succeeded(transaction);
+            } else if(error.replacement && error.replacement.hash && error.receipt && error.receipt.status == 0) {
+              transaction.id = error.replacement.hash;
               transaction._failed = true;
-              if(transaction.failed) transaction.failed(transaction, error);
+              if(transaction.failed) transaction.failed(transaction, error);  
             }
-          });
-        }
+          } else {
+            transaction._failed = true;
+            if(transaction.failed) transaction.failed(transaction, error);
+          }
+        });
       } else {
         throw('Submitting transaction failed!')
       }
@@ -1033,16 +1121,23 @@
     return transaction
   };
 
-  const retrieveTransaction$1 = async (tx, blockchain)=>{
-    let sentTransaction;
+  const retrieveTransaction$1 = async ({ blockchain, tx, smartContractWallet })=>{
     const provider = await web3Client.getProvider(blockchain);
-    sentTransaction = await provider.getTransaction(tx);
-    const maxRetries = 120;
-    let attempt = 1;
-    while (attempt <= maxRetries && !sentTransaction) {
-      sentTransaction = await provider.getTransaction(tx);
-      await (new Promise((resolve)=>setTimeout(resolve, 5000)));
-      attempt++;
+    let retrieve = async()=>{
+      try {
+        if(smartContractWallet && smartContractWallet.retrieveTransaction) {
+          return await smartContractWallet.retrieveTransaction({ blockchain, tx })
+        } else {
+          return await provider.getTransaction(tx)
+        }
+      } catch (e) {}
+    };
+    
+    let sentTransaction;
+    sentTransaction = await retrieve();
+    while (!sentTransaction) {
+      await (new Promise((resolve)=>setTimeout(resolve, 3000)));
+      sentTransaction = await retrieve();
     }
     return sentTransaction
   };
@@ -1062,15 +1157,6 @@
     const data = await transaction.getData();
     const value = transaction.value ? ethers.ethers.utils.hexlify(ethers.ethers.BigNumber.from(transaction.value)) : undefined;
     const nonce = ethers.ethers.utils.hexlify(transaction.nonce);
-    console.log({
-      from: transaction.from,
-      to: transaction.to,
-      value,
-      data,
-      gas: gas.toHexString(),
-      gasPrice: gasPrice.toHexString(),
-      nonce,
-    });
     return wallet.connector.sendTransaction({
       from: transaction.from,
       to: transaction.to,
@@ -1088,15 +1174,6 @@
     const gas = await web3Client.estimate(transaction);
     const value = ethers.ethers.utils.hexlify(ethers.ethers.BigNumber.from(transaction.value));
     const nonce = ethers.ethers.utils.hexlify(transaction.nonce);
-    console.log({
-      from: transaction.from,
-      to: transaction.to,
-      value,
-      data: '0x',
-      gas: gas.toHexString(),
-      gasPrice: gasPrice.toHexString(),
-      nonce,
-    });
     return wallet.connector.sendTransaction({
       from: transaction.from,
       to: transaction.to,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depay/web3-wallets-evm",
   "moduleName": "Web3Wallets",
-  "version": "14.5.2",
+  "version": "14.6.1",
   "description": "One-Stop-Shop JavaScript library to integrate various web3 crypto wallets and multiple blockchains at once with a single interface.",
   "main": "dist/umd/index.evm.js",
   "module": "dist/esm/index.evm.js",