How to use ripple-address-codec - 10 common examples

adjusted: (/true/i).test(req.query.adjusted) ? true : false,
    descending: (/true/i).test(req.query.descending) ? true : false,
    limit: req.query.limit || 200,
    marker: req.query.marker,
    format: (req.query.format || 'json').toLowerCase()
  };

  var currency = req.params.currency;

  if (currency) {
    currency = currency.split(/[\+|\.]/);  // any of +, |, or .
    options.currency = currency[0].toUpperCase();
    options.issuer = currency[1];
  }

  if (!validator.isValidAddress(options.issuer)) {
    errorResponse({error: 'invalid issuer address', code: 400});
    return;

  } else if (!options.start) {
    errorResponse({error: 'invalid start date format', code: 400});
    return;

  } else if (!options.end) {
    errorResponse({error: 'invalid end date format', code: 400});
    return;

  } else if (options.interval &&
             intervals.indexOf(options.interval) === -1) {
    errorResponse({
      error: 'invalid interval - use: '+intervals.join(', '),
      code: 400

}).then(response => {
  console.log("Final transaction result:", response)

  // Re-calculate checkID to work around issue ripple-lib#876
  const checkIDhasher = createHash('sha512')
  checkIDhasher.update(Buffer.from('0043', 'hex'))
  checkIDhasher.update(new Buffer(decodeAddress(response.address)))
  const seqBuf = Buffer.alloc(4)
  seqBuf.writeUInt32BE(response.sequence, 0)
  checkIDhasher.update(seqBuf)
  const checkID = checkIDhasher.digest('hex').slice(0,64).toUpperCase()
  console.log("Calculated checkID:", checkID)

// Disconnect and return
}).then(() => {
  api.disconnect().then(() => {

}

  const accounts = [ ];

  // This code should match the behavior of the C++ method:
  // TransactionMetaSet::getAffectedAccounts
  for (let i = 0; i < this.nodes.length; i++) {
    const node = this.nodes[i];
    const fields = (node.nodeType === 'CreatedNode')
    ? node.fieldsNew
    : node.fieldsFinal;

    for (const fieldName in fields) {
      const field = fields[fieldName];

      if (this.isAccountField(fieldName) && isValidAddress(field)) {
        accounts.push(field);
      } else if (
          Meta.AMOUNT_FIELDS_AFFECTING_ISSUER.indexOf(fieldName) !== -1) {
        const amount = Amount.from_json(field);
        const issuer = amount.issuer();
        if (isValidAddress(issuer) && issuer !== ACCOUNT_ZERO) {
          accounts.push(issuer);
        }
      }
    }
  }

  this._affectedAccounts = utils.arrayUnique(accounts);

  return this._affectedAccounts;
};

Composer.privateChat(ctx => {
                const message = ctx.update.message.text;
                if (!address_codec.isValidAddress(message)) {
                    return ctx.replyWithHTML('⚠️ Please enter a correct XRP address.', CANCEL_MENU);
                }

                if (message === process.env.WALLET_ADDRESS) {
                    return ctx.replyWithHTML(
                        '⚠️ This address cannot be used, please enter another address.',
                        CANCEL_MENU,
                    );
                }

                // set withdraw address
                ctx.scene.session.state.address = message;

                ctx.wizard.next();
                return ctx.wizard.steps[ctx.wizard.cursor](ctx);
            }),

ledger_hash: req.query.ledger_hash,
    closeTime: req.query.close_time || req.query.date,
    account: req.params.address,
    format: (req.query.format || 'json').toLowerCase(),
    limit: req.query.limit || 200,
    ip: req.headers['fastly-client-ip'] || req.headers['x-forwarded-for'] || 'not_provided'
  };

  if (!options.account) {
    errorResponse({
      error: 'account is required.',
      code: 400
    });
    return;

  } else if (!rippleAddress.isValidAddress(options.account)) {
    errorResponse({
      error: 'invalid ripple address',
      code: 400
    });
    return;
  }

  if (options.ledger_index) {
    options.ledger_index = Number(options.ledger_index);
  }

  // validate and fomat close time
  if (options.closeTime) {
    options.closeTime = smoment(options.closeTime);
    if (options.closeTime) {
      options.closeTime = options.closeTime.format();

export function ensureClassicAddress(account: string): string {
  if (isValidXAddress(account)) {
    const {classicAddress, tag} = xAddressToClassicAddress(account)

    // Except for special cases, X-addresses used for requests
    // must not have an embedded tag. In other words,
    // `tag` should be `false`.
    if (tag !== false) {
      throw new Error(
        'This command does not support the use of a tag. Use an address without a tag.'
      )
    }

    // For rippled requests that use an account, always use a classic address.
    return classicAddress
  } else {
    return account
  }

export function ensureClassicAddress(account: string): string {
  if (isValidXAddress(account)) {
    const {classicAddress, tag} = xAddressToClassicAddress(account)

    // Except for special cases, X-addresses used for requests
    // must not have an embedded tag. In other words,
    // `tag` should be `false`.
    if (tag !== false) {
      throw new Error(
        'This command does not support the use of a tag. Use an address without a tag.'
      )
    }

    // For rippled requests that use an account, always use a classic address.
    return classicAddress
  } else {
    return account
  }
}

public getAddressDetails(address: string): Address {
    const destinationDetails = url.parse(address);
    const destinationAddress = destinationDetails.pathname;
    if (!destinationAddress || !rippleAddressCodec.isValidClassicAddress(destinationAddress)) {
      throw new InvalidAddressError(`destination address "${destinationAddress}" is not valid`);
    }
    // there are no other properties like destination tags
    if (destinationDetails.pathname === address) {
      return {
        address: address,
        destinationTag: undefined,
      };
    }

    if (!destinationDetails.query) {
      throw new InvalidAddressError('no query params present');
    }

    const queryDetails = querystring.parse(destinationDetails.query);
    if (!queryDetails.dt) {

function verifySignature(manifest) {
    const sfSequence = '$'
    const sfPublicKey = 'q'
    const sfSigningPubKey = 's'

    // Form manifest
    var sequence_buf = new Buffer(4)
    sequence_buf.writeUInt32BE(manifest.sequence)
    const sequence_bytes = sequence_buf.toJSON().data

    var master_public_bytes = addressCodec.decodeNodePublic(manifest.master_public_key)
    const signature = manifest.master_signature ? manifest.master_signature : manifest.signature
    const signature_bytes = new Buffer(signature, 'hex').toJSON().data

    var manifest_data = new Buffer('MAN\0').toJSON().data
    manifest_data = manifest_data.concat(new Buffer(sfSequence).toJSON().data,
                               sequence_bytes,
                               new Buffer(sfPublicKey).toJSON().data,
                               [master_public_bytes.length],
                               master_public_bytes)

    if (manifest.ephemeral_public_key) {
      const ephemeral_public_bytes = addressCodec.decodeNodePublic(manifest.ephemeral_public_key)
      manifest_data = manifest_data.concat(
        new Buffer(sfSigningPubKey).toJSON().data,
        [ephemeral_public_bytes.length],
        ephemeral_public_bytes)

Transaction.prototype.addMultiSigner = function(signer) {
  assert(isValidAddress(signer.Account), 'Signer must have a valid Account');

  if (_.isUndefined(this.tx_json.Signers)) {
    this.tx_json.Signers = [];
  }

  this.tx_json.Signers.push({Signer: signer});

  this.tx_json.Signers.sort((a, b) => {
    return (new Buffer(decodeAddress(a.Signer.Account))).compare(
      new Buffer(decodeAddress(b.Signer.Account)));
  });

  return this;
};