查询以太币及代币余额与价格，进行以太币与代币的转账（两种方式）并获取交易记录

查询以太币及代币余额与价格，进行以太币与代币的转账（两种方式）并获取交易记录

// 补齐64位，不够前面用0补齐
function addPreZero(num){
  var t = (num+'').length,
  s = '';
  for(var i=0; i<64-t; i++){
    s += '0';
  }
  return s+num;
}

一，使用web3.js

  查询类方法在私链和主链上的方法都是一样的，说明以下几点：

• 主链地址。可以去infura申请

• contractAbi。合约的abi。可以去https://etherscan.io获取，如果代币合约提供了code，就会有abi

 1，链接web3.js

import Web3 from 'web3'
let getWeb3 = new Promise(function(resolve, reject) {
    var web3 = window.web3
    if (typeof web3 !== 'undefined') {
        web3 = new Web3(web3.currentProvider)
        results = {web3: web3}
        console.log('Injected web3 detected.');
        resolve(results)
    } else {
        var provider = new Web3.providers.HttpProvider('https://mainnet.infura.io/v3/apikey')
        web3 = new Web3(provider)
        results = {web3: web3}
        resolve(results)
    }
})

2，查询以太币以及代币的价格与gasLimit

getWeb3.then(function (server) {
            server.web3.eth.getGasPrice(function (error, result) {//获取当前价格
                if (!error) {
                    alert(result.toNumber())
                    server.web3.eth.getBlock("latest", function (error1, info) {//gasLimit
                        if (!error1) {
              alert(JSON.stringify(info.gasLimit))
                          
                        }

                    })
                }
            });
        });

3，查询以太币以及代币的余额

const BigNumber = require('bignumber.js');
const Ether = new BigNumber(10e+17);
//查询以太币余额
balanceOfETH = (address) => {
        let self = this;
        getWeb3.then(function (server) {
            let filter = server.web3.eth.filter('latest')
          valueOfgetBalance(server, address, 0)
         valueOfgetBalanceOther(server, address)
            filter.watch(function (error, result) {

                if (!error) {
                  valueOfgetBalance(server, address, 0)
                  valueOfgetBalanceOther(server, address)
                }
            }, function (err) {
                console.log(err);
            });
        })
    }
valueOfgetBalance = (server, address, num) => {
        let self = this;
        const balance = server.web3.eth.getBalance(address, (err2, bal) => {
            if (!err2) {
                let ret = new BigNumber(bal);
              alert(ret.dividedBy(Ether)).toFixed(2))//以太币余额
            }

        });

    }
//查询代币余额
valueOfgetBalanceOther= (server, address) => {
        let self = this;
        const balance = server.web3.eth.getBalance(address, (err2, bal) => {
            if (!err2) {
                let contractother = 
        server.web3.eth.contract(contractabi).at(contractaddress);
                contractother.balanceOf(address, (error2, bal) => {
                    if (!error2) {
                        let ret = new BigNumber(bal);
            alert(ret.dividedBy(Ether)).toFixed(2))//代币币余额
                    }

                })
            }
        });
    }

4，在私链上转账以太币及代币

// 以太币转账
web3.eth.sendTransaction({
    from: currentAccount,
    to: receiverAccount,
    value: '1000000000000000'
})
.then(function(receipt){
    console.log(receipt);
});

// 代币转账
myContract.methods.transfer(to, amount).send({from: currentAccount}), function(error, transactionHash){
    if(!error) {
       console.log('transactionHash is ' + transactionHash);
    } else {
       console.log(error);
    }
});

5，在主链上转账以太币及代币

上面的方法只适用于私链。因为你在私链的账户在本地是有私钥的。而在主链上要进行写入数据的方法，是需要获取账户的私钥并对交易进行签名的，所以要用到web3.eth.sendSignedTransaction方法。

文档http://web3js.readthedocs.io/en/1.0/web3-eth.html#sendsignedtransaction

需要npm安裝'ethereumjs-tx'

npm install ethereumjs-tx

转账的方法(以太币以及代币)

