9920095919

Committed 13 Jul 2024 12:55PM UTC coverage: 68.621% (+0.07%) from 68.551%

Build # 9920095919

Build Type

Pull #900

github

Committed by

web-flow

Commit Message

Merge a550b13b8 into 106fbfaac

Pull Request Pull Request #900: Update migrations

Run Details

7551 of 12844 branches covered (58.79%)

Branch coverage included in aggregate %.

124 of 125 new or added lines in 4 files covered. (99.2%)

3 existing lines in 1 file now uncovered.

24113 of 33299 relevant lines covered (72.41%)

33902.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.02

/lib/wallet/migrations.js

/*!
 * wallet/migrations.js - wallet db migrations for hsd
 * Copyright (c) 2021, Nodari Chkuaselidze (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const Logger = require('blgr');
const bdb = require('bdb');
const bio = require('bufio');
const {HDPublicKey} = require('../hd/hd');
const binary = require('../utils/binary');
const {encoding} = bio;
const Network = require('../protocol/network');
const Account = require('./account');
const WalletKey = require('./walletkey');
const Path = require('./path');
const Script = require('../script/script');
const MapRecord = require('./records').MapRecord;
const AbstractMigration = require('../migrations/migration');
const {
  MigrationResult,
  Migrator,
  types,
  oldLayout
} = require('../migrations/migrator');
const layouts = require('./layout');

/**
 * Switch to new migrations layout.
 */

class MigrateMigrations extends AbstractMigration {
  /**
   * Create migrations migration.
   * @param {WalletMigratorOptions} options
   */

  constructor(options) {
    super(options);

    this.options = options;
    this.logger = options.logger.context('wallet-migrations-migrate');
    this.db = options.db;
    this.ldb = options.ldb;
    this.layout = MigrateMigrations.layout();
  }

  async check() {
    return types.MIGRATE;
  }

  /**
   * Actual migration
   * @param {Batch} b
   * @returns {Promise}
   */

  async migrate(b) {
    this.logger.info('Migrating migrations..');
    let nextMigration = 1;

    if (await this.ldb.get(this.layout.oldLayout.wdb.M.encode(0))) {
      b.del(this.layout.oldLayout.wdb.M.encode(0));
      nextMigration = 2;
    }

    this.db.writeVersion(b, 1);
    b.put(
      this.layout.newLayout.wdb.M.encode(),
      this.encodeMigrationState(nextMigration)
    );
  }

  encodeMigrationState(nextMigration) {
    const size = 4 + 1 + 1;
    const encoded = Buffer.alloc(size);

    encoding.writeVarint(encoded, nextMigration, 4);

    return encoded;
  }

  static info() {
    return {
      name: 'Migrate wallet migrations',
      description: 'Wallet migration layout has changed.'
    };
  }

  static layout() {
    return {
      oldLayout: {
        wdb: {
          M: bdb.key('M', ['uint32'])
        }
      },
      newLayout: {
        wdb: {
          M: bdb.key('M')
        }
      }
    };
  }
}

/**
 * Run change address migration.
 * Applies to WalletDB v0
 */

class MigrateChangeAddress extends AbstractMigration {
  /**
   * Create change address migration object.
   * @constructor
   * @param {WalletMigratorOptions} options
   */

  constructor(options) {
    super(options);

    this.options = options;
    this.logger = options.logger.context('change-address-migration');
    this.db = options.db;
    this.ldb = options.ldb;
    this.layout = MigrateChangeAddress.layout();
  }

  /**
   * Migration and check for the change address
   * are done in the same step.
   */

  async check() {
    return types.MIGRATE;
  }

  /**
   * Actual migration
   * @param {Batch} b
   * @param {WalletMigrationResult} pending
   * @returns {Promise}
   */

  async migrate(b, pending) {
    const wlayout = this.layout.wdb;
    const wids = await this.ldb.keys({
      gte: wlayout.W.min(),
      lte: wlayout.W.max(),
      parse: key => wlayout.W.decode(key)[0]
    });

    let total = 0;
    for (const wid of wids) {
      this.logger.info('Checking wallet (wid=%d).', wid);
      total += await this.migrateWallet(b, wid);
    }

    if (total > 0)
      pending.rescan = true;
  }

