vrid/lib/api.js

const fastSha256 = require('fast-sha256');
const secp256k1 = require('eccrypto-sync/secp256k1');
const base64 = require('./base64');
const base58 = require('./base58');

module.exports = ({random, fetch, Headers, encodeUtf8, crdsUrl}) => {

const NULL_PRIVATE_KEY = (() => {
  const result = new Uint8Array(32);
  result[0] = 0xFF;
  return result;
})();
// const NULL_PUBLIC_KEY = eccrypto.getPublic(NULL_PRIVATE_KEY);

const getPublicKey = privateKey => Uint8Array.from(secp256k1.keyFromPrivate(privateKey).getPublic('arr'));
const getAddress = privateKey => base58.encode(_sha256(getPublicKey(privateKey)));
const requestStatus = () => fetch(`${crdsUrl}/status`)
  .then(_resJson);
const requestAssets = () => fetch(`${crdsUrl}/assets`)
  .then(_resJson);
const requestBlockCache = () => fetch(`${crdsUrl}/blockcache`)
  .then(_resJson);
const requestUnconfirmedBalances = address => fetch(`${crdsUrl}/unconfirmedBalances/${encodeURIComponent(address)}`)
  .then(_resJson);
const requestUnconfirmedMinter = asset => fetch(`${crdsUrl}/unconfirmedMinter/${encodeURIComponent(asset)}`)
  .then(_resJson);
const requestUnconfirmedPrice = asset => fetch(`${crdsUrl}/unconfirmedPrice/${encodeURIComponent(asset)}`)
  .then(_resJson);
const requestMempool = () => fetch(`${crdsUrl}/mempool`)
  .then(_resJson);
const requestMine = address => fetch(`${crdsUrl}/mine`, {
  method: 'POST',
  headers: (() => {
    const headers = new Headers();
    headers.append('Content-Type', 'application/json');
    return headers;
  })(),
  body: JSON.stringify({address}),
})
  .then(_resJson);
const requestMinedBlocks = () => fetch(`${crdsUrl}/minedBlocks`)
  .then(_resJson);
const _requestSubmitMessage = message => fetch(`${crdsUrl}/submitMessage`, {
    method: 'POST',
    headers: (() => {
      const headers = new Headers();
      headers.append('Content-Type', 'application/json');
      return headers;
    })(),
    body: JSON.stringify(message),
  })
  .then(_resJson);
const requestCreateSend = (asset, quantity, srcAddress, dstAddress, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'send', startHeight, asset, quantity, srcAddress, dstAddress, publicKey: publicKeyString, timestamp});
    const payloadHash = _sha256(payload);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateMinter = (asset, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'minter', asset, publicKey: publicKeyString, startHeight, timestamp});
    const payloadBuffer = encodeUtf8(payload);
    const payloadHash = _sha256(payloadBuffer);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateMint = (asset, quantity, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'mint', asset, quantity, publicKey: publicKeyString, startHeight, timestamp});
    const payloadHash = _sha256(payload);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateGet = (address, asset, quantity) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const payload = JSON.stringify({type: 'get', address, asset, quantity, startHeight, timestamp});
    const payloadHash = _sha256(payload);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, NULL_PRIVATE_KEY).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateBurn = (asset, quantity, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'burn', asset, quantity, publicKey: publicKeyString, startHeight, timestamp});
    const payloadHash = _sha256(payload);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateDrop = (address, asset, quantity) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const payload = JSON.stringify({type: 'drop', address, asset, quantity, startHeight, timestamp});
    const payloadHash = _sha256(payload);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, NULL_PRIVATE_KEY).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreatePrice = (asset, price, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'price', asset, price, publicKey: publicKeyString, startHeight, timestamp});
    const payloadBuffer = encodeUtf8(payload);
    const payloadHash = _sha256(payloadBuffer);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });
const requestCreateBuy = (asset, quantity, price, privateKey) => requestStatus()
  .then(status => {
    const {startHeight, timestamp} = status;
    const privateKeyBuffer = base64.decode(privateKey);
    const publicKey = getPublicKey(privateKeyBuffer);
    const publicKeyString = base64.encode(publicKey);
    const payload = JSON.stringify({type: 'buy', asset, quantity, price, publicKey: publicKeyString, startHeight, timestamp});
    const payloadBuffer = encodeUtf8(payload);
    const payloadHash = _sha256(payloadBuffer);
    const payloadHashString = _arrayToHex(payloadHash);
    const signature = Uint8Array.from(secp256k1.sign(payloadHash, privateKeyBuffer).toDER());
    const signatureString = base64.encode(signature);
    const message = {
      payload: payload,
      hash: payloadHashString,
      signature: signatureString,
    };

    return _requestSubmitMessage(message);
  });

const _resJson = res => {
  if (res.status >= 200 && res.status < 300) {
    return res.json();
  } else {
    return Promise.reject({
      status: res.status,
      stack: 'API returned failure status code: ' + res.status,
    });
  }
};
const _arrayToHex = array => {
  let result = '';
  for (let i = 0; i < array.byteLength; i++) {
    const n = array[i];
    result += ('00' + n.toString(16)).slice(-2);
  }
  return result;
};
const _sha256 = o => {
  if (typeof o === 'string') {
    o = encodeUtf8(o);
  }
  return fastSha256(o);
};

return {
  getPublicKey,
  getAddress,
  requestStatus,
  requestAssets,
  requestBlockCache,
  requestUnconfirmedBalances,
  requestUnconfirmedMinter,
  requestUnconfirmedPrice,
  requestMempool,
  requestMine,
  requestMinedBlocks,
  requestCreateSend,
  requestCreateMinter,
  requestCreateMint,
  requestCreateGet,
  requestCreateBurn,
  requestCreateDrop,
  requestCreatePrice,
  requestCreateBuy,
};

};