// 引入ethereumjs-tx
var tx = require('ethereumjs-tx');
transfer = (recipientAddress, balance, privateKey) => {
        // ethGasLimit
        let self = this;
        getWeb3.then(function (server) {
            let address =WalletaA;//转账人钱包地址
     
            server.web3.eth.getTransactionCount(address, function (err, nonce) {
              
                let balanceEth = parseFloat(balance) * Ether;//转换成ETH的最小单位数量
                let rawTx = {}
                if (self.state.token == 'ETH') {//以太币转账
                    //创建转账对象
                    rawTx = {
                        nonce: server.web3.toHex(nonce++),//nonce转出累计次数
                        gasPrice: server.web3.toHex(10e9),
                        from: address, //从keystore的address账户转出
                        gasLimit: server.web3.toHex(99000), //gasLimit限制
                        to: recipientAddress, //向recipientAddress转账
                        value: balanceEth//valueEth
                    }
                } else {//代币转账
                    // data的组成，由：0x + 要调用的合约方法的function signature + 要传递的方法参数，每个参数都为64位(对transfer来说，第一个是接收人的地址去掉0x，第二个是代币数量的16进制表示，去掉前面0x，然后补齐为64位)
                    let data = '0x' + 'a9059cbb' + addPreZero(recipientAddress.substr(2)) + addPreZero(server.web3.toHex(balanceEth).substr(2))
                    rawTx = {
                        nonce: server.web3.toHex(nonce++),
                        gasLimit: server.web3.toHex(9900),
                        gasPrice: server.web3.toHex(10e9),
                        // 注意这里是代币合约地址    
                        to:address,
                        from: address,
                        // 调用合约转账value这里留空
                        value: '0x00',
                        // data的组成，由：0x + 要调用的合约方法的function signature + 要传递的方法参数，每个参数都为64位(对transfer来说，第一个是接收人的地址去掉0x，第二个是代币数量的16进制表示，去掉前面0x，然后补齐为64位)
                        data: data
                    }
                }
                let tx = new ethTX(rawTx);
                let keyBuf = Buffer.from(privateKey, 'hex');
                //对交易进行签名
                tx.sign(keyBuf);
                if (tx.verifySignature()) {
                    console.log('Signature Checks out!')
                }
                let serializedTxHex = '0x' + tx.serialize().toString('hex');
                server.web3.eth.sendRawTransaction(serializedTxHex, function (err, transactionHash) {
                    //交易信息transctionHash可以通过web3.eth.getTransaction(transactionHash)详细交易信息
                    //alert(address + '  ' + nonce + '   ' + err + ';  ' + transactionHash)
                    //alert('详细交易信息==' + transactionHash + '详细交易错误信息==' + JSON.stringify(err));
                  
                });
            });
        });
        //});
    }

二，以太坊api

  1,查询以太币以及代币的价格与gasLimit

fetch(`https://api.etherscan.io/api?module=proxy&action=eth_gasPrice&apikey=apikey`)
            .then(result => result.json())
            .then(result => {
                // alert(JSON.stringify(parseInt(result.result, 16))/ 1e9)
                // if (result.status == 1) {
                let parseIntresult = parseInt(result.result, 16)
              
                //alert(result.result+'===0x'+parseIntresult.toString(16))
               
                fetch(`https://api.etherscan.io/api?module=proxy&action=eth_getBlockByNumber&tag=0x10d4f&boolean=true&apikey=apikey`) 
.then(info => info.json()) 
.then(info => { 
// alert(JSON.stringify(info)) 
let parseIntinfo = parseInt(info.result.gasLimit, 16) 

 }) 
.catch(e => { 
  }) 
 }) 
.catch(e => { 
 })

  2,查询以太币以及代币的余额

//以太币余额
return fetch(`https://api.etherscan.io/api?module=account&action=balance&address=${address}&tag=latest&apikey=apikey`)
        .then(result => result.json())
        .then(result => {
            if (result.status == 1) {
                let ret = new BigNumber(result.result);
              alert(ret.dividedBy(Ether)).toFixed(2);//以太币余额
               
            }
        })
        .catch(e => {

        })