  async migrateWallet(b, wid) {
    const accounts = this.ldb.iterator({
      gte: this.layout.wdb.a.min(wid),
      lte: this.layout.wdb.a.max(wid),
      values: true
    });

    let total = 0;
    for await (const {key, value} of accounts) {
      const [awid, aindex] = this.layout.wdb.a.decode(key);
      const name = await this.ldb.get(this.layout.wdb.n.encode(wid, aindex));
      assert(awid === wid);
      const br = bio.read(value);
      const initialized = br.readU8();

      if (!initialized)
        continue;

      const type = br.readU8();
      const m = br.readU8();
      const n = br.readU8();
      br.seek(4); // skip receive
      const changeDepth = br.readU32();
      const lookahead = br.readU8();
      const accountKey = this.readKey(br);
      const count = br.readU8();
      assert(br.left() === count * 74);

      const keys = [];

      for (let i = 0; i < count; i++) {
        const key = this.readKey(br);
        const cmp = (a, b) => a.compare(b);
        binary.insert(keys, key, cmp, true);
      }

      for (let i = 0; i < changeDepth + lookahead; i++) {
        const key = this.deriveKey({
          accountName: name,
          accountIndex: aindex,
          accountKey: accountKey,
          type: type,
          m: m,
          n: n,
          branch: 1,
          index: i,
          keys: keys
        });

        const path = key.toPath();

        if (!await this.hasPath(wid, path.hash)) {
          await this.savePath(b, wid, path);
          total += 1;
        }
      }
    }

    return total;
  }

  deriveKey(options) {
    const key = options.accountKey.derive(options.branch).derive(options.index);
    const wkey = new WalletKey();
    wkey.keyType = Path.types.HD;
    wkey.name = options.accountName;
    wkey.account = options.accountIndex;
    wkey.branch = options.branch;
    wkey.index = options.index;
    wkey.publicKey = key.publicKey;

    const keys = [];
    switch (options.type) {
      case Account.types.PUBKEYHASH:
        break;

      case Account.types.MULTISIG:
        keys.push(wkey.publicKey);

        for (const shared of options.keys) {
          const key = shared.derive(options.branch).derive(options.index);
          keys.push(key.publicKey);
        }

        wkey.script = Script.fromMultisig(options.m, options.n, keys);

        break;
    }

    return wkey;
  }

  readKey(br) {
    const key = new HDPublicKey();
    key.depth = br.readU8();
    key.parentFingerPrint = br.readU32BE();
    key.childIndex = br.readU32BE();
    key.chainCode = br.readBytes(32);
    key.publicKey = br.readBytes(33);
    return key;
  }

  async hasPath(wid, hash) {
    return this.ldb.has(this.layout.wdb.P.encode(wid, hash));
  }

  async savePath(b, wid, path) {
    const wlayout = this.layout.wdb;

    const data = await this.ldb.get(wlayout.p.encode(path.hash));
    const map = data ? MapRecord.decode(data) : new MapRecord();

    map.add(wid);
    b.put(wlayout.p.encode(path.hash), map.encode());
    b.put(wlayout.P.encode(wid, path.hash), path.encode());
    b.put(wlayout.r.encode(wid, path.account, path.hash), null);
  }

  /**
   * Return info about the migration.
   * @returns {String}
   */

  static info() {
    return {
      name: 'Change address migration',
      description: 'Wallet is corrupted.'
    };
  }

  /**
   * Get layout that migration is going to affect.
   * @returns {Object}
   */

  static layout() {
    return {
      wdb: {
        // W[wid] -> wallet id
        W: bdb.key('W', ['uint32']),

        // n[wid][index] -> account name
        n: bdb.key('n', ['uint32', 'uint32']),

        // a[wid][index] -> account
        a: bdb.key('a', ['uint32', 'uint32']),

        // p[addr-hash] -> address->wid map
        p: bdb.key('p', ['hash']),

        // P[wid][addr-hash] -> path data
        P: bdb.key('P', ['uint32', 'hash']),

        // r[wid][index][addr-hash] -> dummy (addr by account)
        r: bdb.key('r', ['uint32', 'uint32', 'hash'])
      }
    };
  }
}

/**
 * Migrate account for new lookahead entry.
 * Applies to WalletDB v1
 */

