tornado-packages/ethers.js
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
v5.2
ethers.js/packages/tests/src.ts/test-utils.ts

915 lines
36 KiB
TypeScript
Raw Permalink Normal View History

Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
'use strict';
import assert from 'assert';
Updated references to umbrella package in tests.
2019-05-14 18:42:45 -04:00
import { ethers } from "ethers";
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
import { loadTests, TestCase } from "@ethersproject/testcases";
import * as utils from './utils';
function equals(a: any, b: any): boolean {
if (Array.isArray(a)) {
if (!Array.isArray(b) || a.length !== b.length) {
return false;
}
for (let i = 0; i < a.length; i++) {
if (!equals(a[i], b[i])) { return false; }
}
return true;
}
return a === b;
}
describe('Test Contract Address Generation', function() {
// @TODO: Mine a large collection of these from the blockchain
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let getContractAddress = ethers.utils.getContractAddress;
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let Tests = [
Fixed getContractAddress for odd-length hex values (#572).
2019-09-08 02:39:00 -04:00
// Transaction: 0x939aa17985bc2a52a0c1cba9497ef09e092355a805a8150e30e24b753bac6864
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
{
address: '0x3474627D4F63A678266BC17171D87f8570936622',
Fixed getContractAddress for odd-length hex values (#572).
2019-09-08 02:39:00 -04:00
name: 'tx-0x939aa179 (number)',
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
tx: {
from: '0xb2682160c482eb985ec9f3e364eec0a904c44c23',
nonce: 10,
}
},
Fixed getContractAddress for odd-length hex values (#572).
2019-09-08 02:39:00 -04:00
{
address: '0x3474627D4F63A678266BC17171D87f8570936622',
name: 'tx-0x939aa179 (odd-zero-hex)',
tx: {
from: '0xb2682160c482eb985ec9f3e364eec0a904c44c23',
nonce: "0xa",
}
},
{
address: '0x3474627D4F63A678266BC17171D87f8570936622',
name: 'tx-0x939aa179 (even-zero-hex)',
tx: {
from: '0xb2682160c482eb985ec9f3e364eec0a904c44c23',
nonce: "0x0a",
}
},
// Ropsten: https://etherscan.io/tx/0x78d17f8ab31fb6ad688340634a9a29d8726feb6d588338a9b9b21a44159bc916
{
address: '0x271300790813f82638A8A6A8a86d65df6dF33c17',
name: 'tx-0x78d17f8a (odd-long-hex)',
tx: {
from: '0x8ba1f109551bd432803012645ac136ddd64dba72',
nonce: "0x200",
}
},
{
address: '0x271300790813f82638A8A6A8a86d65df6dF33c17',
name: 'tx-0x78d17f8a (even-long-hex)',
tx: {
from: '0x8ba1f109551bd432803012645ac136ddd64dba72',
nonce: "0x0200",
}
},
// https://ropsten.etherscan.io/tx/0x444ea8ae9890ac0ee5fd249512726abf9d23f44a378d5f45f727b65dc1b899c2
{
address: '0x995C25706C407a1F1E84b3777775e3e619764933',
name: 'tx-0x444ea8ae (even-long-hex)',
tx: {
from: '0x8ba1f109551bd432803012645ac136ddd64dba72',
nonce: "0x1d",
}
},
{
address: '0x995C25706C407a1F1E84b3777775e3e619764933',
name: 'tx-0x444ea8ae (padded-long-hex)',
tx: {
from: '0x8ba1f109551bd432803012645ac136ddd64dba72',
nonce: "0x001d",
}
},
{
address: '0x995C25706C407a1F1E84b3777775e3e619764933',
name: 'tx-0x444ea8ae (number)',
tx: {
from: '0x8ba1f109551bd432803012645ac136ddd64dba72',
nonce: 29,
}
},
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
// Ropsten: 0x5bdfd14fcc917abc2f02a30721d152a6f147f09e8cbaad4e0d5405d646c5c3e1
{
address: '0x0CcCC7507aEDf9FEaF8C8D731421746e16b4d39D',
name: 'zero-nonce',
tx: {
from: '0xc6af6e1a78a6752c7f8cd63877eb789a2adb776c',
nonce: 0
}
},
]
Tests.forEach(function(test) {
it(('Computes the transaction address - ' + test.name), function() {
this.timeout(120000);
assert.equal(getContractAddress(test.tx), test.address, 'computes the transaction address');
});
});
});
describe('Test RLP Coder', function() {
type TestCase = {
name: string,
decoded: string,
encoded: string
};
const tests: Array<TestCase> = loadTests('rlp-coder');
tests.forEach(function(test) {
it(('RLP coder encoded - ' + test.name), function() {
this.timeout(120000);
assert.equal(ethers.utils.RLP.encode(test.decoded), test.encoded, 'RLP encoded - ' + test.name);
});
});
tests.forEach((test: TestCase) => {
it(('RLP coder decoded - ' + test.name), function() {
this.timeout(120000);
assert.ok(equals(ethers.utils.RLP.decode(test.encoded), test.decoded),
'RLP decoded - ' + test.name);
});
});
});
describe('Test Unit Conversion', function () {
const tests: Array<TestCase.Unit> = loadTests('units');
tests.forEach((test) => {
let wei = ethers.BigNumber.from(test.wei);
it (('parses ' + test.ether + ' ether'), function() {
assert.ok(ethers.utils.parseEther(test.ether.replace(/,/g, '')).eq(wei),
'parsing ether failed - ' + test.name);
});
it (('formats ' + wei.toString() + ' wei to ether'), function() {
let actual = ethers.utils.formatEther(wei);
assert.equal(actual, test.ether_format,
'formatting wei failed - ' + test.name);
});
});
tests.forEach((test) => {
let wei = ethers.BigNumber.from(test.wei);
type UnitName = 'kwei' | 'mwei' | 'gwei' | 'szabo' | 'finney' | 'satoshi'
type UnitNameFormat = 'kwei_format' | 'mwei_format' | 'gwei_format' | 'szabo_format' | 'finney_format' | 'satoshi_format'
['kwei', 'mwei', 'gwei', 'szabo', 'finney', 'satoshi'].forEach((name: UnitName) => {
let unitName: string | number = name;
if (name === 'satoshi') { unitName = 8; }
if (test[name]) {
it(('parses ' + test[name] + ' ' + name), function() {
this.timeout(120000);
assert.ok(ethers.utils.parseUnits(test[name].replace(/,/g, ''), unitName).eq(wei),
('parsing ' + name + ' failed - ' + test.name));
});
}
let expectedKey: UnitNameFormat = (<UnitNameFormat>(name + '_format'));
if (test[expectedKey]) {
it (('formats ' + wei.toString() + ' wei to ' + name + ')'), function() {
let actual = ethers.utils.formatUnits(wei, unitName);
let expected = test[expectedKey];
assert.equal(actual, expected,
('formats ' + name + ' - ' + test.name));
});
}
});
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it("formats with commify", function() {
const tests: { [ testcase: string ]: string } = {
"0.0": "0.0",
".0": "0.0",
"0.": "0.0",
"00.00": "0.0",
"100.000": "100.0",
"100.0000": "100.0",
"1000.000": "1,000.0",
"1000.0000": "1,000.0",
"100.123": "100.123",
"100.1234": "100.1234",
"1000.1234": "1,000.1234",
"1000.12345": "1,000.12345",
"998998998998.123456789": "998,998,998,998.123456789",
};
Object.keys(tests).forEach((test) => {
assert.equal(ethers.utils.commify(test), tests[test]);
});
});
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
});
describe('Test Namehash', function() {
type TestCase = {
expected: string,
name: string
};
const tests: Array<TestCase> = loadTests('namehash');
tests.forEach((test: TestCase) => {
it(('computes namehash - "' + test.name + '"'), function() {
this.timeout(120000);
assert.equal(ethers.utils.namehash(test.name), test.expected,
'computes namehash(' + test.name + ')');
});
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it("isValidName", function() {
assert.ok(ethers.utils.isValidName("ricmoo.eth"));
assert.ok(!ethers.utils.isValidName(""));
assert.ok(!ethers.utils.isValidName("ricmoo..eth"));
});
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
});
Added string spell-checking to library and fixed discovered typos.
2020-04-22 02:42:25 -04:00
describe('Test ID Hash Functions', function () {
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
type TestCase = {
expected: string,
name: string,
text: string
};
const tests: Array<TestCase> = [
{
name: 'setAddr signature hash',
text: 'setAddr(bytes32,address)',
expected: '0xd5fa2b00b0756613052388dd576d941ba16904757996b8bb03a737ef4fd1f9ce'
}
]
tests.forEach((test: TestCase) => {
it(('computes id - ' + test.name), function() {
this.timeout(120000);
let actual = ethers.utils.id(test.text);
assert.equal(actual, test.expected,
'computes id(' + test.text + ')');
});
});
});
describe('Test Solidity Hash Functions', function() {
type TestCase = {
keccak256: string,
sha256: string,
types: Array<string>,
values: Array<string>
};
const tests: Array<TestCase> = loadTests('solidity-hashes');
function test(funcName: string, testKey: 'keccak256' | 'sha256') {
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it(`computes ${ funcName } correctly`, function() {
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
this.timeout(120000);
tests.forEach((test, index) => {
let actual = (<any>(ethers.utils))['solidity' + funcName](test.types, test.values);
let expected = test[testKey];
assert.equal(actual, expected,
('computes solidity-' + funcName + '(' + JSON.stringify(test.values) + ') - ' + test.types));
});
});
}
test('Keccak256', 'keccak256');
test('Sha256', 'sha256');
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
const testsInvalid = [
"uint0", // number - null length
"uint1", // number - not byte-aligned
"uint08", // number - leading zeros
"uint266", // number - out-of-range
"bytes0", // bytes - null length
"bytes02", // bytes - leading zeros
"bytes33", // bytes - out-of-range
"purple" // invalid type
];
testsInvalid.forEach((type) => {
it(`disallows invalid type "${ type }"`, function() {
assert.throws(() => {
ethers.utils.solidityPack([ type ], [ "0x12" ]);
}, (error: Error) => {
const message = error.message;
return (message.match(/invalid([a-z ]*) type/) && message.indexOf(type) >= 0);
});
});
});
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
});
describe('Test Hash Functions', function() {
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
const tests: Array<TestCase.Hash> = loadTests('hashes');
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
it('computes keccak256 correctly', function() {
this.timeout(120000);
tests.forEach(function(test) {
assert.equal(ethers.utils.keccak256(test.data), test.keccak256, ('Keccak256 - ' + test.data));
});
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it('computes sha2-256 correctly', function() {
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
this.timeout(120000);
tests.forEach(function(test) {
assert.equal(ethers.utils.sha256(test.data), test.sha256, ('SHA256 - ' + test.data));
});
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it('computes sha2-512 correctly', function() {
this.timeout(120000);
tests.forEach(function(test) {
assert.equal(ethers.utils.sha512(test.data), test.sha512, ('SHA512 - ' + test.data));
});
});
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
});
describe('Test Solidity splitSignature', function() {
it('splits a canonical signature', function() {
this.timeout(120000);
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let r = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
let s = '0xcafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7e';
for (let v = 27; v <= 28; v++) {
let signature = ethers.utils.concat([ r, s, [ v ] ]);
let sig = ethers.utils.splitSignature(signature);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.equal(sig.r, r, 'split r correctly');
assert.equal(sig.s, s, 'split s correctly');
assert.equal(sig.v, v, 'split v correctly');
}
});
it('splits a legacy signature', function() {
this.timeout(120000);
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let r = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
let s = '0xcafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7ecafe1a7e';
for (let v = 27; v <= 28; v++) {
let signature = ethers.utils.concat([ r, s, [ v - 27 ] ]);
let sig = ethers.utils.splitSignature(signature);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.equal(sig.r, r, 'split r correctly');
assert.equal(sig.s, s, 'split s correctly');
assert.equal(sig.v, v, 'split v correctly');
}
});
});
describe('Test Base64 coder', function() {
// https://en.wikipedia.org/wiki/Base64#Examples
it('encodes and decodes the example from wikipedia', function() {
this.timeout(120000);
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let decodedText = 'Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.';
let decoded = ethers.utils.toUtf8Bytes(decodedText);
let encoded = 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=';
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.equal(ethers.utils.base64.encode(decoded), encoded, 'encodes to base64 string');
Added string spell-checking to library and fixed discovered typos.
2020-04-22 02:42:25 -04:00
assert.equal(ethers.utils.toUtf8String(ethers.utils.base64.decode(encoded)), decodedText, 'decodes from base64 string');
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
});
});
describe('Test UTF-8 coder', function() {
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
const overlong = ethers.utils.Utf8ErrorReason.OVERLONG;
const utf16Surrogate = ethers.utils.Utf8ErrorReason.UTF16_SURROGATE;
const overrun = ethers.utils.Utf8ErrorReason.OVERRUN;
const missingContinue = ethers.utils.Utf8ErrorReason.MISSING_CONTINUE;
const unexpectedContinue = ethers.utils.Utf8ErrorReason.UNEXPECTED_CONTINUE;
const outOfRange = ethers.utils.Utf8ErrorReason.OUT_OF_RANGE;
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let BadUTF = [
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
// See: https://en.wikipedia.org/wiki/UTF-8#Overlong_encodings
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
{ bytes: [ 0xF0,0x82, 0x82, 0xAC ], reason: overlong, ignored: "", replaced: "\u20ac", name: 'wikipedia overlong encoded Euro sign' },
{ bytes: [ 0xc0, 0x80 ], reason: overlong, ignored: "", replaced: "\u0000", name: '2-byte overlong - 0xc080' },
{ bytes: [ 0xc0, 0xbf ], reason: overlong, ignored: "", replaced: "?", name: '2-byte overlong - 0xc0bf' },
{ bytes: [ 0xc1, 0x80 ], reason: overlong, ignored: "", replaced: "@", name: '2-byte overlong - 0xc180' },
{ bytes: [ 0xc1, 0xbf ], reason: overlong, ignored: "", replaced: "\u007f", name: '2-byte overlong - 0xc1bf' },
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
// Reserved UTF-16 Surrogate halves
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
{ bytes: [ 0xed, 0xa0, 0x80 ], reason: utf16Surrogate, ignored: "", replaced: "\ufffd", name: 'utf-16 surrogate - U+d800' },
{ bytes: [ 0xed, 0xbf, 0xbf ], reason: utf16Surrogate, ignored: "", replaced: "\ufffd", name: 'utf-16 surrogate - U+dfff' },
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
// a leading byte not followed by enough continuation bytes
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
{ bytes: [ 0xdf ], reason: overrun, ignored: "", replaced: "\ufffd", name: 'too short - 2-bytes - 0x00' },
{ bytes: [ 0xe0 ], reason: overrun, ignored: "", replaced: "\ufffd", name: 'too short - 3-bytes' },
{ bytes: [ 0xe0, 0x80 ], reason: overrun, ignored: "", replaced: "\ufffd", name: 'too short - 3-bytes with 1' },
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
{ bytes: [ 0x80 ], reason: unexpectedContinue, ignored: "", replaced: "\ufffd", name: 'unexpected continuation byte' },
{ bytes: [ 0xc2, 0x00 ], reason: missingContinue, ignored: "\u0000", replaced: "\ufffd\u0000", name: 'invalid continuation byte - 0xc200' },
{ bytes: [ 0xc2, 0x40 ], reason: missingContinue, ignored: "@", replaced: "\ufffd@", name: 'invalid continuation byte - 0xc240' },
{ bytes: [ 0xc2, 0xc0 ], reason: missingContinue, ignored: "", replaced: "\ufffd\ufffd", name: 'invalid continuation byte - 0xc2c0' },
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
// Out of range
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
{ bytes: [ 0xf4, 0x90, 0x80, 0x80 ], reason: outOfRange, ignored: "", replaced: "\ufffd", name: 'out of range' },
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
];
BadUTF.forEach(function(test) {
it('toUtf8String - ' + test.name, function() {
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
// Check the string using the ignoreErrors conversion
const ignored = ethers.utils.toUtf8String(test.bytes, ethers.utils.Utf8ErrorFuncs.ignore);
assert.equal(ignored, test.ignored, "ignoring errors matches");
// Check the string using the replaceErrors conversion
const replaced = ethers.utils.toUtf8String(test.bytes, ethers.utils.Utf8ErrorFuncs.replace);
assert.equal(replaced, test.replaced, "replaced errors matches");
// Check the string throws the correct error during conversion
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.throws(function() {
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let result = ethers.utils.toUtf8String(test.bytes);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
console.log('Result', result);
}, function(error: Error) {
Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String.
2020-01-20 19:26:49 -05:00
return (error.message.split(";").pop().split("(")[0].trim() === test.reason)
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
}, test.name);
});
});
it('toUtf8String - random conversions', function() {
this.timeout(200000);
function randomChar(seed: string) {
switch (utils.randomNumber(seed + '-range', 0, 4)) {
case 0:
return String.fromCharCode(utils.randomNumber(seed + '-value', 0, 0x100));
case 1:
return String.fromCharCode(utils.randomNumber(seed + '-value', 0, 0xd800));
case 2:
return String.fromCharCode(utils.randomNumber(seed + '-value', 0xdfff + 1, 0xffff));
case 3:
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let left = utils.randomNumber(seed + '-value', 0xd800, 0xdbff + 1);
let right = utils.randomNumber(seed + '-value', 0xdc00, 0xdfff + 1);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
return String.fromCharCode(left, right);
}
throw new Error('this should not happen');
}
function randomString(seed: string) {
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let length = utils.randomNumber(seed + '-length', 1, 5);
let str = '';
for (let i = 0; i < length; i++) {
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
str += randomChar(seed + '-char-' + i);
}
return str;
}
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
for (let i = 0; i < 100000; i++) {
let seed = 'test-' + String(i);
let str = randomString(seed);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let bytes = ethers.utils.toUtf8Bytes(str)
let str2 = ethers.utils.toUtf8String(bytes);
let escaped = JSON.parse(ethers.utils._toEscapedUtf8String(bytes));
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
Refactoring dist build process.
2020-11-14 17:42:36 -05:00
// assert.ok(Buffer.from(str).equals(Buffer.from(bytes)), 'bytes not generated correctly - ' + bytes)
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.equal(str2, str, 'conversion not reflexive - ' + bytes);
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
assert.equal(escaped, str, 'conversion not reflexive - ' + bytes);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
}
});
});
describe('Test Bytes32String coder', function() {
// @TODO: a LOT more test cases; generated from Solidity
it("encodes an ens name", function() {
Added experimental UTF-8 functions for escaping non-ascii strings.
2019-07-23 00:58:07 -03:00
let str = "ricmoo.firefly.eth";
let bytes32 = ethers.utils.formatBytes32String(str);
let str2 = ethers.utils.parseBytes32String(bytes32);
Initial v5 branch commit.
2019-05-14 18:25:46 -04:00
assert.equal(bytes32, '0x7269636d6f6f2e66697265666c792e6574680000000000000000000000000000', 'formatted correctly');
assert.equal(str2, str, "parsed correctly");
});
});
Full case-folding for IDNA in namehash.
2019-08-02 01:58:42 -04:00
function getHex(value: string): string {
Refactoring dist build process.
2020-11-14 17:42:36 -05:00
return ethers.utils.hexlify(ethers.utils.toUtf8Bytes(value));
Full case-folding for IDNA in namehash.
2019-08-02 01:58:42 -04:00
}
describe("Test nameprep", function() {
const Tests: Array<TestCase.Nameprep> = loadTests("nameprep");
Tests.forEach((test) => {
Updated API in testcases.
2019-11-20 18:31:19 +09:00
// No RTL support yet... These will always fail
if ([
"Surrogate code U+DF42",
"Left-to-right mark U+200E",
"Deprecated U+202A",
"Language tagging character U+E0001",
"Bidi: RandALCat character U+05BE and LCat characters",
"Bidi: RandALCat character U+FD50 and LCat characters",
"Bidi: RandALCat without trailing RandALCat U+0627 U+0031"
].indexOf(test.comment) >= 0) {
return;
}
Full case-folding for IDNA in namehash.
2019-08-02 01:58:42 -04:00
it(test.comment, function() {
let input = ethers.utils.toUtf8String(test.input);
if (test.output) {
let expected = ethers.utils.toUtf8String(test.output)
let actual = ethers.utils.nameprep(input);
assert.equal(actual, expected, `actual("${ getHex(actual) }") !== expected("${ getHex(expected) }")`);
} else {
let ok = true;
let reason = "";
try {
let actual = ethers.utils.nameprep(input);
console.log(actual);
reason = `should has thrown ${ test.rc } - actual("${ getHex(actual) }")`;
ok = false;
} catch (error) {
}
assert.ok(ok, reason);
}
});
});
});
Fixed splitSignature computing wrong v for BytesLike (#700).
2020-01-11 03:34:00 -05:00
describe("Test Signature Manipulation", function() {
const tests: Array<TestCase.SignedTransaction> = loadTests("transactions");
tests.forEach((test) => {
it("autofills partial signatures - " + test.name, function() {
const address = ethers.utils.getAddress(test.accountAddress);
const hash = ethers.utils.keccak256(test.unsignedTransaction);
const data = ethers.utils.RLP.decode(test.signedTransaction);
const s = data.pop(), r = data.pop(), v = parseInt(data.pop().substring(2), 16);
const sig = ethers.utils.splitSignature({ r: r, s: s, v: v });
{
const addr = ethers.utils.recoverAddress(hash, {
r: r, s: s, v: v
});
assert.equal(addr, address, "Using r, s and v");
}
{
const addr = ethers.utils.recoverAddress(hash, {
r: sig.r, _vs: sig._vs
});
assert.equal(addr, address, "Using r, _vs");
}
{
const addr = ethers.utils.recoverAddress(hash, {
r: sig.r, s: sig.s, recoveryParam: sig.recoveryParam
});
assert.equal(addr, address, "Using r, s and recoveryParam");
}
});
});
});
Fixed BigNumber string validation (#935).
2020-07-07 22:18:02 -04:00
describe("BigNumber", function() {
const tests: Array<TestCase.BigNumber> = loadTests("bignumber");
tests.forEach((test) => {
if (test.expectedValue == null) {
it(test.testcase, function() {
assert.throws(() => {
const value = ethers.BigNumber.from(test.value);
console.log("ERROR", value);
}, (error: Error) => {
return true;
});
});
} else {
it(test.testcase, function() {
const value = ethers.BigNumber.from(test.value);
assert.equal(value.toHexString(), test.expectedValue);
const value2 = ethers.BigNumber.from(value)
assert.equal(value2.toHexString(), test.expectedValue);
});
}
});
[
{ value: "0x0", expected: "0x0" },
{ value: "-0x0", expected: "0x0" },
{ value: "0x5", expected: "0x5" },
{ value: "-0x5", expected: "0x5" },
{ value: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", expected: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" },
{ value: "-0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", expected: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" },
{ value: "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", expected: "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" },
{ value: "-0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", expected: "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" },
].forEach((test) => {
it(`absolute value (${ test.value })`, function() {
const value = ethers.BigNumber.from(test.value);
const expected = ethers.BigNumber.from(test.expected);
assert.ok(value.abs().eq(expected));
});
});
Fix BigNumber when passed something with a length property (#1172).
2020-11-25 15:07:34 -05:00
// Fails to create from BN (or any junk with a length) (See: #1172)
it("Fails on junk with a length property", function() {
const junk: any = { negative: 0, words: [ 1000 ], length: 1, red: null };
assert.throws(() => {
const value = ethers.BigNumber.from("100").add(junk);
console.log("ERROR", value);
}, (error: Error) => {
return true;
});
});
Fixed BigNumber string validation (#935).
2020-07-07 22:18:02 -04:00
// @TODO: Add more tests here
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
Add clamping functions to FixedNumber (#1037).
2020-09-10 01:16:28 -04:00
describe("FixedNumber", function() {
{
const Tests = [
{ value: "0.0", expected: "0.0" },
{ value: "-0.0", expected: "0.0" },
{ value: "1.0", expected: "1.0" },
{ value: "1.00", expected: "1.0" },
{ value: "01.00", expected: "1.0" },
{ value: 1, expected: "1.0" },
{ value: "-1.0", expected: "-1.0" },
{ value: "-1.00", expected: "-1.0" },
{ value: "-01.00", expected: "-1.0" },
{ value: -1, expected: "-1.0" },
];
Tests.forEach((test) => {
it (`Create from=${ test.value }`, function() {
const value = ethers.FixedNumber.from(test.value);
assert.equal(value.toString(), test.expected);
});
});
}
{
const Tests = [
{ value: "1.0", round: 1, expected: "1.0" },
{ value: "1.4", round: 1, expected: "1.4" },
{ value: "1.4", round: 2, expected: "1.4" },
{ value: "1.4", round: 0, expected: "1.0" },
{ value: "1.5", round: 0, expected: "2.0" },
{ value: "1.6", round: 0, expected: "2.0" },
{ value: "-1.0", round: 1, expected: "-1.0" },
{ value: "-1.4", round: 1, expected: "-1.4" },
{ value: "-1.4", round: 2, expected: "-1.4" },
{ value: "-1.4", round: 0, expected: "-1.0" },
{ value: "-1.5", round: 0, expected: "-1.0" },
{ value: "-1.6", round: 0, expected: "-2.0" },
{ value: "1.51", round: 1, expected: "1.5" },
{ value: "1.55", round: 1, expected: "1.6" },
];
Tests.forEach((test) => {
it (`Rounding value=${ test.value }, decimals=${ test.round }`, function() {
const value = ethers.FixedNumber.from(test.value).round(test.round);
assert.equal(value.toString(), test.expected);
});
});
}
{
const Tests = [
{ value: "1.0", ceiling: "1.0", floor: "1.0" },
{ value: "1.1", ceiling: "2.0", floor: "1.0" },
{ value: "1.9", ceiling: "2.0", floor: "1.0" },
{ value: "-1.0", ceiling: "-1.0", floor: "-1.0" },
{ value: "-1.1", ceiling: "-1.0", floor: "-2.0" },
{ value: "-1.9", ceiling: "-1.0", floor: "-2.0" },
];
Tests.forEach((test) => {
it (`Clamping value=${ test.value }`, function() {
const value = ethers.FixedNumber.from(test.value);
assert.equal(value.floor().toString(), test.floor);
assert.equal(value.ceiling().toString(), test.ceiling);
});
});
}
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
describe("Logger", function() {
const logger = new ethers.utils.Logger("testing/0.0");
Add testcases for setLogLevel (#947).
2020-07-20 01:43:47 -04:00
it ("setLogLevel", function() {
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.DEBUG);
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.INFO);
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.WARNING);
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.ERROR);
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.OFF);
// Reset back to INFO when done tests
ethers.utils.Logger.setLogLevel(ethers.utils.Logger.levels.INFO);
});
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
it("checkArgumentCount", function() {
logger.checkArgumentCount(3, 3);
});
it("checkArgumentCount - too few", function() {
assert.throws(() => {
logger.checkArgumentCount(1, 3);
}, (error: any) => {
return error.code === ethers.utils.Logger.errors.MISSING_ARGUMENT;
});
});
it("checkArgumentCount - too many", function() {
assert.throws(() => {
logger.checkArgumentCount(3, 1);
}, (error: any) => {
return error.code === ethers.utils.Logger.errors.UNEXPECTED_ARGUMENT;
});
});
});
describe("Base58 Coder", function() {
it("decodes", function() {
Added EIP-712 test cases (#687).
2020-10-18 21:54:21 -04:00
assert.equal(ethers.utils.toUtf8String(ethers.utils.base58.decode("JxF12TrwUP45BMd")), "Hello World");
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
});
it("encodes", function() {
Added EIP-712 test cases (#687).
2020-10-18 21:54:21 -04:00
assert.equal(ethers.utils.base58.encode(ethers.utils.toUtf8Bytes("Hello World")), "JxF12TrwUP45BMd");
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
});
});
Added EIP-712 test cases (#687).
2020-10-18 21:54:21 -04:00
/*
Added tests to help fill out coverage tests.
2020-07-13 07:30:49 -04:00
describe("Web Fetch", function() {
it("fetches JSON", async function() {
const url = "https:/\/api.etherscan.io/api?module=stats&action=ethprice&apikey=9D13ZE7XSBTJ94N9BNJ2MA33VMAY2YPIRB";
const getData = ethers.utils.fetchJson(url)
});
});
*/
Added EIP-712 test cases (#687).
2020-10-18 21:54:21 -04:00
describe("EIP-712", function() {
const tests = loadTests<Array<TestCase.Eip712>>("eip712");
tests.forEach((test) => {
it(`encoding ${ test.name }`, function() {
const encoder = ethers.utils._TypedDataEncoder.from(test.types);
assert.equal(encoder.primaryType, test.primaryType, "instance.primaryType");
assert.equal(encoder.encode(test.data), test.encoded, "instance.encode()");
//console.log(test);
assert.equal(ethers.utils._TypedDataEncoder.getPrimaryType(test.types), test.primaryType, "getPrimaryType");
assert.equal(ethers.utils._TypedDataEncoder.hash(test.domain, test.types, test.data), test.digest, "digest");
});
});
tests.forEach((test) => {
if (!test.privateKey) { return; }
it(`signing ${ test.name }`, async function() {
const wallet = new ethers.Wallet(test.privateKey);
const signature = await wallet._signTypedData(test.domain, test.types, test.data);
assert.equal(signature, test.signature, "signature");
});
});
});
Added EIP-2930 support (#1364).
2021-03-26 16:16:56 -04:00
/*
type EIP2930Test = {
hash: string,
data:
};
*/
function _deepEquals(a: any, b: any, path: string): string {
if (Array.isArray(a)) {
if (!Array.isArray(b)) {
return `{ path }:!isArray(b)`;
}
if (a.length !== b.length) {
return `{ path }:a.length[${ a.length }]!=b.length[${ b.length }]`;
}
for (let i = 0; i < a.length; i++) {
const reason = _deepEquals(a[i], b[i], `${ path }:${ i }`);
if (reason != null) { return reason; }
}
return null;
}
if (a.eq) {
if (!b.eq) { return `${ path }:typeof(b)!=BigNumber`; }
return a.eq(b) ? null: `${ path }:!a.eq(b)`;
}
if (a != null && typeof(a) === "object") {
if (b != null && typeof(b) !== "object") { return `${ path }:typeof(b)!=object`; }
const keys = Object.keys(a), otherKeys = Object.keys(b);
keys.sort();
otherKeys.sort();
if (keys.length !== otherKeys.length) { return `${ path }:keys(a)[${ keys.join(",") }]!=keys(b)[${ otherKeys.join(",") }]`; }
for (const key in a) {
const reason = _deepEquals(a[key], b[key], `${ path }:${ key }`);
if (reason != null) { return reason; }
}
return null;
}
if (a !== b) { return `${ path }[${ a } != ${ b }]`; }
return null;
}
function deepEquals(a: any, b: any): string {
return _deepEquals(a, b, "");
}
describe("EIP-2930", function() {
const Tests = [
{
hash: "0x48bff7b0e603200118a672f7c622ab7d555a28f98938edb8318803eed7ea7395",
data: "0x01f87c030d8465cf89a0825b689432162f3581e88a5f62e8a61892b42c46e2c18f7b8080d7d6940000000000000000000000000000000000000000c080a09659cba42376dbea1433cd6afc9c8ffa38dbeff5408ffdca0ebde6207281a3eca027efbab3e6ed30b088ce0a50533364778e101c9e52acf318daec131da64e7758",
preimage: "0x01f839030d8465cf89a0825b689432162f3581e88a5f62e8a61892b42c46e2c18f7b8080d7d6940000000000000000000000000000000000000000c0",
tx: {
hash: "0x48bff7b0e603200118a672f7c622ab7d555a28f98938edb8318803eed7ea7395",
type: 1,
chainId: 3,
nonce: 13,
gasPrice: ethers.BigNumber.from("0x65cf89a0"),
gasLimit: ethers.BigNumber.from("0x5b68"),
to: "0x32162F3581E88a5f62e8A61892B42C46E2c18f7b",
value: ethers.BigNumber.from("0"),
data: "0x",
accessList: [
{
address: "0x0000000000000000000000000000000000000000",
storageKeys: []
}
],
v: 0,
r: "0x9659cba42376dbea1433cd6afc9c8ffa38dbeff5408ffdca0ebde6207281a3ec",
s: "0x27efbab3e6ed30b088ce0a50533364778e101c9e52acf318daec131da64e7758",
from: "0x32162F3581E88a5f62e8A61892B42C46E2c18f7b",
}
},
{
hash: "0x1675a417e728fd3562d628d06955ef35b913573d9e417eb4e6a209998499c9d3",
data: "0x01f8e2030e8465cf89a08271ac9432162f3581e88a5f62e8a61892b42c46e2c18f7b8080f87cf87a940000000000000000000000000000000000000000f863a0deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefa00000000000111111111122222222223333333333444444444455555555556666a0deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef80a0b0646756f89817d70cdb40aa2ae8b5f43ef65d0926dcf71a7dca5280c93763dfa04d32dbd9a44a2c5639b8434b823938202f75b0a8459f3fcd9f37b2495b7a66a6",
preimage: "0x01f89f030e8465cf89a08271ac9432162f3581e88a5f62e8a61892b42c46e2c18f7b8080f87cf87a940000000000000000000000000000000000000000f863a0deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefa00000000000111111111122222222223333333333444444444455555555556666a0deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
tx: {
hash: "0x1675a417e728fd3562d628d06955ef35b913573d9e417eb4e6a209998499c9d3",
type: 1,
chainId: 3,
nonce: 14,
gasPrice: ethers.BigNumber.from("0x65cf89a0"),
gasLimit: ethers.BigNumber.from("0x71ac"),
to: "0x32162F3581E88a5f62e8A61892B42C46E2c18f7b",
value: ethers.BigNumber.from("0"),
data: "0x",
accessList: [
{
address: "0x0000000000000000000000000000000000000000",
storageKeys: [
"0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
"0x0000000000111111111122222222223333333333444444444455555555556666",
"0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
]
}
],
v: 0,
r: "0xb0646756f89817d70cdb40aa2ae8b5f43ef65d0926dcf71a7dca5280c93763df",
s: "0x4d32dbd9a44a2c5639b8434b823938202f75b0a8459f3fcd9f37b2495b7a66a6",
from: "0x32162F3581E88a5f62e8A61892B42C46E2c18f7b",
}
},
];
Tests.forEach((test) => {
it(`tx:${ test.hash }`, function() {
const tx = ethers.utils.parseTransaction(test.data);
assert.equal(tx.hash, test.hash);
const reason = deepEquals(tx, test.tx);
assert.ok(reason == null, reason);
const preimageData = ethers.utils.serializeTransaction(<any>(test.tx));
assert.equal(preimageData, test.preimage);
const data = ethers.utils.serializeTransaction(<any>(test.tx), test.tx);
assert.equal(data, test.data);
});
});
});
Reference in New Issue Copy Permalink