@parity/api
Version:
The Parity Promise-based API library for interfacing with Ethereum over RPC
313 lines (312 loc) • 12.3 kB
JavaScript
;
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity.
//
// SPDX-License-Identifier: MIT
Object.defineProperty(exports, "__esModule", { value: true });
var bignumber_js_1 = require("bignumber.js");
var address_1 = require("@parity/abi/lib/util/address");
var input_1 = require("./input");
describe('format/input', function () {
var address = '0x63cf90d3f0410092fc0fca41846f596223979195';
describe('inAddress', function () {
var address = '63cf90d3f0410092fc0fca41846f596223979195';
it('adds the leading 0x as required', function () {
expect(input_1.inAddress(address)).toEqual("0x" + address);
});
it('returns verified addresses as-is', function () {
expect(input_1.inAddress("0x" + address)).toEqual("0x" + address);
});
it('returns lowercase equivalents', function () {
expect(input_1.inAddress(address.toUpperCase())).toEqual("0x" + address);
});
it('returns 0x on null addresses', function () {
expect(input_1.inAddress()).toEqual('0x');
});
});
describe('inAddresses', function () {
it('handles empty values', function () {
expect(input_1.inAddresses()).toEqual([]);
});
it('handles mapping of all addresses in array', function () {
var address = '63cf90d3f0410092fc0fca41846f596223979195';
expect(input_1.inAddresses([undefined, address])).toEqual(['0x', "0x" + address]);
});
});
describe('inBlockNumber()', function () {
it('returns earliest as-is', function () {
expect(input_1.inBlockNumber('earliest')).toEqual('earliest');
});
it('returns latest as-is', function () {
expect(input_1.inBlockNumber('latest')).toEqual('latest');
});
it('returns pending as-is', function () {
expect(input_1.inBlockNumber('pending')).toEqual('pending');
});
it('formats existing BigNumber into hex', function () {
expect(input_1.inBlockNumber(new bignumber_js_1.default(0x123456))).toEqual('0x123456');
});
it('formats hex strings into hex', function () {
expect(input_1.inBlockNumber('0x123456')).toEqual('0x123456');
});
it('formats numbers into hex', function () {
expect(input_1.inBlockNumber(0x123456)).toEqual('0x123456');
});
});
describe('inData', function () {
it('formats to hex', function () {
expect(input_1.inData('123456')).toEqual('0x123456');
});
it('converts a string to a hex representation', function () {
expect(input_1.inData('jaco')).toEqual('0x6a61636f');
});
});
describe('inHex', function () {
it('leaves leading 0x as-is', function () {
expect(input_1.inHex('0x123456')).toEqual('0x123456');
});
it('adds a leading 0x', function () {
expect(input_1.inHex('123456')).toEqual('0x123456');
});
it('returns uppercase as lowercase (leading 0x)', function () {
expect(input_1.inHex('0xABCDEF')).toEqual('0xabcdef');
});
it('returns uppercase as lowercase (no leading 0x)', function () {
expect(input_1.inHex('ABCDEF')).toEqual('0xabcdef');
});
it('handles empty & null', function () {
expect(input_1.inHex()).toEqual('0x');
expect(input_1.inHex('')).toEqual('0x');
});
});
describe('inHash', function () {
it('leaves leading 0x as-is', function () {
expect(input_1.inHash('0x123456')).toEqual('0x123456');
});
});
describe('inFilter', function () {
['address'].forEach(function (input) {
it("formats " + input + " address as address", function () {
var block = {};
// @ts-ignore
block[input] = address;
var formatted = input_1.inFilter(block)[input];
expect(address_1.isAddress(formatted)).toBe(true);
expect(formatted).toEqual(address);
});
});
['fromBlock', 'toBlock'].forEach(function (input) {
it("formats " + input + " number as blockNumber", function () {
var block = {};
// @ts-ignore
block[input] = 0x123;
var formatted = input_1.inFilter(block)[input];
expect(formatted).toEqual('0x123');
});
});
it('ignores and passes through unknown keys', function () {
expect(input_1.inFilter({ someRandom: 'someRandom' })).toEqual({
someRandom: 'someRandom'
});
});
it('formats an filter options object with relevant entries converted', function () {
expect(input_1.inFilter({
address: address,
fromBlock: 'latest',
toBlock: 0x101,
extraData: 'someExtraStuffInHere',
limit: 0x32
})).toEqual({
address: address,
fromBlock: 'latest',
toBlock: '0x101',
extraData: 'someExtraStuffInHere',
limit: 50
});
});
});
describe('inNumber10()', function () {
it('formats existing BigNumber into number', function () {
expect(input_1.inNumber10(new bignumber_js_1.default(123))).toEqual(123);
});
it('formats hex strings into decimal', function () {
expect(input_1.inNumber10('0x0a')).toEqual(10);
});
it('formats numbers into number', function () {
expect(input_1.inNumber10(123)).toEqual(123);
});
it('formats undefined into 0', function () {
expect(input_1.inNumber10()).toEqual(0);
});
});
describe('inNumber16()', function () {
it('formats existing BigNumber into hex', function () {
expect(input_1.inNumber16(new bignumber_js_1.default(0x123456))).toEqual('0x123456');
});
it('formats hex strings into hex', function () {
expect(input_1.inNumber16('0x123456')).toEqual('0x123456');
});
it('formats numbers into hex', function () {
expect(input_1.inNumber16(0x123456)).toEqual('0x123456');
});
it('formats undefined into 0', function () {
expect(input_1.inNumber16()).toEqual('0x0');
});
});
describe('inOptions', function () {
['data'].forEach(function (input) {
it("converts " + input + " to hex data", function () {
var block = {};
block[input] = '1234';
var formatted = input_1.inData(block[input]);
expect(formatted).toEqual('0x1234');
});
});
['from', 'to'].forEach(function (input) {
it("formats " + input + " address as address", function () {
var block = {};
block[input] = address;
var formatted = input_1.inOptions(block)[input];
expect(address_1.isAddress(formatted)).toBe(true);
expect(formatted).toEqual(address);
});
});
it('does not encode an empty `to` value', function () {
var options = { to: '' };
var formatted = input_1.inOptions(options);
expect(formatted.to).toEqual(undefined);
});
['gas', 'gasPrice', 'value', 'nonce'].forEach(function (input) {
it("formats " + input + " number as hexnumber", function () {
var block = {};
block[input] = 0x123;
var formatted = input_1.inOptions(block)[input];
expect(formatted).toEqual('0x123');
});
});
it('passes condition as null when specified as such', function () {
expect(input_1.inOptions({ condition: null })).toEqual({ condition: null });
});
it('ignores and passes through unknown keys', function () {
expect(input_1.inOptions({ someRandom: 'someRandom' })).toEqual({
someRandom: 'someRandom'
});
});
it('formats an options object with relevant entries converted', function () {
expect(input_1.inOptions({
from: address,
to: address,
gas: new bignumber_js_1.default('0x100'),
gasPrice: 0x101,
value: 258,
nonce: '0x104',
data: '0123456789',
extraData: 'someExtraStuffInHere'
})).toEqual({
from: address,
to: address,
gas: '0x100',
gasPrice: '0x101',
value: '0x102',
nonce: '0x104',
data: '0x0123456789',
extraData: 'someExtraStuffInHere'
});
});
});
describe('inTraceType', function () {
it('returns array of types as is', function () {
var types = ['vmTrace', 'trace', 'stateDiff'];
expect(input_1.inTraceType(types)).toEqual(types);
});
it('formats single string type into array', function () {
var type = 'vmTrace';
expect(input_1.inTraceType(type)).toEqual([type]);
});
});
describe('inDeriveHash', function () {
it('returns derive hash', function () {
expect(input_1.inDeriveHash(1)).toEqual({
hash: '0x1',
type: 'soft'
});
expect(input_1.inDeriveHash(null)).toEqual({
hash: '0x',
type: 'soft'
});
expect(input_1.inDeriveHash({
hash: 5
})).toEqual({
hash: '0x5',
type: 'soft'
});
expect(input_1.inDeriveHash({
hash: 5,
type: 'hard'
})).toEqual({
hash: '0x5',
type: 'hard'
});
});
});
describe('inDeriveIndex', function () {
it('returns derive hash', function () {
expect(input_1.inDeriveIndex(null)).toEqual([]);
expect(input_1.inDeriveIndex([])).toEqual([]);
expect(input_1.inDeriveIndex([1])).toEqual([
{
index: 1,
type: 'soft'
}
]);
expect(input_1.inDeriveIndex({
index: 1
})).toEqual([
{
index: 1,
type: 'soft'
}
]);
expect(input_1.inDeriveIndex([
{
index: 1,
type: 'hard'
},
5
])).toEqual([
{
index: 1,
type: 'hard'
},
{
index: 5,
type: 'soft'
}
]);
});
});
describe('inTopics', function () {
it('returns empty array when no inputs provided', function () {
expect(input_1.inTopics()).toEqual([]);
});
it('keeps null topic as null', function () {
expect(input_1.inTopics([null])).toEqual([null]);
});
it('pads topics as received', function () {
expect(input_1.inTopics(['123'])).toEqual([
'0x0000000000000000000000000000000000000000000000000000000000000123'
]);
});
it('handles nested arrays', function () {
expect(input_1.inTopics([null, '123', ['456', null, '789']])).toEqual([
null,
'0x0000000000000000000000000000000000000000000000000000000000000123',
[
'0x0000000000000000000000000000000000000000000000000000000000000456',
null,
'0x0000000000000000000000000000000000000000000000000000000000000789'
]
]);
});
});
});