class MigrateAccountLookahead extends AbstractMigration {
  /**
   * Create migration object.
   * @param {WalletMigratorOptions}
   */

  constructor (options) {
    super(options);

    this.options = options;
    this.logger = options.logger.context('account-lookahead-migration');
    this.db = options.db;
    this.ldb = options.ldb;
    this.layout = MigrateAccountLookahead.layout();
  }

  /**
   * We always migrate account.
   */

  async check() {
    return types.MIGRATE;
  }

  /**
   * Actual migration
   * @param {Batch} b
   * @returns {Promise}
   */

  async migrate(b) {
    const wlayout = this.layout.wdb;
    const wids = await this.ldb.keys({
      gte: wlayout.W.min(),
      lte: wlayout.W.max(),
      parse: key => wlayout.W.decode(key)[0]
    });

    for (const wid of wids)
      await this.migrateWallet(b, wid);

    this.db.writeVersion(b, 2);
  }

  async migrateWallet(b, wid) {
    const wlayout = this.layout.wdb;
    const accounts = await this.ldb.keys({
      gte: wlayout.a.min(wid),
      lte: wlayout.a.max(wid),
      parse: key => wlayout.a.decode(key)[1]
    });

    for (const accID of accounts) {
      const key = wlayout.a.encode(wid, accID);
      const rawAccount = await this.ldb.get(key);
      const newRaw = this.accountEncode(rawAccount);
      b.put(key, newRaw);
    }
  }

  accountEncode(raw) {
    // flags, type, m, n, receiveDepth, changeDepth
    const preLen = 1 + 1 + 1 + 1 + 4 + 4;
    const pre = raw.slice(0, preLen);
    const lookahead = raw.slice(preLen, preLen + 1);
    const post = raw.slice(preLen + 1);
    const newLookahead = Buffer.alloc(4, 0x00);

    newLookahead.writeUInt32LE(lookahead[0], 0);

    return Buffer.concat([
      pre,
      newLookahead,
      post
    ]);
  }

  static info() {
    return {
      name: 'Account lookahead migration',
      description: 'Account lookahead now supports up to 2^32 - 1'
    };
  }

  static layout() {
    return {
      wdb: {
        // W[wid] -> wallet id
        W: bdb.key('W', ['uint32']),

        // a[wid][index] -> account
        a: bdb.key('a', ['uint32', 'uint32'])
      }
    };
  }
}

class MigrateTXDBBalances extends AbstractMigration {
  /**
   * Create TXDB Balance migration object.
   * @param {WalletMigratorOptions} options
   * @constructor
   */

  constructor(options) {
    super(options);

    this.options = options;
    this.logger = options.logger.context('txdb-balance-migration');
    this.db = options.db;
    this.ldb = options.ldb;
  }

  /**
   * We always migrate.
   * @returns {Promise}
   */

  async check() {
    return types.MIGRATE;
  }

  /**
   * Actual migration
   * @param {Batch} b
   * @param {WalletMigrationResult} pending
   * @returns {Promise}
   */

  async migrate(b, pending) {
    pending.recalculateTXDB = true;
  }

  static info() {
    return {
      name: 'TXDB balance refresh',
      description: 'Refresh balances for TXDB after txdb updates'
    };
  }
}

/**
 * Wallet migration results.
 * @alias module:blockchain.WalletMigrationResult
 */

class WalletMigrationResult extends MigrationResult {
  constructor() {
    super();

    this.rescan = false;
    this.recalculateTXDB = false;
  }
}

/**
 * Wallet Migrator
 * @alias module:blockchain.WalletMigrator
 */
class WalletMigrator extends Migrator {
  /**
   * Create WalletMigrator object.
   * @constructor
   * @param {Object} options
   */

  constructor(options) {
    super(new WalletMigratorOptions(options));

    this.logger = this.options.logger.context('wallet-migrations');
    this.pending = new WalletMigrationResult();
    this.flagError = 'Restart with '
      + `\`hsd --wallet-migrate=${this.lastMigration}\` or `
      + `\`hsw --migrate=${this.lastMigration}\`\n`
      + '(Full node may be required for rescan)';
  }

  /**
   * Get list of migrations to run
   * @returns {Promise<Set>}
   */

