@0xsequence/provider 0.0.0-20230726193528 → 0.0.0-20230801185244

package/dist/0xsequence-provider.cjs.dev.js

@@ -2107,6 +2107,25 @@ function fromExtended(transaction) {
   return [transaction, ...(transaction.auxiliary || [])];
 }
 
+function validateTransactionRequest(wallet, transaction) {
+  const transactions = core.commons.transaction.fromTransactionish(wallet, transaction);
+  const unwound = core.commons.transaction.unwind(wallet, transactions);
+  unwound.forEach(transaction => validateTransaction(wallet, transaction));
+}
+function validateTransaction(wallet, transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.ethers.utils.arrayify(transaction.data);
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden');
+      }
+    }
+  }
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden');
+  }
+}
+
 const SIGNER_READY_TIMEOUT = 10000;
 class WalletRequestHandler {
   constructor(_account, prompter, networks) {
@@ -2297,6 +2316,7 @@ class WalletRequestHandler {
                 }
                 return tx;
               });
+              validateTransactionRequest(account.address, transactionParams);
               let txnHash = '';
               if (_this.prompter === null) {
                 // prompter is null, so we'll send from here
@@ -2322,6 +2342,7 @@ class WalletRequestHandler {
               if (sender !== account.address) {
                 throw new Error('sender address does not match wallet');
               }
+              validateTransactionRequest(account.address, transaction);
               if (_this.prompter === null) {
                 // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
                 // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.
@@ -3101,20 +3122,36 @@ class WalletUtils {
 
 class SequenceProvider extends ethers.ethers.providers.BaseProvider {
   constructor(client, providerFor, networks = network.allNetworks) {
-    var _this;
     // We support a lot of networks
     // but we start with the default one
     super(client.getChainId());
-    _this = this;
+
+    // Emit events as defined by EIP-1193
     this.singleNetworkProviders = {};
     this._isSequenceProvider = true;
     this.client = client;
     this.providerFor = providerFor;
     this.networks = networks;
-    client.onDefaultChainIdChanged(async function (chainId) {
-      // TODO: Maybe we should emit more events here
-      _this.emit('chainChanged', chainId);
+    client.onConnect(details => {
+      this.emit('connect', details);
     });
+    client.onDisconnect(error => {
+      this.emit('disconnect', error);
+    });
+    client.onDefaultChainIdChanged(chainId => {
+      this.emit('chainChanged', chainId);
+    });
+    client.onAccountsChanged(accounts => {
+      this.emit('accountsChanged', accounts);
+    });
+
+    // NOTICE: We don't emit 'open' and 'close' events
+    // because these are handled by the library, and they
+    // are not part of EIP-1193
+
+    // devs can still access them using
+    //   client.onOpen()
+    //   client.onClose()
 
     // Create a Sequence signer too
     this.signer = new SequenceSigner(this.client, this);
@@ -3238,7 +3275,7 @@ class SequenceProvider extends ethers.ethers.providers.BaseProvider {
     var _provider$prepareRequ;
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return this.useChainId();
+      return `0x${(await this.useChainId()).toString(16)}`;
     }
     if (method === 'eth_accounts') {
       return [this.client.getAddress()];
@@ -3549,31 +3586,48 @@ class SequenceClient {
     this.session = new SequenceClientSession(store);
     this.defaultChainId = new DefaultChainIdTracker(store, defaultChainId);
     this.transport.on('accountsChanged', accounts => {
-      var _this$callbacks$onAcc;
+      var _this$callbacks$accou;
       if (accounts.length > 1) {
         console.warn('SequenceClient: wallet-webapp returned more than one account');
       }
-      (_this$callbacks$onAcc = this.callbacks.onAccountsChanged) == null ? void 0 : _this$callbacks$onAcc.forEach(cb => cb(accounts));
+      (_this$callbacks$accou = this.callbacks.accountsChanged) == null ? void 0 : _this$callbacks$accou.forEach(cb => cb(accounts));
+    });
+    this.transport.on('connect', response => {
+      var _this$callbacks$conne;
+      const chainIdHex = ethers.ethers.BigNumber.from(this.getChainId()).toHexString();
+      (_this$callbacks$conne = this.callbacks.connect) == null ? void 0 : _this$callbacks$conne.forEach(cb => cb(_extends({}, response, {
+        // Ignore the full connect response
+        // use the chainId defined locally
+        chainId: chainIdHex
+      })));
+    });
+    this.transport.on('disconnect', error => {
+      var _this$callbacks$disco;
+      (_this$callbacks$disco = this.callbacks.disconnect) == null ? void 0 : _this$callbacks$disco.forEach(cb => cb(error));
     });
     this.transport.on('networks', networks => {
-      var _this$callbacks$onNet;
-      (_this$callbacks$onNet = this.callbacks.onNetworks) == null ? void 0 : _this$callbacks$onNet.forEach(cb => cb(networks));
+      var _this$callbacks$netwo;
+      (_this$callbacks$netwo = this.callbacks.networks) == null ? void 0 : _this$callbacks$netwo.forEach(cb => cb(networks));
     });
     this.transport.on('walletContext', context => {
-      var _this$callbacks$onWal;
-      (_this$callbacks$onWal = this.callbacks.onWalletContext) == null ? void 0 : _this$callbacks$onWal.forEach(cb => cb(context));
+      var _this$callbacks$walle;
+      (_this$callbacks$walle = this.callbacks.walletContext) == null ? void 0 : _this$callbacks$walle.forEach(cb => cb(context));
     });
-    this.transport.on('open', () => {
-      var _this$callbacks$onOpe;
-      (_this$callbacks$onOpe = this.callbacks.onOpen) == null ? void 0 : _this$callbacks$onOpe.forEach(cb => cb());
+    this.transport.on('open', info => {
+      var _this$callbacks$open;
+      (_this$callbacks$open = this.callbacks.open) == null ? void 0 : _this$callbacks$open.forEach(cb => cb(info));
     });
     this.transport.on('close', () => {
-      var _this$callbacks$onClo;
-      (_this$callbacks$onClo = this.callbacks.onClose) == null ? void 0 : _this$callbacks$onClo.forEach(cb => cb());
+      var _this$callbacks$close;
+      (_this$callbacks$close = this.callbacks.close) == null ? void 0 : _this$callbacks$close.forEach(cb => cb());
     });
+
+    // We don't listen for the transport chainChanged event
+    // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged(chainId => {
-      var _this$callbacks$onDef;
-      (_this$callbacks$onDef = this.callbacks.onDefaultChainIdChanged) == null ? void 0 : _this$callbacks$onDef.forEach(cb => cb(chainId));
+      var _this$callbacks$chain;
+      const chainIdHex = ethers.ethers.BigNumber.from(chainId).toHexString();
+      (_this$callbacks$chain = this.callbacks.chainChanged) == null ? void 0 : _this$callbacks$chain.forEach(cb => cb(chainIdHex));
     });
   }
 
@@ -3592,24 +3646,30 @@ class SequenceClient {
   // Individual callbacks lead to more idiomatic code
 
   onOpen(callback) {
-    return this.registerCallback('onOpen', callback);
+    return this.registerCallback('open', callback);
   }
   onClose(callback) {
-    return this.registerCallback('onClose', callback);
+    return this.registerCallback('close', callback);
+  }
+  onConnect(callback) {
+    return this.registerCallback('connect', callback);
+  }
+  onDisconnect(callback) {
+    return this.registerCallback('disconnect', callback);
   }
   onNetworks(callback) {
-    return this.registerCallback('onNetworks', callback);
+    return this.registerCallback('networks', callback);
   }
   onAccountsChanged(callback) {
-    return this.registerCallback('onAccountsChanged', callback);
+    return this.registerCallback('accountsChanged', callback);
   }
 
   // @deprecated
   onWalletContext(callback) {
-    return this.registerCallback('onWalletContext', callback);
+    return this.registerCallback('walletContext', callback);
   }
   onDefaultChainIdChanged(callback) {
-    return this.registerCallback('onDefaultChainIdChanged', callback);
+    return this.registerCallback('chainChanged', callback);
   }
   getChainId() {
     return this.defaultChainId.getDefaultChainId();

package/dist/0xsequence-provider.cjs.prod.js

@@ -2107,6 +2107,25 @@ function fromExtended(transaction) {
   return [transaction, ...(transaction.auxiliary || [])];
 }
 
+function validateTransactionRequest(wallet, transaction) {
+  const transactions = core.commons.transaction.fromTransactionish(wallet, transaction);
+  const unwound = core.commons.transaction.unwind(wallet, transactions);
+  unwound.forEach(transaction => validateTransaction(wallet, transaction));
+}
+function validateTransaction(wallet, transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.ethers.utils.arrayify(transaction.data);
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden');
+      }
+    }
+  }
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden');
+  }
+}
+
 const SIGNER_READY_TIMEOUT = 10000;
 class WalletRequestHandler {
   constructor(_account, prompter, networks) {
@@ -2297,6 +2316,7 @@ class WalletRequestHandler {
                 }
                 return tx;
               });
+              validateTransactionRequest(account.address, transactionParams);
               let txnHash = '';
               if (_this.prompter === null) {
                 // prompter is null, so we'll send from here
@@ -2322,6 +2342,7 @@ class WalletRequestHandler {
               if (sender !== account.address) {
                 throw new Error('sender address does not match wallet');
               }
+              validateTransactionRequest(account.address, transaction);
               if (_this.prompter === null) {
                 // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
                 // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.
@@ -3101,20 +3122,36 @@ class WalletUtils {
 
 class SequenceProvider extends ethers.ethers.providers.BaseProvider {
   constructor(client, providerFor, networks = network.allNetworks) {
-    var _this;
     // We support a lot of networks
     // but we start with the default one
     super(client.getChainId());
-    _this = this;
+
+    // Emit events as defined by EIP-1193
     this.singleNetworkProviders = {};
     this._isSequenceProvider = true;
     this.client = client;
     this.providerFor = providerFor;
     this.networks = networks;
-    client.onDefaultChainIdChanged(async function (chainId) {
-      // TODO: Maybe we should emit more events here
-      _this.emit('chainChanged', chainId);
+    client.onConnect(details => {
+      this.emit('connect', details);
     });
+    client.onDisconnect(error => {
+      this.emit('disconnect', error);
+    });
+    client.onDefaultChainIdChanged(chainId => {
+      this.emit('chainChanged', chainId);
+    });
+    client.onAccountsChanged(accounts => {
+      this.emit('accountsChanged', accounts);
+    });
+
+    // NOTICE: We don't emit 'open' and 'close' events
+    // because these are handled by the library, and they
+    // are not part of EIP-1193
+
+    // devs can still access them using
+    //   client.onOpen()
+    //   client.onClose()
 
     // Create a Sequence signer too
     this.signer = new SequenceSigner(this.client, this);
@@ -3238,7 +3275,7 @@ class SequenceProvider extends ethers.ethers.providers.BaseProvider {
     var _provider$prepareRequ;
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return this.useChainId();
+      return `0x${(await this.useChainId()).toString(16)}`;
     }
     if (method === 'eth_accounts') {
       return [this.client.getAddress()];
@@ -3549,31 +3586,48 @@ class SequenceClient {
     this.session = new SequenceClientSession(store);
     this.defaultChainId = new DefaultChainIdTracker(store, defaultChainId);
     this.transport.on('accountsChanged', accounts => {
-      var _this$callbacks$onAcc;
+      var _this$callbacks$accou;
       if (accounts.length > 1) {
         console.warn('SequenceClient: wallet-webapp returned more than one account');
       }
-      (_this$callbacks$onAcc = this.callbacks.onAccountsChanged) == null ? void 0 : _this$callbacks$onAcc.forEach(cb => cb(accounts));
+      (_this$callbacks$accou = this.callbacks.accountsChanged) == null ? void 0 : _this$callbacks$accou.forEach(cb => cb(accounts));
+    });
+    this.transport.on('connect', response => {
+      var _this$callbacks$conne;
+      const chainIdHex = ethers.ethers.BigNumber.from(this.getChainId()).toHexString();
+      (_this$callbacks$conne = this.callbacks.connect) == null ? void 0 : _this$callbacks$conne.forEach(cb => cb(_extends({}, response, {
+        // Ignore the full connect response
+        // use the chainId defined locally
+        chainId: chainIdHex
+      })));
+    });
+    this.transport.on('disconnect', error => {
+      var _this$callbacks$disco;
+      (_this$callbacks$disco = this.callbacks.disconnect) == null ? void 0 : _this$callbacks$disco.forEach(cb => cb(error));
     });
     this.transport.on('networks', networks => {
-      var _this$callbacks$onNet;
-      (_this$callbacks$onNet = this.callbacks.onNetworks) == null ? void 0 : _this$callbacks$onNet.forEach(cb => cb(networks));
+      var _this$callbacks$netwo;
+      (_this$callbacks$netwo = this.callbacks.networks) == null ? void 0 : _this$callbacks$netwo.forEach(cb => cb(networks));
     });
     this.transport.on('walletContext', context => {
-      var _this$callbacks$onWal;
-      (_this$callbacks$onWal = this.callbacks.onWalletContext) == null ? void 0 : _this$callbacks$onWal.forEach(cb => cb(context));
+      var _this$callbacks$walle;
+      (_this$callbacks$walle = this.callbacks.walletContext) == null ? void 0 : _this$callbacks$walle.forEach(cb => cb(context));
     });
-    this.transport.on('open', () => {
-      var _this$callbacks$onOpe;
-      (_this$callbacks$onOpe = this.callbacks.onOpen) == null ? void 0 : _this$callbacks$onOpe.forEach(cb => cb());
+    this.transport.on('open', info => {
+      var _this$callbacks$open;
+      (_this$callbacks$open = this.callbacks.open) == null ? void 0 : _this$callbacks$open.forEach(cb => cb(info));
     });
     this.transport.on('close', () => {
-      var _this$callbacks$onClo;
-      (_this$callbacks$onClo = this.callbacks.onClose) == null ? void 0 : _this$callbacks$onClo.forEach(cb => cb());
+      var _this$callbacks$close;
+      (_this$callbacks$close = this.callbacks.close) == null ? void 0 : _this$callbacks$close.forEach(cb => cb());
     });
+
+    // We don't listen for the transport chainChanged event
+    // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged(chainId => {
-      var _this$callbacks$onDef;
-      (_this$callbacks$onDef = this.callbacks.onDefaultChainIdChanged) == null ? void 0 : _this$callbacks$onDef.forEach(cb => cb(chainId));
+      var _this$callbacks$chain;
+      const chainIdHex = ethers.ethers.BigNumber.from(chainId).toHexString();
+      (_this$callbacks$chain = this.callbacks.chainChanged) == null ? void 0 : _this$callbacks$chain.forEach(cb => cb(chainIdHex));
     });
   }
 
@@ -3592,24 +3646,30 @@ class SequenceClient {
   // Individual callbacks lead to more idiomatic code
 
   onOpen(callback) {
-    return this.registerCallback('onOpen', callback);
+    return this.registerCallback('open', callback);
   }
   onClose(callback) {
-    return this.registerCallback('onClose', callback);
+    return this.registerCallback('close', callback);
+  }
+  onConnect(callback) {
+    return this.registerCallback('connect', callback);
+  }
+  onDisconnect(callback) {
+    return this.registerCallback('disconnect', callback);
   }
   onNetworks(callback) {
-    return this.registerCallback('onNetworks', callback);
+    return this.registerCallback('networks', callback);
   }
   onAccountsChanged(callback) {
-    return this.registerCallback('onAccountsChanged', callback);
+    return this.registerCallback('accountsChanged', callback);
   }
 
   // @deprecated
   onWalletContext(callback) {
-    return this.registerCallback('onWalletContext', callback);
+    return this.registerCallback('walletContext', callback);
   }
   onDefaultChainIdChanged(callback) {
-    return this.registerCallback('onDefaultChainIdChanged', callback);
+    return this.registerCallback('chainChanged', callback);
   }
   getChainId() {
     return this.defaultChainId.getDefaultChainId();

package/dist/0xsequence-provider.esm.js

@@ -2103,6 +2103,25 @@ function fromExtended(transaction) {
   return [transaction, ...(transaction.auxiliary || [])];
 }
 
+function validateTransactionRequest(wallet, transaction) {
+  const transactions = commons.transaction.fromTransactionish(wallet, transaction);
+  const unwound = commons.transaction.unwind(wallet, transactions);
+  unwound.forEach(transaction => validateTransaction(wallet, transaction));
+}
+function validateTransaction(wallet, transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.utils.arrayify(transaction.data);
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden');
+      }
+    }
+  }
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden');
+  }
+}
+
 const SIGNER_READY_TIMEOUT = 10000;
 class WalletRequestHandler {
   constructor(_account, prompter, networks) {
@@ -2293,6 +2312,7 @@ class WalletRequestHandler {
                 }
                 return tx;
               });
+              validateTransactionRequest(account.address, transactionParams);
               let txnHash = '';
               if (_this.prompter === null) {
                 // prompter is null, so we'll send from here
@@ -2318,6 +2338,7 @@ class WalletRequestHandler {
               if (sender !== account.address) {
                 throw new Error('sender address does not match wallet');
               }
+              validateTransactionRequest(account.address, transaction);
               if (_this.prompter === null) {
                 // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
                 // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.
@@ -3097,20 +3118,36 @@ class WalletUtils {
 
 class SequenceProvider extends ethers.providers.BaseProvider {
   constructor(client, providerFor, networks = allNetworks) {
-    var _this;
     // We support a lot of networks
     // but we start with the default one
     super(client.getChainId());
-    _this = this;
+
+    // Emit events as defined by EIP-1193
     this.singleNetworkProviders = {};
     this._isSequenceProvider = true;
     this.client = client;
     this.providerFor = providerFor;
     this.networks = networks;
-    client.onDefaultChainIdChanged(async function (chainId) {
-      // TODO: Maybe we should emit more events here
-      _this.emit('chainChanged', chainId);
+    client.onConnect(details => {
+      this.emit('connect', details);
     });
+    client.onDisconnect(error => {
+      this.emit('disconnect', error);
+    });
+    client.onDefaultChainIdChanged(chainId => {
+      this.emit('chainChanged', chainId);
+    });
+    client.onAccountsChanged(accounts => {
+      this.emit('accountsChanged', accounts);
+    });
+
+    // NOTICE: We don't emit 'open' and 'close' events
+    // because these are handled by the library, and they
+    // are not part of EIP-1193
+
+    // devs can still access them using
+    //   client.onOpen()
+    //   client.onClose()
 
     // Create a Sequence signer too
     this.signer = new SequenceSigner(this.client, this);
@@ -3234,7 +3271,7 @@ class SequenceProvider extends ethers.providers.BaseProvider {
     var _provider$prepareRequ;
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return this.useChainId();
+      return `0x${(await this.useChainId()).toString(16)}`;
     }
     if (method === 'eth_accounts') {
       return [this.client.getAddress()];
@@ -3545,31 +3582,48 @@ class SequenceClient {
     this.session = new SequenceClientSession(store);
     this.defaultChainId = new DefaultChainIdTracker(store, defaultChainId);
     this.transport.on('accountsChanged', accounts => {
-      var _this$callbacks$onAcc;
+      var _this$callbacks$accou;
       if (accounts.length > 1) {
         console.warn('SequenceClient: wallet-webapp returned more than one account');
       }
-      (_this$callbacks$onAcc = this.callbacks.onAccountsChanged) == null ? void 0 : _this$callbacks$onAcc.forEach(cb => cb(accounts));
+      (_this$callbacks$accou = this.callbacks.accountsChanged) == null ? void 0 : _this$callbacks$accou.forEach(cb => cb(accounts));
+    });
+    this.transport.on('connect', response => {
+      var _this$callbacks$conne;
+      const chainIdHex = ethers.BigNumber.from(this.getChainId()).toHexString();
+      (_this$callbacks$conne = this.callbacks.connect) == null ? void 0 : _this$callbacks$conne.forEach(cb => cb(_extends({}, response, {
+        // Ignore the full connect response
+        // use the chainId defined locally
+        chainId: chainIdHex
+      })));
+    });
+    this.transport.on('disconnect', error => {
+      var _this$callbacks$disco;
+      (_this$callbacks$disco = this.callbacks.disconnect) == null ? void 0 : _this$callbacks$disco.forEach(cb => cb(error));
     });
     this.transport.on('networks', networks => {
-      var _this$callbacks$onNet;
-      (_this$callbacks$onNet = this.callbacks.onNetworks) == null ? void 0 : _this$callbacks$onNet.forEach(cb => cb(networks));
+      var _this$callbacks$netwo;
+      (_this$callbacks$netwo = this.callbacks.networks) == null ? void 0 : _this$callbacks$netwo.forEach(cb => cb(networks));
     });
     this.transport.on('walletContext', context => {
-      var _this$callbacks$onWal;
-      (_this$callbacks$onWal = this.callbacks.onWalletContext) == null ? void 0 : _this$callbacks$onWal.forEach(cb => cb(context));
+      var _this$callbacks$walle;
+      (_this$callbacks$walle = this.callbacks.walletContext) == null ? void 0 : _this$callbacks$walle.forEach(cb => cb(context));
     });
-    this.transport.on('open', () => {
-      var _this$callbacks$onOpe;
-      (_this$callbacks$onOpe = this.callbacks.onOpen) == null ? void 0 : _this$callbacks$onOpe.forEach(cb => cb());
+    this.transport.on('open', info => {
+      var _this$callbacks$open;
+      (_this$callbacks$open = this.callbacks.open) == null ? void 0 : _this$callbacks$open.forEach(cb => cb(info));
     });
     this.transport.on('close', () => {
-      var _this$callbacks$onClo;
-      (_this$callbacks$onClo = this.callbacks.onClose) == null ? void 0 : _this$callbacks$onClo.forEach(cb => cb());
+      var _this$callbacks$close;
+      (_this$callbacks$close = this.callbacks.close) == null ? void 0 : _this$callbacks$close.forEach(cb => cb());
     });
+
+    // We don't listen for the transport chainChanged event
+    // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged(chainId => {
-      var _this$callbacks$onDef;
-      (_this$callbacks$onDef = this.callbacks.onDefaultChainIdChanged) == null ? void 0 : _this$callbacks$onDef.forEach(cb => cb(chainId));
+      var _this$callbacks$chain;
+      const chainIdHex = ethers.BigNumber.from(chainId).toHexString();
+      (_this$callbacks$chain = this.callbacks.chainChanged) == null ? void 0 : _this$callbacks$chain.forEach(cb => cb(chainIdHex));
     });
   }
 
@@ -3588,24 +3642,30 @@ class SequenceClient {
   // Individual callbacks lead to more idiomatic code
 
   onOpen(callback) {
-    return this.registerCallback('onOpen', callback);
+    return this.registerCallback('open', callback);
   }
   onClose(callback) {
-    return this.registerCallback('onClose', callback);
+    return this.registerCallback('close', callback);
+  }
+  onConnect(callback) {
+    return this.registerCallback('connect', callback);
+  }
+  onDisconnect(callback) {
+    return this.registerCallback('disconnect', callback);
   }
   onNetworks(callback) {
-    return this.registerCallback('onNetworks', callback);
+    return this.registerCallback('networks', callback);
   }
   onAccountsChanged(callback) {
-    return this.registerCallback('onAccountsChanged', callback);
+    return this.registerCallback('accountsChanged', callback);
   }
 
   // @deprecated
   onWalletContext(callback) {
-    return this.registerCallback('onWalletContext', callback);
+    return this.registerCallback('walletContext', callback);
   }
   onDefaultChainIdChanged(callback) {
-    return this.registerCallback('onDefaultChainIdChanged', callback);
+    return this.registerCallback('chainChanged', callback);
   }
   getChainId() {
     return this.defaultChainId.getDefaultChainId();

package/dist/declarations/src/client.d.ts

@@ -1,16 +1,8 @@
 import { JsonRpcRequest, NetworkConfig } from "@0xsequence/network";
-import { ConnectDetails, ConnectOptions, ItemStore, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletSession } from "./index.js";
+import { ConnectDetails, ConnectOptions, ItemStore, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletEventTypes, WalletSession } from "./index.js";
 import { commons } from "@0xsequence/core";
 import { TypedData } from "@0xsequence/utils";
 import { ethers } from "ethers";
-type Callbacks = {
-    onOpen: () => void;
-    onClose: () => void;
-    onNetworks: (networks: NetworkConfig[]) => void;
-    onAccountsChanged: (accounts: string[]) => void;
-    onWalletContext: (context: commons.context.VersionedContext) => void;
-    onDefaultChainIdChanged: (chainId: number) => void;
-};
 /**
  *  This session class is meant to persist the state of the wallet connection
  *  whitin the dapp. This enables the client to retain the wallet address (and some more)
@@ -53,13 +45,15 @@ export declare class SequenceClient {
     private readonly callbacks;
     readonly transport: ProviderTransport;
     constructor(transport: ProviderTransport | MuxTransportTemplate, store: ItemStore, defaultChainId?: number);
-    registerCallback<K extends keyof Callbacks>(eventName: K, callback: Callbacks[K]): () => void;
-    onOpen(callback: Callbacks['onOpen']): () => void;
-    onClose(callback: Callbacks['onClose']): () => void;
-    onNetworks(callback: Callbacks['onNetworks']): () => void;
-    onAccountsChanged(callback: Callbacks['onAccountsChanged']): () => void;
-    onWalletContext(callback: Callbacks['onWalletContext']): () => void;
-    onDefaultChainIdChanged(callback: (chainId: number) => void): () => void;
+    registerCallback<K extends keyof WalletEventTypes>(eventName: K, callback: WalletEventTypes[K]): () => void;
+    onOpen(callback: WalletEventTypes['open']): () => void;
+    onClose(callback: WalletEventTypes['close']): () => void;
+    onConnect(callback: WalletEventTypes['connect']): () => void;
+    onDisconnect(callback: WalletEventTypes['disconnect']): () => void;
+    onNetworks(callback: WalletEventTypes['networks']): () => void;
+    onAccountsChanged(callback: WalletEventTypes['accountsChanged']): () => void;
+    onWalletContext(callback: WalletEventTypes['walletContext']): () => void;
+    onDefaultChainIdChanged(callback: WalletEventTypes['chainChanged']): () => void;
     getChainId(): number;
     setDefaultChainId(chainId: number): void;
     openWallet(path?: string, intent?: OpenWalletIntent): Promise<boolean>;
@@ -78,4 +72,3 @@ export declare class SequenceClient {
     getWalletContext(): Promise<commons.context.VersionedContext>;
     getOnchainWalletConfig(options?: OptionalChainId): Promise<commons.config.Config>;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/provider",
-  "version": "0.0.0-20230726193528",
+  "version": "0.0.0-20230801185244",
   "description": "provider sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/provider",
   "source": "src/index.ts",
@@ -11,15 +11,15 @@
   "dependencies": {
     "eventemitter2": "^6.4.5",
     "webextension-polyfill": "^0.10.0",
-    "@0xsequence/abi": "0.0.0-20230726193528",
-    "@0xsequence/account": "0.0.0-20230726193528",
-    "@0xsequence/migration": "0.0.0-20230726193528",
-    "@0xsequence/auth": "0.0.0-20230726193528",
-    "@0xsequence/core": "0.0.0-20230726193528",
-    "@0xsequence/network": "0.0.0-20230726193528",
-    "@0xsequence/relayer": "0.0.0-20230726193528",
-    "@0xsequence/utils": "0.0.0-20230726193528",
-    "@0xsequence/wallet": "0.0.0-20230726193528"
+    "@0xsequence/account": "0.0.0-20230801185244",
+    "@0xsequence/abi": "0.0.0-20230801185244",
+    "@0xsequence/core": "0.0.0-20230801185244",
+    "@0xsequence/auth": "0.0.0-20230801185244",
+    "@0xsequence/migration": "0.0.0-20230801185244",
+    "@0xsequence/network": "0.0.0-20230801185244",
+    "@0xsequence/relayer": "0.0.0-20230801185244",
+    "@0xsequence/utils": "0.0.0-20230801185244",
+    "@0xsequence/wallet": "0.0.0-20230801185244"
   },
   "peerDependencies": {
     "ethers": ">=5.5 < 6"

package/src/client.ts

@@ -1,18 +1,10 @@
 import { JsonRpcRequest, JsonRpcResponse, NetworkConfig } from "@0xsequence/network"
-import { ConnectDetails, ConnectOptions, ItemStore, MuxMessageProvider, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletSession, isMuxTransportTemplate, isProviderTransport } from "."
+import { ConnectDetails, ConnectOptions, ItemStore, MuxMessageProvider, MuxTransportTemplate, OpenWalletIntent, OptionalChainId, OptionalEIP6492, ProviderTransport, WalletEventTypes, WalletSession, isMuxTransportTemplate, isProviderTransport } from "."
 import { commons } from "@0xsequence/core"
 import { TypedData } from "@0xsequence/utils"
 import { toExtended } from "./extended"
 import { ethers } from "ethers"
 
-type Callbacks = {
-  onOpen: () => void
-  onClose: () => void
-  onNetworks: (networks: NetworkConfig[]) => void
-  onAccountsChanged: (accounts: string[]) => void
-  onWalletContext: (context: commons.context.VersionedContext) => void
-  onDefaultChainIdChanged: (chainId: number) => void
-}
 
 /**
  *  This session class is meant to persist the state of the wallet connection
@@ -123,7 +115,7 @@ export class DefaultChainIdTracker {
 export class SequenceClient {  
   private readonly session: SequenceClientSession
   private readonly defaultChainId: DefaultChainIdTracker
-  private readonly callbacks: { [K in keyof Callbacks]?: Callbacks[K][] } = {}
+  private readonly callbacks: { [K in keyof WalletEventTypes]?: WalletEventTypes[K][] } = {}
 
   public readonly transport: ProviderTransport
 
@@ -148,33 +140,50 @@ export class SequenceClient {
         console.warn('SequenceClient: wallet-webapp returned more than one account')
       }
 
-      this.callbacks.onAccountsChanged?.forEach(cb => cb(accounts))
+      this.callbacks.accountsChanged?.forEach(cb => cb(accounts))
+    })
+
+    this.transport.on('connect', (response: ConnectDetails) => {
+      const chainIdHex = ethers.BigNumber.from(this.getChainId()).toHexString()
+      this.callbacks.connect?.forEach(cb => cb({
+        ...response,
+        // Ignore the full connect response
+        // use the chainId defined locally
+        chainId: chainIdHex
+      }))
+    })
+
+    this.transport.on('disconnect', (error) => {
+      this.callbacks.disconnect?.forEach(cb => cb(error))
     })
 
-    this.transport.on('networks', (networks: NetworkConfig[]) => {
-      this.callbacks.onNetworks?.forEach(cb => cb(networks))
+    this.transport.on('networks', (networks) => {
+      this.callbacks.networks?.forEach(cb => cb(networks))
     })
 
-    this.transport.on('walletContext', (context: commons.context.VersionedContext) => {
-      this.callbacks.onWalletContext?.forEach(cb => cb(context))
+    this.transport.on('walletContext', (context) => {
+      this.callbacks.walletContext?.forEach(cb => cb(context))
     })
 
-    this.transport.on('open', () => {
-      this.callbacks.onOpen?.forEach(cb => cb())
+    this.transport.on('open', (info) => {
+      this.callbacks.open?.forEach(cb => cb(info))
     })
 
     this.transport.on('close', () => {
-      this.callbacks.onClose?.forEach(cb => cb())
+      this.callbacks.close?.forEach(cb => cb())
     })
   
+    // We don't listen for the transport chainChanged event
+    // instead we handle it locally, so we listen for changes in the store
     this.defaultChainId.onDefaultChainIdChanged((chainId: number) => {
-      this.callbacks.onDefaultChainIdChanged?.forEach(cb => cb(chainId))
+      const chainIdHex = ethers.BigNumber.from(chainId).toHexString()
+      this.callbacks.chainChanged?.forEach(cb => cb(chainIdHex))
     })
   }
 
   // Callbacks
 
-  registerCallback<K extends keyof Callbacks>(eventName: K, callback: Callbacks[K]) {
+  registerCallback<K extends keyof WalletEventTypes>(eventName: K, callback: WalletEventTypes[K]) {
     if (!this.callbacks[eventName]) {
       this.callbacks[eventName] = []
     }
@@ -188,29 +197,37 @@ export class SequenceClient {
 
   // Individual callbacks lead to more idiomatic code
 
-  onOpen(callback: Callbacks['onOpen']) {
-    return this.registerCallback('onOpen', callback)
+  onOpen(callback: WalletEventTypes['open']) {
+    return this.registerCallback('open', callback)
   }
 
-  onClose(callback: Callbacks['onClose']) {
-    return this.registerCallback('onClose', callback)
+  onClose(callback: WalletEventTypes['close']) {
+    return this.registerCallback('close', callback)
+  }
+
+  onConnect(callback: WalletEventTypes['connect']) {
+    return this.registerCallback('connect', callback)
+  }
+
+  onDisconnect(callback: WalletEventTypes['disconnect']) {
+    return this.registerCallback('disconnect', callback)
   }
   
-  onNetworks(callback: Callbacks['onNetworks']) {
-    return this.registerCallback('onNetworks', callback)
+  onNetworks(callback: WalletEventTypes['networks']) {
+    return this.registerCallback('networks', callback)
   }
 
-  onAccountsChanged(callback: Callbacks['onAccountsChanged']) {
-    return this.registerCallback('onAccountsChanged', callback)
+  onAccountsChanged(callback: WalletEventTypes['accountsChanged']) {
+    return this.registerCallback('accountsChanged', callback)
   }
 
   // @deprecated
-  onWalletContext(callback: Callbacks['onWalletContext']) {
-    return this.registerCallback('onWalletContext', callback)
+  onWalletContext(callback: WalletEventTypes['walletContext']) {
+    return this.registerCallback('walletContext', callback)
   }
 
-  onDefaultChainIdChanged(callback: (chainId: number) => void) {
-    return this.registerCallback('onDefaultChainIdChanged', callback)
+  onDefaultChainIdChanged(callback: WalletEventTypes['chainChanged']) {
+    return this.registerCallback('chainChanged', callback)
   }
 
   getChainId(): number {

package/src/provider.ts

@@ -63,11 +63,32 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     // We support a lot of networks
     // but we start with the default one
     super(client.getChainId())
-    client.onDefaultChainIdChanged(async (chainId) => {
-      // TODO: Maybe we should emit more events here
+
+    // Emit events as defined by EIP-1193
+    client.onConnect((details) => {
+      this.emit('connect', details)
+    })
+
+    client.onDisconnect((error) => {
+      this.emit('disconnect', error)
+    })
+
+    client.onDefaultChainIdChanged((chainId) => {
       this.emit('chainChanged', chainId)
     })
 
+    client.onAccountsChanged((accounts) => {
+      this.emit('accountsChanged', accounts)
+    })
+
+    // NOTICE: We don't emit 'open' and 'close' events
+    // because these are handled by the library, and they
+    // are not part of EIP-1193
+
+    // devs can still access them using
+    //   client.onOpen()
+    //   client.onClose()
+
     // Create a Sequence signer too
     this.signer = new SequenceSigner(this.client, this)
 
@@ -226,7 +247,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   async perform(method: string, params: any): Promise<any> {
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return this.useChainId()
+      return `0x${(await this.useChainId()).toString(16)}`
     }
 
     if (method === 'eth_accounts') {

package/src/transactions.ts

@@ -0,0 +1,23 @@
+import { commons } from '@0xsequence/core'
+import { ethers } from 'ethers'
+
+export function validateTransactionRequest(wallet: string, transaction: commons.transaction.Transactionish) {
+  const transactions = commons.transaction.fromTransactionish(wallet, transaction)
+  const unwound = commons.transaction.unwind(wallet, transactions)
+  unwound.forEach(transaction => validateTransaction(wallet, transaction))
+}
+
+function validateTransaction(wallet: string, transaction: commons.transaction.Transaction) {
+  if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
+    if (transaction.data) {
+      const data = ethers.utils.arrayify(transaction.data)
+      if (data.length >= 4) {
+        throw new Error('self calls are forbidden')
+      }
+    }
+  }
+
+  if (transaction.delegateCall) {
+    throw new Error('delegate calls are forbidden')
+  }
+}

package/src/transports/wallet-request-handler.ts

@@ -7,6 +7,7 @@ import { BigNumber, ethers, providers } from 'ethers'
 import { EventEmitter2 as EventEmitter } from 'eventemitter2'
 
 import { fromExtended } from '../extended'
+import { validateTransactionRequest } from '../transactions'
 import {
   ProviderMessageRequest,
   ProviderMessageResponse,
@@ -393,6 +394,8 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
               return tx
             })
 
+          validateTransactionRequest(account.address, transactionParams)
+
           let txnHash = ''
           if (this.prompter === null) {
             // prompter is null, so we'll send from here
@@ -421,6 +424,8 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
             throw new Error('sender address does not match wallet')
           }
 
+          validateTransactionRequest(account.address, transaction)
+
           if (this.prompter === null) {
             // The eth_signTransaction method expects a `string` return value we instead return a `SignedTransactions` object,
             // this can only be broadcasted using an RPC provider with support for signed Sequence transactions, like this one.