[0, 1, 2, 3, 4]) as Buffer)
} catch (err) {
- assert(err.message.includes('This method only supports Buffer'))
+ st.ok(err.message.includes('This method only supports Buffer'))
}
+ st.end()
})
})
-describe('isValidSignature', function() {
- it('should fail on an invalid signature (shorter r))', function() {
+tape('isValidSignature', function(t) {
+ t.test('should fail on an invalid signature (shorter r))', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1ab', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
- assert.equal(isValidSignature(27, r, s), false)
+ st.notOk(isValidSignature(27, r, s))
+ st.end()
})
- it('should fail on an invalid signature (shorter s))', function() {
+ t.test('should fail on an invalid signature (shorter s))', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca', 'hex')
- assert.equal(isValidSignature(27, r, s), false)
+ st.notOk(isValidSignature(27, r, s))
+ st.end()
})
- it('should fail on an invalid signature (v = 21)', function() {
+ t.test('should fail on an invalid signature (v = 21)', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
- assert.equal(isValidSignature(21, r, s), false)
+ st.notOk(isValidSignature(21, r, s))
+ st.end()
})
- it('should fail on an invalid signature (v = 29)', function() {
+ t.test('should fail on an invalid signature (v = 29)', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
- assert.equal(isValidSignature(29, r, s), false)
+ st.notOk(isValidSignature(29, r, s))
+ st.end()
})
- it('should fail when on homestead and s > secp256k1n/2', function() {
+ t.test('should fail when on homestead and s > secp256k1n/2', function(st) {
const SECP256K1_N_DIV_2 = new BN(
'7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0',
16
@@ -263,9 +288,10 @@ describe('isValidSignature', function() {
const s = Buffer.from(SECP256K1_N_DIV_2.add(new BN('1', 16)).toString(16), 'hex')
const v = 27
- assert.equal(isValidSignature(v, r, s, true), false)
+ st.notOk(isValidSignature(v, r, s, true))
+ st.end()
})
- it('should not fail when not on homestead but s > secp256k1n/2', function() {
+ t.test('should not fail when not on homestead but s > secp256k1n/2', function(st) {
const SECP256K1_N_DIV_2 = new BN(
'7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0',
16
@@ -275,93 +301,97 @@ describe('isValidSignature', function() {
const s = Buffer.from(SECP256K1_N_DIV_2.add(new BN('1', 16)).toString(16), 'hex')
const v = 27
- assert.equal(isValidSignature(v, r, s, false), true)
+ st.ok(isValidSignature(v, r, s, false))
+ st.end()
})
- it('should work otherwise', function() {
+ t.test('should work otherwise', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
const v = 27
- assert.equal(isValidSignature(v, r, s), true)
+ st.ok(isValidSignature(v, r, s))
+ st.end()
})
- it('should work otherwise(chainId=3)', function() {
+ t.test('should work otherwise (chainId=3)', function(st) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
const v = 41
- assert.equal(isValidSignature(v, r, s, false, chainId), true)
+ st.ok(isValidSignature(v, r, s, false, chainId))
+ st.end()
})
- it('should work otherwise(chainId=150)', function() {
+ t.test('should work otherwise (chainId=150)', function(st) {
const chainId = 150
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
const v = chainId * 2 + 35
- assert.equal(isValidSignature(v, r, s, false, chainId), true)
- assert.equal(isValidSignature(intToBuffer(v), r, s, false, intToBuffer(chainId)), true)
- assert.equal(isValidSignature(new BN(v), r, s, false, new BN(chainId)), true)
- assert.equal(
+ st.ok(isValidSignature(v, r, s, false, chainId))
+ st.ok(isValidSignature(intToBuffer(v), r, s, false, intToBuffer(chainId)))
+ st.ok(isValidSignature(new BN(v), r, s, false, new BN(chainId)))
+ st.ok(
isValidSignature(
'0x' + intToBuffer(v).toString('hex'),
r,
s,
false,
'0x' + intToBuffer(chainId).toString('hex')
- ),
- true
+ )
)
+ st.end()
})
- it('should work otherwise(chainId larger than MAX_INTEGER)', function() {
+ t.test('should work otherwise (chainId larger than MAX_INTEGER)', function(st) {
const r = Buffer.from('ec212841e0b7aaffc3b3e33a08adf32fa07159e856ef23db85175a4f6d71dc0f', 'hex')
const s = Buffer.from('4b8e02b96b94064a5aa2f8d72bd0040616ba8e482a5dd96422e38c9a4611f8d5', 'hex')
const vBuffer = Buffer.from('f2ded8deec6714', 'hex')
const chainIDBuffer = Buffer.from('796f6c6f763378', 'hex')
- assert.equal(isValidSignature(vBuffer, r, s, false, chainIDBuffer), true)
- assert.equal(isValidSignature(new BN(vBuffer), r, s, false, new BN(chainIDBuffer)), true)
- assert.equal(
+ st.ok(isValidSignature(vBuffer, r, s, false, chainIDBuffer))
+ st.ok(isValidSignature(new BN(vBuffer), r, s, false, new BN(chainIDBuffer)))
+ st.ok(
isValidSignature(
'0x' + vBuffer.toString('hex'),
r,
s,
false,
'0x' + chainIDBuffer.toString('hex')
- ),
- true
+ )
)
const chainIDNumber = parseInt(chainIDBuffer.toString('hex'), 16)
const vNumber = parseInt(vBuffer.toString('hex'), 16)
- assert.throws(() => {
+ st.throws(() => {
// If we would use numbers for the `v` and `chainId` parameters, then it should throw.
// (The numbers are too high to perform arithmetic on)
isValidSignature(vNumber, r, s, false, chainIDNumber)
})
+ st.end()
})
// FIXME: add homestead test
})
-describe('message sig', function() {
+tape('message sig', function(t) {
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
const s = Buffer.from('129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66', 'hex')
- it('should return hex strings that the RPC can use', function() {
+ t.test('should return hex strings that the RPC can use', function(st) {
const sig =
'0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca661b'
- assert.equal(toRpcSig(27, r, s), sig)
- assert.deepEqual(fromRpcSig(sig), {
+ st.equal(toRpcSig(27, r, s), sig)
+ st.deepEqual(fromRpcSig(sig), {
v: 27,
r,
s
})
+ st.end()
})
- it('should return hex strings that the RPC can use (chainId=150)', function() {
+ t.test('should return hex strings that the RPC can use (chainId=150)', function(st) {
const sig =
'0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66014f'
const chainId = 150
const v = chainId * 2 + 35
- assert.equal(toRpcSig(v, r, s, chainId), sig)
- assert.equal(toRpcSig(intToBuffer(v), r, s, intToBuffer(chainId)), sig)
- assert.equal(toRpcSig(new BN(v), r, s, new BN(chainId)), sig)
- assert.equal(
+ st.equal(toRpcSig(v, r, s, chainId), sig)
+ st.equal(toRpcSig(intToBuffer(v), r, s, intToBuffer(chainId)), sig)
+ st.equal(toRpcSig(new BN(v), r, s, new BN(chainId)), sig)
+ st.equal(
toRpcSig(
'0x' + intToBuffer(v).toString('hex'),
r,
@@ -370,53 +400,61 @@ describe('message sig', function() {
),
sig
)
- assert.deepEqual(fromRpcSig(sig), {
+ st.deepEqual(fromRpcSig(sig), {
v,
r,
s
})
+ st.end()
})
- it('should return hex strings that the RPC can use (chainId larger than MAX_SAFE_INTEGER)', function() {
- const sig =
- '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66f2ded8deec6714'
- const chainIDBuffer = Buffer.from('796f6c6f763378', 'hex')
- const vBuffer = Buffer.from('f2ded8deec6714', 'hex')
- assert.equal(toRpcSig(vBuffer, r, s, chainIDBuffer), sig)
- assert.equal(toRpcSig(new BN(vBuffer), r, s, new BN(chainIDBuffer)), sig)
- assert.equal(
- toRpcSig('0x' + vBuffer.toString('hex'), r, s, '0x' + chainIDBuffer.toString('hex')),
- sig
- )
+ t.test(
+ 'should return hex strings that the RPC can use (chainId larger than MAX_SAFE_INTEGER)',
+ function(st) {
+ const sig =
+ '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66f2ded8deec6714'
+ const chainIDBuffer = Buffer.from('796f6c6f763378', 'hex')
+ const vBuffer = Buffer.from('f2ded8deec6714', 'hex')
+ st.equal(toRpcSig(vBuffer, r, s, chainIDBuffer), sig)
+ st.equal(toRpcSig(new BN(vBuffer), r, s, new BN(chainIDBuffer)), sig)
+ st.equal(
+ toRpcSig('0x' + vBuffer.toString('hex'), r, s, '0x' + chainIDBuffer.toString('hex')),
+ sig
+ )
- const chainIDNumber = parseInt(chainIDBuffer.toString('hex'), 16)
- const vNumber = parseInt(vBuffer.toString('hex'), 16)
- assert.throws(function() {
- toRpcSig(vNumber, r, s, chainIDNumber)
- })
- })
+ const chainIDNumber = parseInt(chainIDBuffer.toString('hex'), 16)
+ const vNumber = parseInt(vBuffer.toString('hex'), 16)
+ st.throws(function() {
+ toRpcSig(vNumber, r, s, chainIDNumber)
+ })
+ st.end()
+ }
+ )
- it('should throw on shorter length', function() {
- assert.throws(function() {
+ t.test('should throw on shorter length', function(st) {
+ st.throws(function() {
fromRpcSig('')
})
- assert.throws(function() {
+ st.throws(function() {
fromRpcSig(
'0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca'
)
})
+ st.end()
})
- it('pad short r and s values', function() {
- assert.equal(
+ t.test('pad short r and s values', function(st) {
+ st.equal(
toRpcSig(27, r.slice(20), s.slice(20)),
'0x00000000000000000000000000000000000000004a1579cf389ef88b20a1abe90000000000000000000000000000000000000000326fa689f228040429e3ca661b'
)
+ st.end()
})
- it('should throw on invalid v value', function() {
- assert.throws(function() {
+ t.test('should throw on invalid v value', function(st) {
+ st.throws(function() {
toRpcSig(1, r, s)
})
+ st.end()
})
})
diff --git a/test/types.spec.ts b/test/types.spec.ts
index 16ae5f3..0b2322e 100644
--- a/test/types.spec.ts
+++ b/test/types.spec.ts
@@ -1,112 +1,124 @@
-import assert from 'assert'
-import BN from 'bn.js'
-import { toType, TypeOutput, intToBuffer, bufferToHex, intToHex, bnToHex, toBuffer } from '../src'
+import tape from 'tape'
+import {
+ BN,
+ toType,
+ TypeOutput,
+ intToBuffer,
+ bufferToHex,
+ intToHex,
+ bnToHex,
+ toBuffer
+} from '../src'
-describe('toType', function() {
- describe('from Number', function() {
+tape('toType', function(t) {
+ t.test('from Number', function(st) {
const num = 1000
- it('should convert to Number', function() {
+ st.test('should convert to Number', function(st) {
const result = toType(num, TypeOutput.Number)
- assert.strictEqual(result, num)
+ st.strictEqual(result, num)
+ st.end()
})
- it('should convert to BN', function() {
+ st.test('should convert to BN', function(st) {
const result = toType(num, TypeOutput.BN)
- assert.ok(result.eq(new BN(num)))
+ st.ok(result.eq(new BN(num)))
+ st.end()
})
- it('should convert to Buffer', function() {
+ st.test('should convert to Buffer', function(st) {
const result = toType(num, TypeOutput.Buffer)
- assert.ok(result.equals(intToBuffer(num)))
+ st.ok(result.equals(intToBuffer(num)))
+ st.end()
})
- it('should convert to PrefixedHexString', function() {
+ st.test('should convert to PrefixedHexString', function(st) {
const result = toType(num, TypeOutput.PrefixedHexString)
- assert.strictEqual(result, bufferToHex(new BN(num).toArrayLike(Buffer)))
- })
- it('should throw an error if greater than MAX_SAFE_INTEGER', function() {
- assert.throws(
- () => {
- const num = Number.MAX_SAFE_INTEGER + 1
- toType(num, TypeOutput.BN)
- },
- {
- message:
- 'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)'
- }
- )
+ st.strictEqual(result, bufferToHex(new BN(num).toArrayLike(Buffer)))
+ st.end()
+ })
+ st.test('should throw an error if greater than MAX_SAFE_INTEGER', function(st) {
+ st.throws(() => {
+ const num = Number.MAX_SAFE_INTEGER + 1
+ toType(num, TypeOutput.BN)
+ }, /^Error: The provided number is greater than MAX_SAFE_INTEGER \(please use an alternative input type\)$/)
+ st.end()
})
})
- describe('from BN', function() {
+ t.test('from BN', function(st) {
const num = new BN(1000)
- it('should convert to Number', function() {
+ st.test('should convert to Number', function(st) {
const result = toType(num, TypeOutput.Number)
- assert.strictEqual(result, num.toNumber())
+ st.strictEqual(result, num.toNumber())
+ st.end()
})
- it('should convert to BN', function() {
+ st.test('should convert to BN', function(st) {
const result = toType(num, TypeOutput.BN)
- assert.ok(result.eq(num))
+ st.ok(result.eq(num))
+ st.end()
})
- it('should convert to Buffer', function() {
+ st.test('should convert to Buffer', function(st) {
const result = toType(num, TypeOutput.Buffer)
- assert.ok(result.equals(num.toArrayLike(Buffer)))
+ st.ok(result.equals(num.toArrayLike(Buffer)))
+ st.end()
})
- it('should convert to PrefixedHexString', function() {
+ st.test('should convert to PrefixedHexString', function(st) {
const result = toType(num, TypeOutput.PrefixedHexString)
- assert.strictEqual(result, bufferToHex(num.toArrayLike(Buffer)))
- })
- it('should throw an error if converting to Number and greater than MAX_SAFE_INTEGER', function() {
- const num = new BN(Number.MAX_SAFE_INTEGER).addn(1)
- assert.throws(
- () => {
+ st.strictEqual(result, bufferToHex(num.toArrayLike(Buffer)))
+ st.end()
+ })
+ st.test(
+ 'should throw an error if converting to Number and greater than MAX_SAFE_INTEGER',
+ function(st) {
+ const num = new BN(Number.MAX_SAFE_INTEGER).addn(1)
+ st.throws(() => {
toType(num, TypeOutput.Number)
- },
- {
- message:
- 'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative output type)'
- }
- )
- })
+ }, /^Error: The provided number is greater than MAX_SAFE_INTEGER \(please use an alternative output type\)$/)
+ st.end()
+ }
+ )
})
- describe('from Buffer', function() {
+ t.test('from Buffer', function(st) {
const num = intToBuffer(1000)
- it('should convert to Number', function() {
+ st.test('should convert to Number', function(st) {
const result = toType(num, TypeOutput.Number)
- assert.ok(intToBuffer(result).equals(num))
+ st.ok(intToBuffer(result).equals(num))
+ st.end()
})
- it('should convert to BN', function() {
+ st.test('should convert to BN', function(st) {
const result = toType(num, TypeOutput.BN)
- assert.ok(result.eq(new BN(num)))
+ st.ok(result.eq(new BN(num)))
+ st.end()
})
- it('should convert to Buffer', function() {
+ st.test('should convert to Buffer', function(st) {
const result = toType(num, TypeOutput.Buffer)
- assert.ok(result.equals(num))
+ st.ok(result.equals(num))
+ st.end()
})
- it('should convert to PrefixedHexString', function() {
+ st.test('should convert to PrefixedHexString', function(st) {
const result = toType(num, TypeOutput.PrefixedHexString)
- assert.strictEqual(result, bufferToHex(num))
+ st.strictEqual(result, bufferToHex(num))
+ st.end()
})
})
- describe('from HexPrefixedString', function() {
+ t.test('from HexPrefixedString', function(st) {
const num = intToHex(1000)
- it('should convert to Number', function() {
+ st.test('should convert to Number', function(st) {
const result = toType(num, TypeOutput.Number)
- assert.strictEqual(intToHex(result), num)
+ st.strictEqual(intToHex(result), num)
+ st.end()
})
- it('should convert to BN', function() {
+ st.test('should convert to BN', function(st) {
const result = toType(num, TypeOutput.BN)
- assert.strictEqual(bnToHex(result), num)
+ st.strictEqual(bnToHex(result), num)
+ st.end()
})
- it('should convert to Buffer', function() {
+ st.test('should convert to Buffer', function(st) {
const result = toType(num, TypeOutput.Buffer)
- assert.ok(result.equals(toBuffer(num)))
- })
- it('should throw an error if is not 0x-prefixed', function() {
- assert.throws(
- () => {
- toType('1', TypeOutput.Number)
- },
- {
- message: 'A string must be provided with a 0x-prefix, given: 1'
- }
- )
+ st.ok(result.equals(toBuffer(num)))
+ st.end()
+ })
+ st.test('should throw an error if is not 0x-prefixed', function(st) {
+ st.throws(() => {
+ toType('1', TypeOutput.Number)
+ }, /^Error: A string must be provided with a 0x-prefix, given: 1$/)
+ st.end()
})
})
})
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy
+
+