  async getMigrationsToRun() {
    const state = await this.getState();
    const lastID = this.getLastMigrationID();

    if (state.nextMigration > lastID)
      return new Set();

    const ids = new Set();

    for (let i = state.nextMigration; i <= lastID; i++)
      ids.add(i);

    if (state.nextMigration === 0 && await this.ldb.get(oldLayout.M.encode(0)))
      ids.delete(1);

    return ids;
  }
}

/**
 * WalletMigratorOptions
 * @alias module:wallet.WalletMigratorOptions
 */

class WalletMigratorOptions {
  /**
   * Create Wallet Migrator Options.
   * @constructor
   * @param {Object} options
   */

  constructor(options) {
    this.network = Network.primary;
    this.logger = Logger.global;

    this.migrations = exports.migrations;
    this.migrateFlag = -1;

    this.dbVersion = 0;
    this.db = null;
    this.ldb = null;
    this.layout = layouts.wdb;

    if (options)
      this.fromOptions(options);
  }

  /**
   * Inject properties from object.
   * @param {Object} options
   * @returns {WalletMigratorOptions}
   */

  fromOptions(options) {
    if (options.network != null)
      this.network = Network.get(options.network);

    if (options.logger != null) {
      assert(typeof options.logger === 'object');
      this.logger = options.logger;
    }

    if (options.walletDB != null) {
      assert(typeof options.walletDB === 'object');
      this.db = options.walletDB;
      this.ldb = this.db.db;
    }

    if (options.walletMigrate != null) {
      assert(typeof options.walletMigrate === 'number');
      this.migrateFlag = options.walletMigrate;
    }

    if (options.dbVersion != null) {
      assert(typeof options.dbVersion === 'number');
      this.dbVersion = options.dbVersion;
    }

    if (options.migrations != null) {
      assert(typeof options.migrations === 'object');
      this.migrations = options.migrations;
    }
  }
}

exports = WalletMigrator;

exports.WalletMigrationResult = WalletMigrationResult;

// List of the migrations with ids
exports.migrations = {
  0: MigrateMigrations,
  1: MigrateChangeAddress,
  2: MigrateAccountLookahead,
  3: MigrateTXDBBalances
};

// Expose migrations
exports.MigrateChangeAddress = MigrateChangeAddress;
exports.MigrateMigrations = MigrateMigrations;
exports.MigrateAccountLookahead = MigrateAccountLookahead;
exports.MigrateTXDBBalances = MigrateTXDBBalances;

module.exports = exports;