//代币余额
  return fetch(`https://api.etherscan.io/api?module=account&action=tokenbalance&contractaddress=${contactaddress}&address=${address}&tag=latest&apikey=apikey`)
             .then(result => result.json())
            .then(result => {
                if (result.status == 1) {
                     let ret = new BigNumber(result.result);
                  alert(ret.dividedBy(Ether)).toFixed(2);
       
                 }
             })
             .catch(e => {

            })

3,在主链上转账以太币及代币

transfer = (recipientAddress, balance, privateKey) => {
        // ethGasLimit
        let self = this;
        let address = WalletaA;//转账人钱包地址
        fetch(`https://api.etherscan.io/api?module=proxy&action=eth_getTransactionCount&address=${address}&tag=latest&apikey=apikey`)
       .then(result => result.json())
        .then(result => {
                let nonce = parseInt(result.result, 16)+1
                let gasPrice = 10e9;//gas价格
                let gasLimit = 9900;//gas限制
                let balanceEth = parseFloat(balance) * Ether;//转换成ETH的最小单位数量
                let rawTx = {}
                if (self.state.token == 'ETH') {
                    //创建转账对象
                    rawTx = {
                        nonce: '0x'+nonce.toString(16),//nonce转出累计次数
                        gasPrice: '0x'+gasPrice.toString(16),
                        from: address, //从keystore的address账户转出
                        gasLimit: '0x'+gasLimit.toString(16), //gasLimit限制
                        to: recipientAddress, //向recipientAddress转账
                        value: balanceEth//valueEth
                    }
                } else {
                    // data的组成，由：0x + 要调用的合约方法的function signature + 要传递的方法参数，每个参数都为64位(对transfer来说，第一个是接收人的地址去掉0x，第二个是代币数量的16进制表示，去掉前面0x，然后补齐为64位)
                    let data = '0x' + 'a9059cbb' + addPreZero(recipientAddress.substr(2)) + addPreZero(balanceEth.toString(16))
                    rawTx = {
                        nonce: '0x'+nonce.toString(16),
                        gasLimit: '0x'+gasLimit.toString(16),
                        gasPrice: '0x'+gasPrice.toString(16),
                        // 注意这里是代币合约地址    
                        to: hrcjson.address,
                        from: address,
                        // 调用合约转账value这里留空
                        value: '0x00',
                        // data的组成，由：0x + 要调用的合约方法的function signature + 要传递的方法参数，每个参数都为64位(对transfer来说，第一个是接收人的地址去掉0x，第二个是代币数量的16进制表示，去掉前面0x，然后补齐为64位)
                        data: data
                    }
                }
                let tx = new ethTX(rawTx);
                let keyBuf = Buffer.from(privateKey, 'hex');
                //对交易进行签名
                tx.sign(keyBuf);
                if (tx.verifySignature()) {
                    console.log('Signature Checks out!')
                }

                let serializedTxHex = '0x' + tx.serialize().toString('hex');
                fetch(`https://api.etherscan.io/api?module=proxy&action=eth_sendRawTransaction&hex=${serializedTxHex}&apikey=apikey`)
                .then(info => info.json())
                 .then(info => {
                    alert('转账信息=='+JSON.stringify(info))
                  
        })
        .catch(e => {

        })
    }

三，获取交易记录

fetch(`https://api.etherscan.io/api?module=account&action=tokentx&contractaddress=${contractaddress}&address=${address}&page=1&offset=20&sort=desc&apikey=apikey`)
        .then(transactionList => transactionList.json())
            .then(transactionList => {
                if (transactionList.status == 1) {
                    let value = transactionList.result[transactionList.result.length - 1].value
                    transactionList = transactionList.result;
                    
                    // const txnIn = transactionList.filter(t => t.to === address);
                    // const txnOut = transactionList.filter(t => t.from === address);
                    //处理转账数据，转入转出
                }
              

            }).catch(err => {});