@0xsequence/account 1.2.0 → 1.2.1

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

@@ -29,7 +29,7 @@ function isPromise(value) {
 }
 function isDeferrable(value) {
   // The value is deferrable if any of the properties is a Promises
-  if (typeof value === "object") {
+  if (typeof value === 'object') {
     return Object.keys(value).some(key => isPromise(value[key]));
   }
   return false;
@@ -59,15 +59,15 @@ function encodeGasRefundTransaction(option) {
         to: option.token.contractAddress,
         value: 0,
         data: new ethers.ethers.utils.Interface([{
-          "constant": false,
-          "inputs": [{
-            "type": "address"
+          constant: false,
+          inputs: [{
+            type: 'address'
           }, {
-            "type": "uint256"
+            type: 'uint256'
           }],
-          "name": "transfer",
-          "outputs": [],
-          "type": "function"
+          name: 'transfer',
+          outputs: [],
+          type: 'function'
         }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
       }];
     default:
@@ -98,15 +98,15 @@ class AccountSigner {
     // If there are multiple options, try them one by one
     // until we find one that satisfies the balance requirement
     const balanceOfAbi = [{
-      "constant": true,
-      "inputs": [{
-        "type": "address"
+      constant: true,
+      inputs: [{
+        type: 'address'
       }],
-      "name": "balanceOf",
-      "outputs": [{
-        "type": "uint256"
+      name: 'balanceOf',
+      outputs: [{
+        type: 'uint256'
       }],
-      "type": "function"
+      type: 'function'
     }];
     for (const option of options) {
       if (option.token.type === relayer.proto.FeeTokenType.UNKNOWN) {
@@ -124,7 +124,7 @@ class AccountSigner {
         }
       } else ;
     }
-    throw new Error("No fee option available - not enough balance");
+    throw new Error('No fee option available - not enough balance');
   }
   async sendTransaction(txsPromise) {
     var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
@@ -153,34 +153,34 @@ class AccountSigner {
     return res;
   }
   connect(_provider) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   signTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getTransactionCount(blockTag) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   estimateGas(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getChainId() {
     return Promise.resolve(ethers.ethers.BigNumber.from(this.chainId).toNumber());
   }
   getGasPrice() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getFeeData() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   checkTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   populateTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   _checkProvider(operation) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 }
 

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

@@ -29,7 +29,7 @@ function isPromise(value) {
 }
 function isDeferrable(value) {
   // The value is deferrable if any of the properties is a Promises
-  if (typeof value === "object") {
+  if (typeof value === 'object') {
     return Object.keys(value).some(key => isPromise(value[key]));
   }
   return false;
@@ -59,15 +59,15 @@ function encodeGasRefundTransaction(option) {
         to: option.token.contractAddress,
         value: 0,
         data: new ethers.ethers.utils.Interface([{
-          "constant": false,
-          "inputs": [{
-            "type": "address"
+          constant: false,
+          inputs: [{
+            type: 'address'
           }, {
-            "type": "uint256"
+            type: 'uint256'
           }],
-          "name": "transfer",
-          "outputs": [],
-          "type": "function"
+          name: 'transfer',
+          outputs: [],
+          type: 'function'
         }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
       }];
     default:
@@ -98,15 +98,15 @@ class AccountSigner {
     // If there are multiple options, try them one by one
     // until we find one that satisfies the balance requirement
     const balanceOfAbi = [{
-      "constant": true,
-      "inputs": [{
-        "type": "address"
+      constant: true,
+      inputs: [{
+        type: 'address'
       }],
-      "name": "balanceOf",
-      "outputs": [{
-        "type": "uint256"
+      name: 'balanceOf',
+      outputs: [{
+        type: 'uint256'
       }],
-      "type": "function"
+      type: 'function'
     }];
     for (const option of options) {
       if (option.token.type === relayer.proto.FeeTokenType.UNKNOWN) {
@@ -124,7 +124,7 @@ class AccountSigner {
         }
       } else ;
     }
-    throw new Error("No fee option available - not enough balance");
+    throw new Error('No fee option available - not enough balance');
   }
   async sendTransaction(txsPromise) {
     var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
@@ -153,34 +153,34 @@ class AccountSigner {
     return res;
   }
   connect(_provider) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   signTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getTransactionCount(blockTag) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   estimateGas(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getChainId() {
     return Promise.resolve(ethers.ethers.BigNumber.from(this.chainId).toNumber());
   }
   getGasPrice() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getFeeData() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   checkTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   populateTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   _checkProvider(operation) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 }
 

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

@@ -25,7 +25,7 @@ function isPromise(value) {
 }
 function isDeferrable(value) {
   // The value is deferrable if any of the properties is a Promises
-  if (typeof value === "object") {
+  if (typeof value === 'object') {
     return Object.keys(value).some(key => isPromise(value[key]));
   }
   return false;
@@ -55,15 +55,15 @@ function encodeGasRefundTransaction(option) {
         to: option.token.contractAddress,
         value: 0,
         data: new ethers.utils.Interface([{
-          "constant": false,
-          "inputs": [{
-            "type": "address"
+          constant: false,
+          inputs: [{
+            type: 'address'
           }, {
-            "type": "uint256"
+            type: 'uint256'
           }],
-          "name": "transfer",
-          "outputs": [],
-          "type": "function"
+          name: 'transfer',
+          outputs: [],
+          type: 'function'
         }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
       }];
     default:
@@ -94,15 +94,15 @@ class AccountSigner {
     // If there are multiple options, try them one by one
     // until we find one that satisfies the balance requirement
     const balanceOfAbi = [{
-      "constant": true,
-      "inputs": [{
-        "type": "address"
+      constant: true,
+      inputs: [{
+        type: 'address'
       }],
-      "name": "balanceOf",
-      "outputs": [{
-        "type": "uint256"
+      name: 'balanceOf',
+      outputs: [{
+        type: 'uint256'
       }],
-      "type": "function"
+      type: 'function'
     }];
     for (const option of options) {
       if (option.token.type === proto.FeeTokenType.UNKNOWN) {
@@ -120,7 +120,7 @@ class AccountSigner {
         }
       } else ;
     }
-    throw new Error("No fee option available - not enough balance");
+    throw new Error('No fee option available - not enough balance');
   }
   async sendTransaction(txsPromise) {
     var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
@@ -149,34 +149,34 @@ class AccountSigner {
     return res;
   }
   connect(_provider) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   signTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getTransactionCount(blockTag) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   estimateGas(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getChainId() {
     return Promise.resolve(ethers.BigNumber.from(this.chainId).toNumber());
   }
   getGasPrice() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   getFeeData() {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   checkTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   populateTransaction(transaction) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
   _checkProvider(operation) {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 }
 

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

@@ -1,8 +1,8 @@
-import { ChainId } from "@0xsequence/network";
+import { ChainId } from '@0xsequence/network';
 import { Account } from "./account.js";
-import { ethers } from "ethers";
-import { commons } from "@0xsequence/core";
-import { FeeOption } from "@0xsequence/relayer";
+import { ethers } from 'ethers';
+import { commons } from '@0xsequence/core';
+import { FeeOption } from '@0xsequence/relayer';
 export type AccountSignerOptions = {
     nonceSpace?: ethers.BigNumberish;
     cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/account",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "tools for migrating sequence wallets to new versions",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/account",
   "source": "src/index.ts",
@@ -10,19 +10,19 @@
   "license": "Apache-2.0",
   "dependencies": {
     "ethers": "^5.5.2",
-    "@0xsequence/core": "1.2.0",
-    "@0xsequence/migration": "1.2.0",
-    "@0xsequence/relayer": "1.2.0",
-    "@0xsequence/network": "1.2.0",
-    "@0xsequence/sessions": "1.2.0",
-    "@0xsequence/utils": "1.2.0",
-    "@0xsequence/wallet": "1.2.0"
+    "@0xsequence/core": "1.2.1",
+    "@0xsequence/migration": "1.2.1",
+    "@0xsequence/network": "1.2.1",
+    "@0xsequence/relayer": "1.2.1",
+    "@0xsequence/utils": "1.2.1",
+    "@0xsequence/sessions": "1.2.1",
+    "@0xsequence/wallet": "1.2.1"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "nyc": "^15.1.0",
-    "@0xsequence/signhub": "1.2.0",
-    "@0xsequence/tests": "1.2.0"
+    "@0xsequence/signhub": "1.2.1",
+    "@0xsequence/tests": "1.2.1"
   },
   "files": [
     "src",

package/src/signer.ts

@@ -1,14 +1,14 @@
-import { ChainId } from "@0xsequence/network"
-import { Account } from "./account"
-import { ethers } from "ethers"
-import { commons } from "@0xsequence/core"
-import { FeeOption, proto } from "@0xsequence/relayer"
-import { isDeferrable } from "./utils"
+import { ChainId } from '@0xsequence/network'
+import { Account } from './account'
+import { ethers } from 'ethers'
+import { commons } from '@0xsequence/core'
+import { FeeOption, proto } from '@0xsequence/relayer'
+import { isDeferrable } from './utils'
 
 export type AccountSignerOptions = {
-  nonceSpace?: ethers.BigNumberish,
-  cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw',
-  stubSignatureOverrides?: Map<string, string>,
+  nonceSpace?: ethers.BigNumberish
+  cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'
+  stubSignatureOverrides?: Map<string, string>
   selectFee?: (
     txs: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish,
     options: FeeOption[]
@@ -22,37 +22,40 @@ function encodeGasRefundTransaction(option?: FeeOption) {
 
   switch (option.token.type) {
     case proto.FeeTokenType.UNKNOWN:
-      return [{
-        delegateCall: false,
-        revertOnError: true,
-        gasLimit: option.gasLimit,
-        to: option.to,
-        value: value.toHexString(),
-        data: []
-      }]
+      return [
+        {
+          delegateCall: false,
+          revertOnError: true,
+          gasLimit: option.gasLimit,
+          to: option.to,
+          value: value.toHexString(),
+          data: []
+        }
+      ]
 
     case proto.FeeTokenType.ERC20_TOKEN:
       if (!option.token.contractAddress) {
         throw new Error(`No contract address for ERC-20 fee option`)
       }
 
-      return [{
-        delegateCall: false,
-        revertOnError: true,
-        gasLimit: option.gasLimit,
-        to: option.token.contractAddress,
-        value: 0,
-        data: new ethers.utils.Interface([{
-          "constant": false,
-          "inputs": [
-            {"type": "address"},
-            {"type": "uint256"}
-          ],
-          "name": "transfer",
-          "outputs": [],
-          "type": "function"
-        }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
-      }]
+      return [
+        {
+          delegateCall: false,
+          revertOnError: true,
+          gasLimit: option.gasLimit,
+          to: option.token.contractAddress,
+          value: 0,
+          data: new ethers.utils.Interface([
+            {
+              constant: false,
+              inputs: [{ type: 'address' }, { type: 'uint256' }],
+              name: 'transfer',
+              outputs: [],
+              type: 'function'
+            }
+          ]).encodeFunctionData('transfer', [option.to, value.toHexString()])
+        }
+      ]
 
     default:
       throw new Error(`Unhandled fee token type ${option.token.type}`)
@@ -62,7 +65,7 @@ function encodeGasRefundTransaction(option?: FeeOption) {
 export class AccountSigner implements ethers.Signer {
   public readonly _isSigner = true
 
-  constructor (
+  constructor(
     public account: Account,
     public chainId: ChainId,
     public readonly options?: AccountSignerOptions
@@ -76,14 +79,8 @@ export class AccountSigner implements ethers.Signer {
     return this.account.address
   }
 
-  signMessage(
-    message: string | ethers.utils.Bytes
-  ): Promise<string> {
-    return this.account.signMessage(
-      message,
-      this.chainId,
-      this.options?.cantValidateBehavior ?? 'throw'
-    )
+  signMessage(message: string | ethers.utils.Bytes): Promise<string> {
+    return this.account.signMessage(message, this.chainId, this.options?.cantValidateBehavior ?? 'throw')
   }
 
   private async defaultSelectFee(
@@ -95,14 +92,16 @@ export class AccountSigner implements ethers.Signer {
 
     // If there are multiple options, try them one by one
     // until we find one that satisfies the balance requirement
-    const balanceOfAbi = [{
-      "constant": true,
-      "inputs": [{"type": "address"}],
-      "name": "balanceOf",
-      "outputs": [{"type": "uint256"}],
-      "type": "function"
-    }]
-    
+    const balanceOfAbi = [
+      {
+        constant: true,
+        inputs: [{ type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ type: 'uint256' }],
+        type: 'function'
+      }
+    ]
+
     for (const option of options) {
       if (option.token.type === proto.FeeTokenType.UNKNOWN) {
         // Native token
@@ -122,14 +121,14 @@ export class AccountSigner implements ethers.Signer {
       }
     }
 
-    throw new Error("No fee option available - not enough balance")
+    throw new Error('No fee option available - not enough balance')
   }
 
   async sendTransaction(
     txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish
   ): Promise<ethers.providers.TransactionResponse> {
-    const txs = isDeferrable(txsPromise) ? (
-      await ethers.utils.resolveProperties(txsPromise as ethers.utils.Deferrable<ethers.providers.TransactionRequest>))
+    const txs = isDeferrable(txsPromise)
+      ? await ethers.utils.resolveProperties(txsPromise as ethers.utils.Deferrable<ethers.providers.TransactionRequest>)
       : txsPromise
 
     const prepare = await this.account.prepareTransactions({
@@ -141,10 +140,7 @@ export class AccountSigner implements ethers.Signer {
     const selectMethod = this.options?.selectFee ?? this.defaultSelectFee.bind(this)
     const feeOption = await selectMethod(txs, prepare.feeOptions)
 
-    const finalTransactions = [
-      ...prepare.transactions,
-      ...encodeGasRefundTransaction(feeOption)
-    ]
+    const finalTransactions = [...prepare.transactions, ...encodeGasRefundTransaction(feeOption)]
 
     return this.account.sendTransaction(
       finalTransactions,
@@ -152,9 +148,11 @@ export class AccountSigner implements ethers.Signer {
       prepare.feeQuote,
       undefined,
       undefined,
-      this.options?.nonceSpace ? {
-        nonceSpace: this.options.nonceSpace
-      } : undefined
+      this.options?.nonceSpace
+        ? {
+            nonceSpace: this.options.nonceSpace
+          }
+        : undefined
     )
   }
 
@@ -176,23 +174,19 @@ export class AccountSigner implements ethers.Signer {
   }
 
   connect(_provider: ethers.providers.Provider): ethers.Signer {
-    throw new Error("Method not implemented.")
+    throw new Error('Method not implemented.')
   }
 
-  signTransaction(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-  ): Promise<string> {
-    throw new Error("Method not implemented.")
+  signTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<string> {
+    throw new Error('Method not implemented.')
   }
 
   getTransactionCount(blockTag?: ethers.providers.BlockTag | undefined): Promise<number> {
-    throw new Error("Method not implemented.")
+    throw new Error('Method not implemented.')
   }
 
-  estimateGas(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-  ): Promise<ethers.BigNumber> {
-    throw new Error("Method not implemented.")
+  estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.BigNumber> {
+    throw new Error('Method not implemented.')
   }
 
   getChainId(): Promise<number> {
@@ -200,22 +194,26 @@ export class AccountSigner implements ethers.Signer {
   }
 
   getGasPrice(): Promise<ethers.BigNumber> {
-    throw new Error("Method not implemented.")
+    throw new Error('Method not implemented.')
   }
 
   getFeeData(): Promise<ethers.providers.FeeData> {
-    throw new Error("Method not implemented.")
+    throw new Error('Method not implemented.')
   }
 
-  checkTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): ethers.utils.Deferrable<ethers.providers.TransactionRequest> {
-    throw new Error("Method not implemented.")
+  checkTransaction(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+  ): ethers.utils.Deferrable<ethers.providers.TransactionRequest> {
+    throw new Error('Method not implemented.')
   }
 
-  populateTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.providers.TransactionRequest> {
-    throw new Error("Method not implemented.")
+  populateTransaction(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+  ): Promise<ethers.providers.TransactionRequest> {
+    throw new Error('Method not implemented.')
   }
 
   _checkProvider(operation?: string | undefined): void {
-    throw new Error("Method not implemented.")
+    throw new Error('Method not implemented.')
   }
 }

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { ethers } from "ethers"
+import { ethers } from 'ethers'
 
 function isPromise(value: any): value is Promise<any> {
   return !!value && typeof value.then === 'function'
@@ -6,8 +6,8 @@ function isPromise(value: any): value is Promise<any> {
 
 export function isDeferrable<T>(value: any): value is ethers.utils.Deferrable<T> {
   // The value is deferrable if any of the properties is a Promises
-  if (typeof(value) === "object") {
-    return Object.keys(value).some((key) => isPromise(value[key]))
+  if (typeof value === 'object') {
+    return Object.keys(value).some(key => isPromise(value[key]))
   }
 
   return false