describe('Virtual Token:', function() {
  let bitgo;

  before(function() {
    bitgo = new TestV2BitGo({ env: 'test' });
    bitgo.initializeTestVars();
  });

  it('should not instantiate coin interface before loading client constants', function() {
    (() => bitgo.coin('mycrappytoken')).should.throw('Coin or token type mycrappytoken not supported or not compiled');
  });

  it('should wait for client constants before instantiating coin', Promise.coroutine(function *() {
    const promise = bitgo.token('terc');
    should(promise).be.instanceOf(Promise);
    const erc = yield promise;
    const BaseCoin = require('../../../../src/v2/baseCoin');
    erc.should.be.instanceOf(BaseCoin);
    erc.type.should.equal('terc');
    erc.tokenContractAddress.should.equal('0x945ac907cf021a6bcd07852bb3b8c087051706a9');
  }));

});

            args.push(resolve, reject);
            originalMethod.apply(this, args);
        });
    };
}

obj = Bluebird.promisifyAll(obj, {
	suffix: "",
	filter: defaultFilter,
	promisifier: DOMPromisifier
});

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

const generator1 = function*(a: number, b: string) { return "string"; };
const coroutine1 = Bluebird.coroutine<string, number, string>(generator1);
strProm = coroutine1(5, "foo");

const generator2 = function*(a: number, b: string) {
	yield foo;
	return bar;
};
const coroutine2 = Bluebird.coroutine<Bar, number, string>(generator2);
barProm = coroutine2(5, "foo");

const coroutineCustomYield = Bluebird.coroutine(generator1, { yieldHandler: (value) => "whatever" });
/*
 barProm = Bluebird.spawn<number>(f);
 */
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  describe('Update Password', function() {
    let bitgo;
    let keychains;
    let correctPassword;

    before(co(function *beforeUpdatePassword() {
      bitgo = new TestBitGo({ env: 'test' });
      bitgo.initializeTestVars();
      keychains = bitgo.keychains();
      const loginPasswords = yield bitgo.authenticateChangePWTestUser(bitgo.testUserOTP());
      correctPassword = loginPasswords.password;
      yield bitgo.unlock({ otp: bitgo.testUserOTP() });
    }));

    it('successful update the password for all v1 keychains that are encrypted with the old password', co(function *itUpdatePassword() {
      const newPassword = 'newPassword';
      const result = yield keychains.updatePassword({ oldPassword: correctPassword, newPassword });
      _.forOwn(result.keychains, function(encryptedXprv, xpub) {
        xpub.should.startWith('xpub');
        try {
          const decryptedPrv = bitgo.decrypt({ input: encryptedXprv, password: newPassword });
          decryptedPrv.should.startWith('xprv');
        } catch (e) {
          // the decryption didn't work because of the wrong password, this is one of the keychains that wasn't
          // encrypted with the old password
          e.message.should.startWith('password error');
        }
      });
      result.should.hasOwnProperty('version');
    }));
  });

Wallets.prototype.resendShareInvite = function(params, callback) {
  return co(function *() {
    params = params || {};
    common.validateParams(params, ['walletShareId'], [], callback);

    const urlParts = params.walletShareId + '/resendemail';
    return this.bitgo.post(this.bitgo.url('/walletshare/' + urlParts))
    .result();
  }).call(this).asCallback(callback);
};

  getAddressInfoFromExplorer(addressBase58) {
    return co(function *getAddressInfoFromExplorer() {
      const addrInfo = yield request.get(this.recoveryBlockchainExplorerUrl(`/address/${addressBase58}`)).result();

      addrInfo.txCount = addrInfo.address.total.transaction_count;
      addrInfo.totalBalance = addrInfo.address.total.balance_int;

      return addrInfo;
    }).call(this);
  }

  describe('Recover Wallet:', () => {

    let coin, bitgo;

    before(() => {
      bitgo = new TestBitGo({ env: 'mock' });
      coin = bitgo.coin('tbtc');
      sinon.stub(coin, 'verifyRecoveryTransaction').resolvesArg(0);
    });

    it('should construct a recovery transaction with segwit unspents', co(function *() {
      const { params, expectedTxHex } = fixtures.recoverBtcSegwitFixtures();
      recoveryNocks.nockBtcSegwitRecovery();
      const tx = yield coin.recover(params);
      const transaction = utxoLib.Transaction.fromHex(tx.transactionHex);
      transaction.ins.length.should.equal(2);
      transaction.outs.length.should.equal(1);
      transaction.outs[0].value.should.equal(57112);
      tx.transactionHex.should.equal(expectedTxHex);
    }));

    it('should construct an unsigned recovery transaction for the offline vault', co(function *() {
      const { params, expectedTxHex } = fixtures.recoverBtcUnsignedFixtures();
      recoveryNocks.nockBtcUnsignedRecovery();
      const txPrebuild = yield coin.recover(params);
      txPrebuild.txHex.should.equal(expectedTxHex);
      txPrebuild.should.have.property('feeInfo');
      txPrebuild.coin.should.equal('tbtc');
      txPrebuild.txInfo.unspents.length.should.equal(2);
    }));

    after(function() {
      nock.cleanAll();
      coin.verifyRecoveryTransaction.restore();
    });

  });

  public verifyRecoveryTransaction(txInfo) {
    return co(function *verifyRecoveryTransaction() {
      const decodedTx = yield request.post(this.recoveryBlockchainExplorerUrl(`/decodetx`))
      .send({ hex: txInfo.transactionHex })
      .result();

      const transactionDetails = decodedTx.transaction;

      const tx = bitcoin.Transaction.fromHex(txInfo.transactionHex, this.network);
      if (transactionDetails.TxId !== tx.getId()) {
        console.log(transactionDetails.TxId);
        console.log(tx.getId());
        throw new Error('inconsistent recovery transaction id');
      }

      return transactionDetails;
    }).call(this);
  }

