158 lines
4.6 KiB
TypeScript
158 lines
4.6 KiB
TypeScript
import BN from 'bn.js';
|
|
import { IHexStrTransaction } from 'libs/transaction';
|
|
import { Wei, TokenValue } from 'libs/units';
|
|
import { stripHexPrefix } from 'libs/formatters';
|
|
import { hexToNumber } from 'utils/formatters';
|
|
import { INode, TxObj } from '../INode';
|
|
import RPCClient from './client';
|
|
import RPCRequests from './requests';
|
|
import {
|
|
isValidGetBalance,
|
|
isValidEstimateGas,
|
|
isValidCallRequest,
|
|
isValidTokenBalance,
|
|
isValidTransactionCount,
|
|
isValidTransactionByHash,
|
|
isValidTransactionReceipt,
|
|
isValidCurrentBlock,
|
|
isValidRawTxApi
|
|
} from 'libs/validators';
|
|
import { Token } from 'types/network';
|
|
import { TransactionData, TransactionReceipt } from 'types/transactions';
|
|
|
|
export default class RpcNode implements INode {
|
|
public client: RPCClient;
|
|
public requests: RPCRequests;
|
|
|
|
constructor(endpoint: string) {
|
|
this.client = new RPCClient(endpoint);
|
|
this.requests = new RPCRequests();
|
|
}
|
|
|
|
public ping(): Promise<boolean> {
|
|
return this.client
|
|
.call(this.requests.getNetVersion())
|
|
.then(() => true)
|
|
.catch(() => false);
|
|
}
|
|
|
|
public sendCallRequest(txObj: TxObj): Promise<string> {
|
|
return this.client
|
|
.call(this.requests.ethCall(txObj))
|
|
.then(isValidCallRequest)
|
|
.then(response => response.result);
|
|
}
|
|
public getBalance(address: string): Promise<Wei> {
|
|
return this.client
|
|
.call(this.requests.getBalance(address))
|
|
.then(isValidGetBalance)
|
|
.then(({ result }) => Wei(result));
|
|
}
|
|
|
|
public estimateGas(transaction: Partial<IHexStrTransaction>): Promise<Wei> {
|
|
return this.client
|
|
.call(this.requests.estimateGas(transaction))
|
|
.then(isValidEstimateGas)
|
|
.then(({ result }) => Wei(result))
|
|
.catch(error => {
|
|
throw new Error(error.message);
|
|
});
|
|
}
|
|
|
|
public getTokenBalance(
|
|
address: string,
|
|
token: Token
|
|
): Promise<{ balance: TokenValue; error: string | null }> {
|
|
return this.client
|
|
.call(this.requests.getTokenBalance(address, token))
|
|
.then(isValidTokenBalance)
|
|
.then(({ result }) => {
|
|
return {
|
|
balance: TokenValue(result),
|
|
error: null
|
|
};
|
|
})
|
|
.catch(err => ({
|
|
balance: TokenValue('0'),
|
|
error: 'Caught error:' + err
|
|
}));
|
|
}
|
|
|
|
public getTokenBalances(
|
|
address: string,
|
|
tokens: Token[]
|
|
): Promise<{ balance: TokenValue; error: string | null }[]> {
|
|
return this.client
|
|
.batch(tokens.map(t => this.requests.getTokenBalance(address, t)))
|
|
.then(response =>
|
|
response.map(item => {
|
|
if (isValidTokenBalance(item)) {
|
|
return {
|
|
balance: TokenValue(item.result),
|
|
error: null
|
|
};
|
|
} else {
|
|
return {
|
|
balance: TokenValue('0'),
|
|
error: 'Invalid object shape'
|
|
};
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
public getTransactionCount(address: string): Promise<string> {
|
|
return this.client
|
|
.call(this.requests.getTransactionCount(address))
|
|
.then(isValidTransactionCount)
|
|
.then(({ result }) => result);
|
|
}
|
|
|
|
public getTransactionByHash(txhash: string): Promise<TransactionData> {
|
|
return this.client
|
|
.call(this.requests.getTransactionByHash(txhash))
|
|
.then(isValidTransactionByHash)
|
|
.then(({ result }) => ({
|
|
...result,
|
|
to: result.to || '0x0',
|
|
value: Wei(result.value),
|
|
gasPrice: Wei(result.gasPrice),
|
|
gas: Wei(result.gas),
|
|
nonce: hexToNumber(result.nonce),
|
|
blockNumber: result.blockNumber ? hexToNumber(result.blockNumber) : null,
|
|
transactionIndex: result.transactionIndex ? hexToNumber(result.transactionIndex) : null
|
|
}));
|
|
}
|
|
|
|
public getTransactionReceipt(txhash: string): Promise<TransactionReceipt> {
|
|
return this.client
|
|
.call(this.requests.getTransactionReceipt(txhash))
|
|
.then(isValidTransactionReceipt)
|
|
.then(({ result }) => ({
|
|
...result,
|
|
transactionIndex: hexToNumber(result.transactionIndex),
|
|
blockNumber: hexToNumber(result.blockNumber),
|
|
cumulativeGasUsed: Wei(result.cumulativeGasUsed),
|
|
gasUsed: Wei(result.gasUsed),
|
|
status: result.status ? hexToNumber(result.status) : null,
|
|
root: result.root || null
|
|
}));
|
|
}
|
|
|
|
public getCurrentBlock(): Promise<string> {
|
|
return this.client
|
|
.call(this.requests.getCurrentBlock())
|
|
.then(isValidCurrentBlock)
|
|
.then(({ result }) => new BN(stripHexPrefix(result)).toString());
|
|
}
|
|
|
|
public sendRawTx(signedTx: string): Promise<string> {
|
|
return this.client
|
|
.call(this.requests.sendRawTx(signedTx))
|
|
.then(isValidRawTxApi)
|
|
.then(({ result }) => {
|
|
return result;
|
|
});
|
|
}
|
|
}
|