1	/*!
2	* wallet/migrations.js - wallet db migrations for hsd
3	* Copyright (c) 2021, Nodari Chkuaselidze (MIT License).
4	* https://github.com/handshake-org/hsd
5	*/
6
7	'use strict';
8
9	const assert = require('bsert');	1✔
10	const Logger = require('blgr');	1✔
11	const bdb = require('bdb');	1✔
12	const bio = require('bufio');	1✔
13	const {HDPublicKey} = require('../hd/hd');	1✔
14	const binary = require('../utils/binary');	1✔
15	const {encoding} = bio;	1✔
16	const Network = require('../protocol/network');	1✔
17	const Account = require('./account');	1✔
18	const WalletKey = require('./walletkey');	1✔
19	const Path = require('./path');	1✔
20	const Script = require('../script/script');	1✔
21	const MapRecord = require('./records').MapRecord;	1✔
22	const AbstractMigration = require('../migrations/migration');	1✔
23	const {
24	MigrationResult,
25	Migrator,
26	types,
27	oldLayout
28	} = require('../migrations/migrator');	1✔
29	const layouts = require('./layout');	1✔
30
31	/**
32	* Switch to new migrations layout.
33	*/
34
35	class MigrateMigrations extends AbstractMigration {
36	/**
37	* Create migrations migration.
38	* @param {WalletMigratorOptions} options
39	*/
40
41	constructor(options) {
42	super(options);	3✔
43
44	this.options = options;	3✔
45	this.logger = options.logger.context('wallet-migrations-migrate');	3✔
46	this.db = options.db;	3✔
47	this.ldb = options.ldb;	3✔
48	this.layout = MigrateMigrations.layout();	3✔
49	}
50
51	async check() {
52	return types.MIGRATE;	3✔
53	}
54
55	/**
56	* Actual migration
57	* @param {Batch} b
58	* @returns {Promise}
59	*/
60
61	async migrate(b) {
62	this.logger.info('Migrating migrations..');	3✔
63	let nextMigration = 1;	3✔
64
65	if (await this.ldb.get(this.layout.oldLayout.wdb.M.encode(0))) {	3✔
66	b.del(this.layout.oldLayout.wdb.M.encode(0));	2✔
67	nextMigration = 2;	2✔
68	}
69
70	this.db.writeVersion(b, 1);	3✔
71	b.put(	3✔
72	this.layout.newLayout.wdb.M.encode(),
73	this.encodeMigrationState(nextMigration)
74	);
75	}
76
77	encodeMigrationState(nextMigration) {
78	const size = 4 + 1 + 1;	3✔
79	const encoded = Buffer.alloc(size);	3✔
80
81	encoding.writeVarint(encoded, nextMigration, 4);	3✔
82
83	return encoded;	3✔
84	}
85
86	static info() {
87	return {	7✔
88	name: 'Migrate wallet migrations',
89	description: 'Wallet migration layout has changed.'
90	};
91	}
92
93	static layout() {
94	return {	4✔
95	oldLayout: {
96	wdb: {
97	M: bdb.key('M', ['uint32'])
98	}
99	},
100	newLayout: {
101	wdb: {
102	M: bdb.key('M')
103	}
104	}
105	};
106	}
107	}
108
109	/**
110	* Run change address migration.
111	* Applies to WalletDB v0
112	*/
113
114	class MigrateChangeAddress extends AbstractMigration {
115	/**
116	* Create change address migration object.
117	* @constructor
118	* @param {WalletMigratorOptions} options
119	*/
120
121	constructor(options) {
122	super(options);	2✔
123
124	this.options = options;	2✔
125	this.logger = options.logger.context('change-address-migration');	2✔
126	this.db = options.db;	2✔
127	this.ldb = options.ldb;	2✔
128	this.layout = MigrateChangeAddress.layout();	2✔
129	}
130
131	/**
132	* Migration and check for the change address
133	* are done in the same step.
134	*/
135
136	async check() {
137	return types.MIGRATE;	2✔
138	}
139
140	/**
141	* Actual migration
142	* @param {Batch} b
143	* @param {WalletMigrationResult} pending
144	* @returns {Promise}
145	*/
146
147	async migrate(b, pending) {
148	const wlayout = this.layout.wdb;	2✔
149	const wids = await this.ldb.keys({	2✔
150	gte: wlayout.W.min(),
151	lte: wlayout.W.max(),
152	parse: key => wlayout.W.decode(key)[0]	3✔
153	});
154
155	let total = 0;	2✔
156	for (const wid of wids) {	2✔
157	this.logger.info('Checking wallet (wid=%d).', wid);	3✔
158	total += await this.migrateWallet(b, wid);	3✔
159	}
160
161	if (total > 0)	2✔
162	pending.rescan = true;	1✔
163	}
164
165	async migrateWallet(b, wid) {
166	const accounts = this.ldb.iterator({	3✔
167	gte: this.layout.wdb.a.min(wid),
168	lte: this.layout.wdb.a.max(wid),
169	values: true
170	});
171
172	let total = 0;	3✔
173	for await (const {key, value} of accounts) {	3✔
174	const [awid, aindex] = this.layout.wdb.a.decode(key);	4✔
175	const name = await this.ldb.get(this.layout.wdb.n.encode(wid, aindex));	4✔
176	assert(awid === wid);	4✔
177	const br = bio.read(value);	4✔
178	const initialized = br.readU8();	4✔
179
180	if (!initialized)	4!
NEW 181	continue;	×
182
183	const type = br.readU8();	4✔
184	const m = br.readU8();	4✔
185	const n = br.readU8();	4✔
186	br.seek(4); // skip receive	4✔
187	const changeDepth = br.readU32();	4✔
188	const lookahead = br.readU8();	4✔
189	const accountKey = this.readKey(br);	4✔
190	const count = br.readU8();	4✔
191	assert(br.left() === count * 74);	4✔
192
193	const keys = [];	4✔
194
195	for (let i = 0; i < count; i++) {	4✔
196	const key = this.readKey(br);	1✔
197	const cmp = (a, b) => a.compare(b);	1✔
198	binary.insert(keys, key, cmp, true);	1✔
199	}
200
201	for (let i = 0; i < changeDepth + lookahead; i++) {	4✔
202	const key = this.deriveKey({	74✔
203	accountName: name,
204	accountIndex: aindex,
205	accountKey: accountKey,
206	type: type,
207	m: m,
208	n: n,
209	branch: 1,
210	index: i,
211	keys: keys
212	});
213
214	const path = key.toPath();	74✔
215
216	if (!await this.hasPath(wid, path.hash)) {	74✔
217	await this.savePath(b, wid, path);	30✔
218	total += 1;	30✔
219	}
220	}
221	}
222
223	return total;	3✔
224	}
225
226	deriveKey(options) {
227	const key = options.accountKey.derive(options.branch).derive(options.index);	74✔
228	const wkey = new WalletKey();	74✔
229	wkey.keyType = Path.types.HD;	74✔
230	wkey.name = options.accountName;	74✔
231	wkey.account = options.accountIndex;	74✔
232	wkey.branch = options.branch;	74✔
233	wkey.index = options.index;	74✔
234	wkey.publicKey = key.publicKey;	74✔
235
236	const keys = [];	74✔
237	switch (options.type) {	74✔
238	case Account.types.PUBKEYHASH:
239	break;	53✔
240
241	case Account.types.MULTISIG:
242	keys.push(wkey.publicKey);	21✔
243
244	for (const shared of options.keys) {	21✔
245	const key = shared.derive(options.branch).derive(options.index);	21✔
246	keys.push(key.publicKey);	21✔
247	}
248
249	wkey.script = Script.fromMultisig(options.m, options.n, keys);	21✔
250
251	break;	21✔
252	}
253
254	return wkey;	74✔
255	}
256
257	readKey(br) {
258	const key = new HDPublicKey();	5✔
259	key.depth = br.readU8();	5✔
260	key.parentFingerPrint = br.readU32BE();	5✔
261	key.childIndex = br.readU32BE();	5✔
262	key.chainCode = br.readBytes(32);	5✔
263	key.publicKey = br.readBytes(33);	5✔
264	return key;	5✔
265	}
266
267	async hasPath(wid, hash) {
268	return this.ldb.has(this.layout.wdb.P.encode(wid, hash));	74✔
269	}
270
271	async savePath(b, wid, path) {
272	const wlayout = this.layout.wdb;	30✔
273
274	const data = await this.ldb.get(wlayout.p.encode(path.hash));	30✔
275	const map = data ? MapRecord.decode(data) : new MapRecord();	30!
276
277	map.add(wid);	30✔
278	b.put(wlayout.p.encode(path.hash), map.encode());	30✔
279	b.put(wlayout.P.encode(wid, path.hash), path.encode());	30✔
280	b.put(wlayout.r.encode(wid, path.account, path.hash), null);	30✔
281	}
282
283	/**
284	* Return info about the migration.
285	* @returns {String}
286	*/
287
288	static info() {
289	return {	4✔
290	name: 'Change address migration',
291	description: 'Wallet is corrupted.'
292	};
293	}
294
295	/**
296	* Get layout that migration is going to affect.
297	* @returns {Object}
298	*/
299
300	static layout() {
301	return {	2✔
302	wdb: {
303	// W[wid] -> wallet id
304	W: bdb.key('W', ['uint32']),
305
306	// n[wid][index] -> account name
307	n: bdb.key('n', ['uint32', 'uint32']),
308
309	// a[wid][index] -> account
310	a: bdb.key('a', ['uint32', 'uint32']),
311
312	// p[addr-hash] -> address->wid map
313	p: bdb.key('p', ['hash']),
314
315	// P[wid][addr-hash] -> path data
316	P: bdb.key('P', ['uint32', 'hash']),
317
318	// r[wid][index][addr-hash] -> dummy (addr by account)
319	r: bdb.key('r', ['uint32', 'uint32', 'hash'])
320	}
321	};
322	}
323	}
324
325	/**
326	* Migrate account for new lookahead entry.
327	* Applies to WalletDB v1
328	*/
329
330	class MigrateAccountLookahead extends AbstractMigration {
331	/**
332	* Create migration object.
333	* @param {WalletMigratorOptions}
334	*/
335
336	constructor (options) {
337	super(options);	2✔
338
339	this.options = options;	2✔
340	this.logger = options.logger.context('account-lookahead-migration');	2✔
341	this.db = options.db;	2✔
342	this.ldb = options.ldb;	2✔
343	this.layout = MigrateAccountLookahead.layout();	2✔
344	}
345
346	/**
347	* We always migrate account.
348	*/
349
350	async check() {
351	return types.MIGRATE;	2✔
352	}
353
354	/**
355	* Actual migration
356	* @param {Batch} b
357	* @returns {Promise}
358	*/
359
360	async migrate(b) {
361	const wlayout = this.layout.wdb;	2✔
362	const wids = await this.ldb.keys({	2✔
363	gte: wlayout.W.min(),
364	lte: wlayout.W.max(),
365	parse: key => wlayout.W.decode(key)[0]	5✔
366	});
367
368	for (const wid of wids)	2✔
369	await this.migrateWallet(b, wid);	5✔
370
371	this.db.writeVersion(b, 2);	2✔
372	}
373
374	async migrateWallet(b, wid) {
375	const wlayout = this.layout.wdb;	5✔
376	const accounts = await this.ldb.keys({	5✔
377	gte: wlayout.a.min(wid),
378	lte: wlayout.a.max(wid),
379	parse: key => wlayout.a.decode(key)[1]	10✔
380	});
381
382	for (const accID of accounts) {	5✔
383	const key = wlayout.a.encode(wid, accID);	10✔
384	const rawAccount = await this.ldb.get(key);	10✔
385	const newRaw = this.accountEncode(rawAccount);	10✔
386	b.put(key, newRaw);	10✔
387	}
388	}
389
390	accountEncode(raw) {
391	// flags, type, m, n, receiveDepth, changeDepth
392	const preLen = 1 + 1 + 1 + 1 + 4 + 4;	10✔
393	const pre = raw.slice(0, preLen);	10✔
394	const lookahead = raw.slice(preLen, preLen + 1);	10✔
395	const post = raw.slice(preLen + 1);	10✔
396	const newLookahead = Buffer.alloc(4, 0x00);	10✔
397
398	newLookahead.writeUInt32LE(lookahead[0], 0);	10✔
399
400	return Buffer.concat([	10✔
401	pre,
402	newLookahead,
403	post
404	]);
405	}
406
407	static info() {
408	return {	6✔
409	name: 'Account lookahead migration',
410	description: 'Account lookahead now supports up to 2^32 - 1'
411	};
412	}
413
414	static layout() {
415	return {	2✔
416	wdb: {
417	// W[wid] -> wallet id
418	W: bdb.key('W', ['uint32']),
419
420	// a[wid][index] -> account
421	a: bdb.key('a', ['uint32', 'uint32'])
422	}
423	};
424	}
425	}
426
427	class MigrateTXDBBalances extends AbstractMigration {
428	/**
429	* Create TXDB Balance migration object.
430	* @param {WalletMigratorOptions} options
431	* @constructor
432	*/
433
434	constructor(options) {
435	super(options);	1✔
436
437	this.options = options;	1✔
438	this.logger = options.logger.context('txdb-balance-migration');	1✔
439	this.db = options.db;	1✔
440	this.ldb = options.ldb;	1✔
441	}
442
443	/**
444	* We always migrate.
445	* @returns {Promise}
446	*/
447
448	async check() {
449	return types.MIGRATE;	1✔
450	}
451
452	/**
453	* Actual migration
454	* @param {Batch} b
455	* @param {WalletMigrationResult} pending
456	* @returns {Promise}
457	*/
458
459	async migrate(b, pending) {
460	pending.recalculateTXDB = true;	1✔
461	}
462
463	static info() {
464	return {	1✔
465	name: 'TXDB balance refresh',
466	description: 'Refresh balances for TXDB after txdb updates'
467	};
468	}
469	}
470
471	/**
472	* Wallet migration results.
473	* @alias module:blockchain.WalletMigrationResult
474	*/
475
476	class WalletMigrationResult extends MigrationResult {
477	constructor() {
478	super();	116✔
479
480	this.rescan = false;	116✔
481	this.recalculateTXDB = false;	116✔
482	}
483	}
484
485	/**
486	* Wallet Migrator
487	* @alias module:blockchain.WalletMigrator
488	*/
489	class WalletMigrator extends Migrator {
490	/**
491	* Create WalletMigrator object.
492	* @constructor
493	* @param {Object} options
494	*/
495
496	constructor(options) {
497	super(new WalletMigratorOptions(options));	116✔
498
499	this.logger = this.options.logger.context('wallet-migrations');	116✔
500	this.pending = new WalletMigrationResult();	116✔
501	this.flagError = 'Restart with '	116✔
502	+ `\`hsd --wallet-migrate=${this.lastMigration}\` or `
503	+ `\`hsw --migrate=${this.lastMigration}\`\n`
504	+ '(Full node may be required for rescan)';
505	}
506
507	/**
508	* Get list of migrations to run
509	* @returns {Promise<Set>}
510	*/
511
512	async getMigrationsToRun() {
513	const state = await this.getState();	16✔
514	const lastID = this.getLastMigrationID();	16✔
515
516	if (state.nextMigration > lastID)	16✔
517	return new Set();	3✔
518
519	const ids = new Set();	13✔
520
521	for (let i = state.nextMigration; i <= lastID; i++)	13✔
522	ids.add(i);	21✔
523
524	if (state.nextMigration === 0 && await this.ldb.get(oldLayout.M.encode(0)))	13✔
525	ids.delete(1);	3✔
526
527	return ids;	13✔
528	}
529	}
530
531	/**
532	* WalletMigratorOptions
533	* @alias module:wallet.WalletMigratorOptions
534	*/
535
536	class WalletMigratorOptions {
537	/**
538	* Create Wallet Migrator Options.
539	* @constructor
540	* @param {Object} options
541	*/
542
543	constructor(options) {
544	this.network = Network.primary;	116✔
545	this.logger = Logger.global;	116✔
546
547	this.migrations = exports.migrations;	116✔
548	this.migrateFlag = -1;	116✔
549
550	this.dbVersion = 0;	116✔
551	this.db = null;	116✔
552	this.ldb = null;	116✔
553	this.layout = layouts.wdb;	116✔
554
555	if (options)	116!
556	this.fromOptions(options);	116✔
557	}
558
559	/**
560	* Inject properties from object.
561	* @param {Object} options
562	* @returns {WalletMigratorOptions}
563	*/
564
565	fromOptions(options) {
566	if (options.network != null)	116!
567	this.network = Network.get(options.network);	116✔
568
569	if (options.logger != null) {	116!
570	assert(typeof options.logger === 'object');	116✔
571	this.logger = options.logger;	116✔
572	}
573
574	if (options.walletDB != null) {	116!
575	assert(typeof options.walletDB === 'object');	116✔
576	this.db = options.walletDB;	116✔
577	this.ldb = this.db.db;	116✔
578	}
579
580	if (options.walletMigrate != null) {	116!
581	assert(typeof options.walletMigrate === 'number');	116✔
582	this.migrateFlag = options.walletMigrate;	116✔
583	}
584
585	if (options.dbVersion != null) {	116!
586	assert(typeof options.dbVersion === 'number');	116✔
587	this.dbVersion = options.dbVersion;	116✔
588	}
589
590	if (options.migrations != null) {	116!
591	assert(typeof options.migrations === 'object');	×
592	this.migrations = options.migrations;	×
593	}
594	}
595	}
596
597	exports = WalletMigrator;	1✔
598
599	exports.WalletMigrationResult = WalletMigrationResult;	1✔
600
601	// List of the migrations with ids
602	exports.migrations = {	1✔
603	0: MigrateMigrations,
604	1: MigrateChangeAddress,
605	2: MigrateAccountLookahead,
606	3: MigrateTXDBBalances
607	};
608
609	// Expose migrations
610	exports.MigrateChangeAddress = MigrateChangeAddress;	1✔
611	exports.MigrateMigrations = MigrateMigrations;	1✔
612	exports.MigrateAccountLookahead = MigrateAccountLookahead;	1✔
613	exports.MigrateTXDBBalances = MigrateTXDBBalances;	1✔
614
615	module.exports = exports;	1✔

handshake-org / hsd / 9920095919

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous