waves4you/waves4you.js

Waves Client Library

const wavesTransaction = require('@waves/waves-transactions');

const chainNumber = {
  mainnet: 87,
  testnet: 84,
  stage: 83
}

function createNewWallet(network = 'mainnet'){
  let networkId;
  if (network) {
    networkId = chainNumber[network];
  }
  const account = wavesTransaction.seedUtils.Seed.create();
  const privateKey = wavesTransaction.libs.crypto.privateKey(account.phrase);
  const address = wavesTransaction.libs.crypto.address(account.phrase, networkId);
  return {
    phrase: account.phrase,
    privateKey: privateKey,
    address: address
  }
}

function getPublicKeyFromPrivateKey(privateKey){
  return wavesTransaction.libs.crypto.publicKey({privateKey: privateKey});
}

function getAddressFromPrivateKey(privateKey, network = 'mainnet'){
  let networkId;
  if (network) {
    networkId = chainNumber[network];
  }
  return wavesTransaction.libs.crypto.address({publicKey: getPublicKeyFromPrivateKey(privateKey)}, networkId);
}

function getAddressFromPublicKey(publicKey, network = 'mainnet'){
  let networkId;
  if (network) {
    networkId = chainNumber[network];
  }
  return wavesTransaction.libs.crypto.address({publicKey: publicKey}, networkId);
}

function getAccountFromSeed(seed, network = 'mainnet'){
  let networkId;
  if (network) {
    networkId = chainNumber[network];
  }
  const privateKey = wavesTransaction.libs.crypto.privateKey(seed);
  const address = wavesTransaction.libs.crypto.address(seed, networkId);
  return {
    phrase: seed,
    privateKey: privateKey,
    address: address
  }
}

function isValidAddress(address, network = 'mainnet') {
  try {
    let networkId;
    if (network) {
      networkId = chainNumber[network];
    }
    return wavesTransaction.validators.isValidAddress(address, networkId);
  } catch (ex) {
    return false;
  }
}

function createTransaction(_type, _params, _privateKey, network = 'mainnet') {
  try {
    const type = parseInt(_type);
    if (!type) {
      throw new Error('No transaction type specified');
    }

    const networkId = chainNumber[network];

    const privateKey = {
      privateKey: _privateKey
    };

    let transaction;

    switch (type) {
      case 3: //Issue (never tested)
        let issueParams = {
          name: _params.name.toString(),
          description: (_params.description || '').toString(),
          quantity: parseInt(_params.quantity.toString()),
          senderPublicKey: _params.senderPublicKey.toString(),
          reissuable: !!_params.reiussable,
          decimals: parseInt(_params.decimals.toString()),
          timestamp: Date.now(),
          fee: parseInt(_params.fee.toString()),
          chainId: networkId
        }
        const transactionIssueBuilt = wavesTransaction.issue(issueParams, privateKey);
        transaction = transactionIssueBuilt;
        break;
      case 4: //Transfer
        let transferParams = {
          amount: parseInt(_params.amount.toString()),
          recipient: _params.recipient.toString(),
          feeAssetId: _params.feeAssetId,
          assetId: _params.assetId,
          attachment: (_params.attachment || 'string').toString(),
          senderPublicKey: _params.senderPublicKey.toString(),
          timestamp: Date.now(),
          fee: parseInt(_params.fee.toString()),
          chainId: networkId
        }
        const transactionTransferBuilt = wavesTransaction.transfer(transferParams, privateKey);
        transaction = transactionTransferBuilt;
        break;
      case 5: //Reissue (never tested)
        let reissueParams = {
          quantity: parseInt(_params.quantity.toString()),
          assetId: _params.feeAssetId.toString(),
          reissuable: !!_params.reiussable,
          senderPublicKey: _params.senderPublicKey.toString(),
          timestamp: Date.now(),
          fee: parseInt(_params.fee.toString()),
          chainId: networkId
        }
        const transactionReissueBuilt = wavesTransaction.reissue(reissueParams, privateKey);
        transaction = transactionReissueBuilt;
        break;
      case 6: //Burn (never tested)
        let burnParams = {
          quantity: parseInt(_params.quantity.toString()),
          assetId: _params.feeAssetId.toString(),
          senderPublicKey: _params.senderPublicKey.toString(),
          timestamp: Date.now(),
          fee: parseInt(_params.fee.toString()),
          chainId: networkId
        }
        const transactionBurnBuilt = wavesTransaction.burn(burnParams, privateKey);
        transaction = transactionBurnBuilt;
        break;
      case 10: //Alias (never tested)
        if (_params.alias && _params.alias.length > 3 && _params.alias.length <= 30) {
          let aliasParams = {
            alias: _params.alias.toString(),
            senderPublicKey: _params.senderPublicKey.toString(),
            timestamp: Date.now(),
            fee: parseInt(_params.fee.toString()),
            chainId: networkId
          }
          const transactionAliasBuilt = wavesTransaction.burn(aliasParams, privateKey);
          transaction = transactionAliasBuilt;
        } else {
          throw new Error('invalid alias');
        }
        break;
      case 11: //Mass Transfer (never tested)
      // transfers: [
      //   {
      //     amount: 100,
      //     recipient: '3P23fi1qfVw6RVDn4CH2a5nNouEtWNQ4THs',
      //   },
      //   {
      //     amount: 200,
      //     recipient: '3PPnqZznWJbPG2Z1Y35w8tZzskiq5AMfUXr',
      //   },
      // ]
        let transfers = (_params.transfers || []).map(function (t, index) {
          return {
            amount: parseInt(t.amount.toString()),
            recipient: t.recipient.toString()
          }
        });
        let massTransferParams = {
          transfers: transfers,
          assetId: _params.feeAssetId,
          senderPublicKey: _params.senderPublicKey.toString(),
          timestamp: Date.now(),
          fee: parseInt(_params.fee.toString()),
          chainId: networkId
        }
        const transactionMassTransferBuilt = wavesTransaction.burn(massTransferParams, privateKey);
        transaction = transactionMassTransferBuilt;
        break;
      default:
        throw new Error('Unsupported transaction type');
    }

    return transaction;
  } catch (ex) {
    return null;
  }
}

module.exports = {
  createNewWallet,
  getAccountFromSeed,
  getPublicKeyFromPrivateKey,
  getAddressFromPrivateKey,
  getAddressFromPublicKey,
  isValidAddress,
  createTransaction
};