/**
   * Process address into address and memo id
   *
   * @param address {String} the address
   * @returns {Object} object containing address and memo id
   */
  getAddressDetails(address) {
    const destinationDetails = url.parse(address);
    const queryDetails = querystring.parse(destinationDetails.query);
    const destinationAddress = destinationDetails.pathname;
    if (!stellar.StrKey.isValidEd25519PublicKey(destinationAddress)) {
      throw new Error(`invalid address: ${address}`);
    }
    // address doesn't have a memo id
    if (destinationDetails.pathname === address) {
      return {
        address: address,
        memoId: null
      };
    }

    if (!queryDetails.memoId) {
      // if there are more properties, the query details need to contain the memo id property
      throw new Error(`invalid address: ${address}`);
    }

    try {
      new BigNumber(queryDetails.memoId);
    } catch (e) {
      throw new Error(`invalid address: ${address}`);
    }

    if (!this.isValidMemoId(queryDetails.memoId)) {
      throw new Error(`invalid address: ${address}`);
    }

    return {
      address: destinationAddress,
      memoId: queryDetails.memoId
    };
  }

 /**
  * Validate and return address with appended memo id
  *
  * @param address {String} address
  * @param memoId {String} memo id
  * @returns {String} address with memo id
  */
 normalizeAddress({ address, memoId }) {
   if (!stellar.StrKey.isValidEd25519PublicKey(address)) {
     throw new Error(`invalid address details: ${address}`);
   }
   if (this.isValidMemoId(memoId)) {
     return `${address}?memoId=${memoId}`;
   }
   return address;
 }

  it('should generate a keypair from seed', function() {
    const seed = crypto.randomBytes(32);
    const keyPair = basecoin.generateKeyPair(seed);
    keyPair.should.have.property('pub');
    keyPair.should.have.property('prv');

    const address = keyPair.pub;
    basecoin.isValidAddress(address).should.equal(true);

    basecoin.isValidPub(keyPair.pub).should.equal(true);
    basecoin.isValidPrv(keyPair.prv).should.equal(true);

    const secret = keyPair.prv;
    stellar.StrKey.encodeEd25519SecretSeed(seed).should.equal(secret);
  });

 return co(function *() {
   // The wallet will have 3 keychains on it, usually 2 of those are generated by the platform, and 1 is generated by the user.
   // Initially, we need a root prv to generate the account, which has to be distinct from all three keychains on the wallet.
   // If a root prv is not provided, we generate a random one.
   let seed;
   const rootPrv = walletParams.rootPrivateKey;
   if (rootPrv) {
     if (!this.isValidPrv(rootPrv)) {
       throw new Error('rootPrivateKey needs to be valid ed25519 secret seed');
     }
     seed = stellar.StrKey.decodeEd25519SecretSeed(rootPrv);
   }
   const keyPair = this.generateKeyPair(seed);
   // extend the wallet initialization params
   walletParams.rootPrivateKey = keyPair.prv;
   return walletParams;
 }).call(this);

 /**
  * Return boolean indicating whether input is valid public key for the coin.
  *
  * @param {String} pub the pub to be checked
  * @returns {Boolean} is it valid?
  */
 isValidPub(pub) {
   return stellar.StrKey.isValidEd25519PublicKey(pub);
 }

 /**
  * Get decoded ed25519 private key from raw data
  *
  * @param prv {String} Raw private key
  * @returns {String} Encoded private key
  */
 getPrvFromRaw(prv) {
   return stellar.StrKey.encodeEd25519SecretSeed(Buffer.from(prv, 'hex'));
 }

 /**
  * Get decoded ed25519 public key from raw data
  *
  * @param pub {String} Raw public key
  * @returns {String} Encoded public key
  */
 getPubFromRaw(pub) {
   return stellar.StrKey.encodeEd25519PublicKey(Buffer.from(pub, 'hex'));
 }

 /**
  * Return boolean indicating whether input is valid private key for the coin
  *
  * @param {String} prv the prv to be checked
  * @returns {Boolean} is it valid?
  */
 isValidPrv(prv) {
   return stellar.StrKey.isValidEd25519SecretSeed(prv);
 }