@bitpay-labs/bitcore-wallet-service 11.11.1 → 11.11.3

package/src/lib/storage.ts

@@ -304,8 +304,9 @@ export class Storage {
   }
 
   // TODO: should be done client-side
-  _completeTxData(walletId: string, txs: TxProposal | TxProposal[], cb: (err?: any, txs?: TxProposal | TxProposal[]) => void) {
-    this.fetchWallet(walletId, (err, wallet) => {
+  // Callers that already have the wallet pass it, to save reading it again
+  _completeTxData(walletId: string, txs: TxProposal | TxProposal[], cb: (err?: any, txs?: TxProposal | TxProposal[]) => void, wallet?: Wallet) {
+    const complete = (err, wallet: Wallet) => {
       if (err) return cb(err);
       for (const tx of [].concat(txs) as TxProposal[]) {
         tx.derivationStrategy = wallet.derivationStrategy || 'BIP45';
@@ -318,11 +319,13 @@ export class Storage {
           tx.raw = tx.getRawTx();
       }
       return cb(null, txs);
-    });
+    };
+    if (wallet) return complete(null, wallet);
+    this.fetchWallet(walletId, complete);
   }
 
   // TODO: remove walletId from signature
-  fetchTx(walletId: string, txProposalId: string, cb: (err?: any, tx?: TxProposal) => void) {
+  fetchTx(walletId: string, txProposalId: string, cb: (err?: any, tx?: TxProposal) => void, wallet?: Wallet) {
     if (!this.db) return cb();
 
     this.db.collection(collections.TXS).findOne(
@@ -333,7 +336,7 @@ export class Storage {
       (err, result) => {
         if (err) return cb(err);
         if (!result) return cb();
-        return this._completeTxData(walletId, TxProposal.fromObj(result), cb);
+        return this._completeTxData(walletId, TxProposal.fromObj(result), cb, wallet);
       }
     );
   }
@@ -356,7 +359,7 @@ export class Storage {
 
   // Wallet-scoped counterpart to fetchTxByHash, used by the authenticated
   // by-hash API read.
-  fetchTxByHashForWallet(walletId: string, hash, cb: (err?: any, tx?: TxProposal) => void) {
+  fetchTxByHashForWallet(walletId: string, hash, cb: (err?: any, tx?: TxProposal) => void, wallet?: Wallet) {
     if (!this.db) return cb();
 
     this.db.collection(collections.TXS).findOne(
@@ -368,7 +371,7 @@ export class Storage {
         if (err) return cb(err);
         if (!result) return cb();
 
-        return this._completeTxData(walletId, TxProposal.fromObj(result), cb);
+        return this._completeTxData(walletId, TxProposal.fromObj(result), cb, wallet);
       }
     );
   }
@@ -444,7 +447,7 @@ export class Storage {
     });
   }
 
-  fetchPendingTxs(walletId, cb) {
+  fetchPendingTxs(walletId, cb, wallet?: Wallet) {
     this.db
       .collection(collections.TXS)
       .find({
@@ -460,7 +463,7 @@ export class Storage {
         const txs = _.map(result, tx => {
           return TxProposal.fromObj(tx);
         });
-        return this._completeTxData(walletId, txs, cb);
+        return this._completeTxData(walletId, txs, cb, wallet);
       });
   }
 
@@ -472,7 +475,7 @@ export class Storage {
    * @param opts.maxTs
    * @param opts.limit
    */
-  fetchTxs(walletId, opts, cb) {
+  fetchTxs(walletId, opts, cb, wallet?: Wallet) {
     opts = opts || {};
 
     const tsFilter: { $gte?: number; $lte?: number } = {};
@@ -499,7 +502,7 @@ export class Storage {
         const txs = _.map(result, tx => {
           return TxProposal.fromObj(tx);
         });
-        return this._completeTxData(walletId, txs, cb);
+        return this._completeTxData(walletId, txs, cb, wallet);
       });
   }
 
@@ -511,7 +514,7 @@ export class Storage {
    * @param opts.maxTs
    * @param opts.limit
    */
-  fetchBroadcastedTxs(walletId, opts, cb) {
+  fetchBroadcastedTxs(walletId, opts, cb, wallet?: Wallet) {
     opts = opts || {};
 
     const tsFilter: { $gte?: number; $lte?: number } = {};
@@ -543,7 +546,7 @@ export class Storage {
         const txs = _.map(result, tx => {
           return TxProposal.fromObj(tx);
         });
-        return this._completeTxData(walletId, txs, cb);
+        return this._completeTxData(walletId, txs, cb, wallet);
       });
   }
 
@@ -678,6 +681,70 @@ export class Storage {
       });
   }
 
+  /**
+   * A page of the wallet's addresses, in fetchAddresses order (createdOn, then path), reading only the addresses the
+   * page needs. noChange and addresses filter the list, then reverse, skip and limit apply in that order.
+   *
+   * @param walletId
+   * @param opts.noChange - leave out change addresses
+   * @param opts.addresses - only these addresses
+   * @param opts.reverse - newest first
+   * @param opts.skip
+   * @param opts.limit
+   */
+  fetchAddressesPage(
+    walletId: string,
+    opts: { noChange?: boolean; addresses?: string[]; reverse?: boolean; skip?: number; limit?: number },
+    cb: (err?: any, addresses?: Address[]) => void
+  ) {
+    const query: { walletId: string; isChange?: { $in: Array<false | null> }; address?: { $in: string[] } } = { walletId };
+    // false, null or missing, the same addresses as !isChange
+    if (opts.noChange) query.isChange = { $in: [false, null] };
+    if (opts.addresses) query.address = { $in: opts.addresses };
+    // skip and limit apply only when positive, and as whole numbers, as slice does
+    const skip = opts.skip > 0 ? Math.floor(opts.skip) : 0;
+    const limit = opts.limit > 0 ? Math.floor(opts.limit) : null;
+    const collection = this.db.collection(collections.ADDRESSES);
+
+    const page = docs => {
+      let addresses = Utils.sortAsc(docs.map(Address.fromObj), 'createdOn', 'path');
+      if (opts.reverse) addresses.reverse();
+      if (skip) addresses = addresses.slice(skip);
+      if (limit !== null) addresses = addresses.slice(0, limit);
+      return addresses;
+    };
+    const readAll = () => collection.find(query).sort({ createdOn: 1 }).toArray((err, docs) => {
+      if (err) return cb(err);
+      return cb(null, page(docs));
+    });
+
+    // filtering by address, or reading without a limit or with one too large for a query limit, reads every matching
+    // address
+    if (opts.addresses || !(limit > 0) || !Number.isSafeInteger(skip + limit + 1)) return readAll();
+
+    // fetchAddresses sorts an address with a missing createdOn last and one with a null createdOn first, but Mongo sorts
+    // both first, so a wallet that has either is read whole
+    collection.findOne({ walletId, createdOn: null }, { projection: { _id: 1 } }, (err, unordered) => {
+      if (err) return cb(err);
+      if (unordered) return readAll();
+
+      // The page is within the first skip + limit addresses by createdOn plus any others sharing the last one's
+      // createdOn, whatever order addresses created in the same second are in. One more address shows whether there are any.
+      const count = skip + limit;
+      collection.find(query).sort({ createdOn: opts.reverse ? -1 : 1 }).limit(count + 1).toArray((err, docs) => {
+        if (err) return cb(err);
+        if (docs.length <= count || docs[count].createdOn !== docs[count - 1].createdOn) {
+          return cb(null, page(docs.slice(0, count)));
+        }
+        collection.find({ ...query, createdOn: docs[count - 1].createdOn }).toArray((err, ties) => {
+          if (err) return cb(err);
+          const read = new Set(docs.slice(0, count).map(doc => String(doc._id)));
+          return cb(null, page([...docs.slice(0, count), ...ties.filter(doc => !read.has(String(doc._id)))]));
+        });
+      });
+    });
+  }
+
   migrateToCashAddr(walletId, cb) {
     const cursor = this.db.collection(collections.ADDRESSES).find({
       walletId
@@ -768,6 +835,26 @@ export class Storage {
     );
   }
 
+  storeWalletRegistration(wallet, cb) {
+    this.db.collection(collections.WALLETS).updateOne(
+      {
+        id: wallet.id
+      },
+      {
+        $set: {
+          beRegistered: wallet.beRegistered,
+          beAuthPrivateKey2: wallet.beAuthPrivateKey2,
+          beAuthPublicKey2: wallet.beAuthPublicKey2
+        }
+      },
+      {
+        w: 1,
+        upsert: false
+      },
+      cb
+    );
+  }
+
   deregisterWallet(walletId, cb) {
     this.db.collection(collections.WALLETS).updateOne(
       {
@@ -1300,7 +1387,7 @@ export class Storage {
       });
   }
 
-  fetchTxNote(walletId, txid, cb: (err?: any, note?: TxNote) => void) {
+  fetchTxNote(walletId, txid, cb: (err?: any, note?: TxNote) => void, wallet?: Wallet) {
     this.db.collection(collections.TX_NOTES).findOne(
       {
         walletId,
@@ -1309,20 +1396,23 @@ export class Storage {
       (err, result) => {
         if (err) return cb(err);
         if (!result) return cb();
-        return this._completeTxNotesData(walletId, TxNote.fromObj(result), cb);
+        return this._completeTxNotesData(walletId, TxNote.fromObj(result), cb, wallet);
       }
     );
   }
 
   // TODO: should be done client-side
-  _completeTxNotesData(walletId, notes: TxNote | TxNote[], cb: (err?: any, notes?: TxNote | TxNote[]) => void) {
-    this.fetchWallet(walletId, (err, wallet) => {
+  // Callers that already have the wallet pass it, to save reading it again
+  _completeTxNotesData(walletId, notes: TxNote | TxNote[], cb: (err?: any, notes?: TxNote | TxNote[]) => void, wallet?: Wallet) {
+    const complete = (err, wallet: Wallet) => {
       if (err) return cb(err);
       for (const note of [].concat(notes) as TxNote[]) {
         note.editedByName = wallet.getCopayer(note.editedBy).name;
       }
       return cb(null, notes);
-    });
+    };
+    if (wallet) return complete(null, wallet);
+    this.fetchWallet(walletId, complete);
   }
 
   /**
@@ -1331,7 +1421,7 @@ export class Storage {
    * @param walletId
    * @param opts.minTs
    */
-  fetchTxNotes(walletId, opts, cb) {
+  fetchTxNotes(walletId, opts, cb, wallet?: Wallet) {
     const filter: { walletId: string; editedOn?: { $gte: number } } = {
       walletId
     };
@@ -1349,7 +1439,7 @@ export class Storage {
             return TxNote.fromObj(note);
           })
         );
-        return this._completeTxNotesData(walletId, notes, cb);
+        return this._completeTxNotesData(walletId, notes, cb, wallet);
       });
   }
 
@@ -1891,6 +1981,10 @@ export class Storage {
     );
   }
 
+  /**
+   * Use only for legacy (< v1.3) clients, where bwsJoinSecrets was not available.
+   * @deprecated Use storeTssKeyBwsJoinSecrets instead.
+   */
   async storeTssKeyBwsJoinSecret({ id, secret }: { id: string; secret: string }) {
     return this.db.collection(collections.TSS_KEYGEN).updateOne({
       id
@@ -1903,6 +1997,21 @@ export class Storage {
     { upsert: false });
   }
 
+  async storeTssKeyBwsJoinSecrets(params: { id: string; chain: string; network: string; secrets: { [partyId: number]: string } }) {
+    const { id, chain, network, secrets } = params;
+    const _chain = chain.toLowerCase();
+    const _network = network.toLowerCase();
+    return this.db.collection(collections.TSS_KEYGEN).updateOne({
+      id
+    },
+    {
+      $set: {
+        [`bwsJoinSecrets.${_chain}:${_network}`]: secrets
+      }
+    },
+    { upsert: false });
+  }
+
   async fetchTssSigSession({ id }: { id: string }) {
     const doc = await this.db.collection(collections.TSS_SIGN).findOne({ id });
     if (!doc) {

package/src/lib/tss.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'events';
 import { BitcoreLib } from '@bitpay-labs/crypto-wallet-core';
 import { Constants } from './common/constants';
+import { Utils } from './common/utils';
 import { Errors } from './errors/errordefinitions';
 import logger from './logger';
 import { TssKeyGenModel } from './model/tsskeygen';
@@ -553,7 +554,10 @@ class TssKeyGenClass {
     // }
   }
 
-  /** Store the BWS join secret for the TSS keygen session */
+  /**
+   * Store the BWS join secret for the TSS keygen session
+   * @deprecated Use storeBwsJoinSecrets instead.
+   */
   async storeBwsJoinSecret(params: {
     /** Session ID */
     id: string;
@@ -587,10 +591,77 @@ class TssKeyGenClass {
     }
   }
 
-  /** Get the BWS join secret for the TSS keygen session */
+  /**
+   * Store the party-encrypted BWS join secrets for a wallet on `chain`:`network` created with the TSS key.
+   * This can be called after the key generation session has expired to create additional wallets (e.g. other EVM chains) for the same key.
+   */
+  async storeBwsJoinSecrets(params: {
+    /** Session ID */
+    id: string;
+    /** Blockchain (e.g., 'btc', 'eth') */
+    chain: string;
+    /** Network (e.g., 'livenet', 'testnet') */
+    network: string;
+    /** Party encrypted BWS join secrets, keyed by partyId or by the party's keygen session copayer ID */
+    secrets: { [party: string]: string };
+    /** Copayer ID of the submitting party (must be the session creator) */
+    copayerId: string;
+  }) {
+    const { id, copayerId } = params;
+    const { chain, network } = getSecretChainNetwork(params.chain, params.network);
+    if (!params.secrets || typeof params.secrets !== 'object' || Array.isArray(params.secrets)) {
+      throw Errors.TSS_GENERIC_ERROR.withMessage('Invalid BWS join secrets provided');
+    }
+    const storage = WalletService.getStorage();
+    const session = await storage.fetchTssKeyGenSession({ id });
+
+    if (!session) {
+      throw Errors.TSS_SESSION_NOT_FOUND;
+    }
+
+    if (session.participants.indexOf(copayerId) !== 0) {
+      throw Errors.TSS_GENERIC_ERROR.withMessage('Only the session creator can store the BWS join secret');
+    }
+
+    // Only store secrets keyed by partyId for the other parties (1..n-1)
+    const secrets: { [partyId: number]: string } = {};
+    for (const [party, secret] of Object.entries(params.secrets)) {
+      const partyId = /^\d+$/.test(party) ? parseInt(party) : session.participants.indexOf(party);
+      if (!(partyId > 0 && partyId < session.n) || typeof secret !== 'string' || !secret) {
+        throw Errors.TSS_GENERIC_ERROR.withMessage('Invalid BWS join secret for party ' + party);
+      }
+      if (secrets[partyId]) {
+        // Malformed secrets objects may be keyed by both partyId (number) and copayerId (string).
+        // While this technically won't break anything (only 1 secret will be stored), it indicates
+        // a malformation which could signal a broader issue with the client.
+        throw Errors.TSS_GENERIC_ERROR.withMessage('Multiple BWS join secret for party ' + party);
+      }
+      secrets[partyId] = secret;
+    }
+
+    if (Object.keys(secrets).length !== session.n - 1) {
+      throw Errors.TSS_GENERIC_ERROR.withMessage('Missing BWS join secrets for some parties');
+    }
+
+    const result = await storage.storeTssKeyBwsJoinSecrets({ id, chain, network, secrets });
+    if (!result.result.ok) {
+      logger.error('Failed to store TSS key generation BWS join secrets %o %o', id, result);
+      throw Errors.TSS_GENERIC_ERROR.withMessage('Failed to store TSS key generation BWS join secrets');
+    }
+  }
+
+  /**
+   * Get the BWS join secret for the TSS keygen session.
+   * If chain & network are given, returns the requesting party's encrypted secret for that chain & network.
+   * Otherwise, returns the legacy (< v1.3) unencrypted secret.
+   */
   async getBwsJoinSecret(params: {
     /** Session ID */
     id: string;
+    /** Blockchain (e.g., 'btc', 'eth'). Omitted by legacy clients */
+    chain?: string;
+    /** Network (e.g., 'livenet', 'testnet'). Omitted by legacy clients */
+    network?: string;
     /** Copayer ID of the requesting party */
     copayerId: string;
   }): Promise<string> {
@@ -600,16 +671,42 @@ class TssKeyGenClass {
     if (!session) {
       throw Errors.TSS_SESSION_NOT_FOUND;
     }
-    if (session.participants.indexOf(copayerId) === -1) {
+    const partyId = session.participants.indexOf(copayerId);
+    if (partyId === -1) {
       throw Errors.TSS_NON_PARTICIPANT;
     }
-    if (!session.bwsJoinSecret) {
+
+    if (params.chain == null && params.network == null) {
+      // Legacy clients don't send chain & network
+      if (!session.bwsJoinSecret) {
+        throw Errors.TSS_BWS_JOIN_SECRET_NOT_FOUND;
+      }
+      return session.bwsJoinSecret;
+    }
+
+    // Note: sessions < v1.3 can have chain-specific secrets too (i.e. wallets created with an existing TSS key)
+    const { chain, network } = getSecretChainNetwork(params.chain, params.network);
+    const secret = session.bwsJoinSecrets?.[`${chain}:${network}`]?.[partyId];
+    if (typeof secret !== 'string') {
       throw Errors.TSS_BWS_JOIN_SECRET_NOT_FOUND;
     }
-    return session.bwsJoinSecret;
+    return secret;
   }
 };
 
+/** Validate and normalize the chain & network used to key the BWS join secrets */
+function getSecretChainNetwork(chain: string, network: string) {
+  chain = typeof chain === 'string' ? chain.toLowerCase() : chain;
+  if (!Utils.checkValueInCollection(chain, Constants.CHAINS)) {
+    throw Errors.TSS_GENERIC_ERROR.withMessage('Invalid chain provided');
+  }
+  network = typeof network === 'string' ? Utils.getNetworkName(chain, Utils.getGenericName(network.toLowerCase())) : network;
+  if (!Utils.checkValueInCollection(network, Constants.NETWORKS[chain])) {
+    throw Errors.TSS_GENERIC_ERROR.withMessage('Invalid network provided');
+  }
+  return { chain, network };
+}
+
 export const TssKeyGen = new TssKeyGenClass();
 
 class TssSignClass {
@@ -748,7 +845,8 @@ class TssSignClass {
       if (session.isExpired()) {
         throw Errors.TSS_SESSION_EXPIRED;
       }
-      if (!this._isValidBroadcastMessage({ message }) && !this._isValidP2pMessage({ message })) {
+      // 1-of-N sessions won't have messages for other recipients
+      if (session.m > 1 && !this._isValidBroadcastMessage({ message }) && !this._isValidP2pMessage({ message })) {
         throw Errors.TSS_INVALID_MESSAGE.withMessage('Invalid message provided');
       }
 
@@ -903,8 +1001,10 @@ class TssSignClass {
     id: string;
     /** Signature to store */
     signature: ITssSigMessageObject['signature'];
+    /** Copayer ID of the sender */
+    copayerId: string;
   }): Promise<void> {
-    const { id, signature } = params;
+    const { id, signature, copayerId } = params;
     if (!signature) {
       throw Errors.TSS_NO_FINAL_SIGNATURE;
     }
@@ -917,6 +1017,10 @@ class TssSignClass {
     if (!session) {
       throw Errors.TSS_SESSION_NOT_FOUND;
     }
+    const party = session.participants.find(p => p.copayerId === copayerId);
+    if (!party) {
+      throw Errors.TSS_NON_PARTICIPANT;
+    }
 
     const verifySig = (sig1, sig2) => {
       return sig1.r === sig2.r &&

package/test/chain/eth.test.ts

@@ -19,6 +19,76 @@ describe('Chain ETH', function() {
     x.address.should.equal('0x01');
   });
 
+  describe('#onTx', function() {
+    const token = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+    const sender = '0xC877cBCF020A8AA259A1Efab1559B2A3A7259086';
+    const recipient = '0x37D3bCDA9d7d5Dc41e32DAd77a5BA89a77aA8BD0';
+    const multisig = '0x9527a556f0D9AA753dE0D1f9Ad024a17dd281B1D';
+    // a tx event as bitcore-node emits it to the wallets room
+    const tx = (fields = {}) => ({ chain: 'ETH', network: 'mainnet', txid: '0x01', to: token, from: sender, value: 0, ...fields });
+    // effects as bitcore-node builds them
+    const erc20 = { type: 'ERC20:transfer', to: recipient, from: sender, amount: '1000000', contractAddress: token, callStack: '' };
+    const internal = { to: recipient, from: sender, amount: '2000', callStack: '0' };
+    const multisigEffect = type => ({ type, to: recipient, from: sender, amount: '3000', contractAddress: multisig, callStack: '' });
+
+    it('notifies the tx recipient and value for a tx without effects', function() {
+      ChainService.onTx('eth', tx({ to: recipient, value: 5000 })).should.deep.equal({
+        txid: '0x01',
+        out: { address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined }
+      });
+      ChainService.onTx('eth', tx({ to: recipient, value: 5000, effects: [] })).out.should.deep.equal({
+        address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('notifies the recipient of an internal value transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [internal] })).out.should.deep.equal({
+        address: recipient, amount: '2000', tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    for (const type of ['MULTISIG:confirmTransaction', 'MULTISIG:submitTransaction']) {
+      it(`notifies the recipient of a ${type} with its multisig contract`, function() {
+        ChainService.onTx('eth', tx({ effects: [internal, multisigEffect(type)] })).out.should.deep.equal({
+          address: recipient, amount: '3000', tokenAddress: undefined, multisigContractAddress: multisig
+        });
+      });
+    }
+
+    it('prefers a multisig effect to an ERC20 transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [erc20, multisigEffect('MULTISIG:submitTransaction')] })).out.should.deep.equal({
+        address: recipient, amount: '3000', tokenAddress: undefined, multisigContractAddress: multisig
+      });
+    });
+
+    it('falls back to the tx recipient for effects it does not know', function() {
+      const other = { type: 'OTHER:call', to: recipient, from: sender, amount: '1', contractAddress: token, callStack: '' };
+      ChainService.onTx('eth', tx({ effects: [other] })).out.should.deep.equal({
+        address: token, amount: 0, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('handles MATIC txs the same way', function() {
+      ChainService.onTx('matic', tx({ chain: 'MATIC', to: recipient, value: 5000 })).out.should.deep.equal({
+        address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('notifies the token recipient, amount and token of an ERC20 transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [erc20] })).should.deep.equal({
+        txid: '0x01',
+        out: { address: recipient, amount: '1000000', tokenAddress: token, multisigContractAddress: undefined }
+      });
+      ChainService.onTx('matic', tx({ chain: 'MATIC', effects: [erc20] })).out.tokenAddress.should.equal(token);
+    });
+
+    it('prefers an ERC20 transfer to an internal value transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [internal, erc20] })).out.should.deep.equal({
+        address: recipient, amount: '1000000', tokenAddress: token, multisigContractAddress: undefined
+      });
+    });
+  });
+
   describe('#selectTxInputs', function() {
     it('should reject a total that a number rounds down to the balance', function(done) {
       const server = {

package/test/chain/sol.test.ts

@@ -27,7 +27,7 @@ describe('Chain SOL', function() {
             getRentMinimum: (_space, cb) => cb(null, Defaults.MIN_SOL_BALANCE)
           }),
           getPendingTxs: (_opts, cb) => cb(null, c.txps),
-          storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+          storage: { fetchAddressesPage: (_walletId, _opts, cb) => cb(null, []) }
         };
         const wallet = { chain: 'sol', network: 'livenet' };
 

package/test/chain/xrp.test.ts

@@ -20,7 +20,7 @@ describe('Chain XRP', function() {
           getReserve: cb => cb(null, 1000000)
         }),
         getPendingTxs: (_opts, cb) => cb(null, [{ amount: '3000000', fee: '12' }]),
-        storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+        storage: { fetchAddressesPage: (_walletId, _opts, cb) => cb(null, []) }
       };
       const wallet = { chain: 'xrp', network: 'livenet' };