describe('V2 Trading', function() {
  const microservicesUri = 'https://bitgo-microservices.example';
  let bitgo;
  let basecoin;
  let wallet;
  let trading;
  let bgUrl;

  before(co(function *() {
    bitgo = new TestV2BitGo({ env: 'mock', microservicesUri });
    bitgo.initializeTestVars();
    basecoin = bitgo.coin('ofc');
    basecoin.keychains();

    const walletData = {
      id: 'walletId',
      coin: 'tbtc',
      keys: [
        'keyid'
      ]
    };

    wallet = new Wallet(bitgo, basecoin, walletData);
    trading = wallet.trading();
    bgUrl = common.Environments[bitgo.getEnv()].uri;
  }));

  it('should create and sign a trade payload', co(function *() {
    const xprv = 'xprv9s21ZrQH143K2MUz7uPUBVzdmvJQE6fPEQCkR3mypPbZgijPqfmGH7pjijdjeJx3oCoxPWVbjC4VYHzgN6wqEfYnnbNjK7jm2CkrvWrvkbR';
    const xpub = 'xpub661MyMwAqRbcEqZTDvvUYdwNKx8tdZPEbd8MDSBbNj8YZX4YPD5Wpv9Da2YzLC8ZNRhundXP7mVhhu9WdJChzZJFGLQD7tyY1KGfmjuBvcX';

    const msScope = nock(microservicesUri)
    .post('/api/trade/v1/payload')
    .reply(200, {
      payload: JSON.stringify({
        walletId: 'walletId',
        currency: 'tbtc',
        amount: '100000000',
        otherParties: ['test_counter_party_1'],
        nonce: Date.now()
      })
    });
    const platformScope = nock(bgUrl)
    .get('/api/v2/ofc/key/keyid')
    .reply(200, {
      pub: xpub,
      encryptedPrv: bitgo.encrypt({ input: xprv, password: TestV2BitGo.OFC_TEST_PASSWORD })
    });

    const { payload, signature } = yield trading.signTradePayload({
      currency: 'tbtc',
      amount: '100000000',
      otherParties: ['test_counterparty_1'],
      walletPassphrase: TestV2BitGo.OFC_TEST_PASSWORD
    });

    should.exist(payload);
    // The payload should be a valid JSON object
    // NOTE: we shouldn't do any more validation than this, as the schema is subject to change often
    (() => { JSON.parse(payload); }).should.not.throw();

    should.exist(signature);
    // signature should be a hex string
    signature.should.match(/^[0-9a-f]+$/);

    const address = HDNode.fromBase58(xpub).getAddress();

    bitcoinMessage.verify(payload, address, Buffer.from(signature, 'hex')).should.be.True();

    msScope.isDone().should.be.True();
    platformScope.isDone().should.be.True();
  }));
});

  describe('server initialization', function() {

    it('should require NODE_ENV to be production when running against prod env', function() {
      const envStub = sinon.stub(process, 'env').value({ NODE_ENV: 'production' });

      try {
        (() => expressApp({
          env: 'prod',
          bind: 'localhost'
        })).should.not.throw();

        process.env.NODE_ENV = 'dev';
        (() => expressApp({
          env: 'prod',
          bind: 'localhost'
        })).should.throw(NodeEnvironmentError);
      } finally {
        envStub.restore();
      }
    });

    it('should disable NODE_ENV check if disableenvcheck argument is given', function() {
      const envStub = sinon.stub(process, 'env').value({ NODE_ENV: 'dev' });

      try {
        (() => expressApp({
          env: 'prod',
          bind: 'localhost',
          disableenvcheck: true
        })).should.not.throw();
      } finally {
        envStub.restore();
      }
    });

    it('should require TLS for prod env when listening on external interfaces', function() {
      const args = {
        env: 'prod',
        bind: '1',
        disableenvcheck: true,
        disablessl: false,
        crtpath: null,
        keypath: null,
      };

      (() => expressApp(args)).should.throw(TlsConfigurationError);

      args.bind = 'localhost';
      (() => expressApp(args)).should.not.throw();

      args.bind = '1';
      args.env = 'test';
      (() => expressApp(args)).should.not.throw();

      args.disablessl = true;
      args.env = 'prod';
      (() => expressApp(args)).should.not.throw();

      delete args.disablessl;
      args.crtpath = '/tmp/cert.pem';
      (() => expressApp(args)).should.throw(TlsConfigurationError);

      delete args.crtpath;
      args.keypath = '/tmp/key.pem';
      (() => expressApp(args)).should.throw(TlsConfigurationError);

    });

    it('should require both keypath and crtpath when using TLS, but TLS is not required', function() {
      const args = {
        env: 'test',
        bind: '1',
        keypath: '/tmp/key.pem',
        crtpath: null,
      };

      (() => expressApp(args)).should.throw(TlsConfigurationError);

      delete args.keypath;
      args.crtpath = '/tmp/cert.pem';

      (() => expressApp(args)).should.throw(TlsConfigurationError);
    });

    it('should create an http server when not using TLS', co(function *() {
      sinon.stub(http, 'createServer');

      const args = {
        env: 'prod',
        bind: 'localhost'
      };

      createServer(args);

      http.createServer.should.be.calledOnce();
      http.createServer.restore();
    }));

    it('should create an https server when using TLS', co(function *() {
      sinon.stub(https, 'createServer');
//.........这里部分代码省略.........