[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,
+ 16
)
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
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,
+ 16
)
const r = Buffer.from('99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9', 'hex')
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()
+ })
+ 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
+ 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')
+ )
+ )
+ st.end()
+ })
+ 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')
+ 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')
+ )
+ )
+
+ const chainIDNumber = parseInt(chainIDBuffer.toString('hex'), 16)
+ const vNumber = parseInt(vBuffer.toString('hex'), 16)
+ 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() {
- assert.equal(
- toRpcSig(27, r, s),
- '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca661b',
- )
- assert.deepEqual(
- fromRpcSig(
- '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca661b',
- ),
- {
- v: 27,
- r: r,
- s: s,
- },
- )
- assert.deepEqual(
- fromRpcSig(
- '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca6600',
+ t.test('should return hex strings that the RPC can use', function(st) {
+ const sig =
+ '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca661b'
+ st.equal(toRpcSig(27, r, s), sig)
+ st.deepEqual(fromRpcSig(sig), {
+ v: 27,
+ r,
+ s
+ })
+ st.end()
+ })
+
+ 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
+ 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,
+ s,
+ '0x' + intToBuffer(chainId).toString('hex')
),
- {
- v: 27,
- r: r,
- s: s,
- },
+ sig
)
+ st.deepEqual(fromRpcSig(sig), {
+ v,
+ r,
+ s
+ })
+ st.end()
})
- it('should throw on invalid length', function() {
- assert.throws(function() {
+ 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)
+ st.throws(function() {
+ toRpcSig(vNumber, r, s, chainIDNumber)
+ })
+ st.end()
+ }
+ )
+
+ t.test('should throw on shorter length', function(st) {
+ st.throws(function() {
fromRpcSig('')
})
- assert.throws(function() {
+ st.throws(function() {
fromRpcSig(
- '0x99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca660042',
+ '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',
+ '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
new file mode 100644
index 00000000..0b2322ed
--- /dev/null
+++ b/test/types.spec.ts
@@ -0,0 +1,124 @@
+import tape from 'tape'
+import {
+ BN,
+ toType,
+ TypeOutput,
+ intToBuffer,
+ bufferToHex,
+ intToHex,
+ bnToHex,
+ toBuffer
+} from '../src'
+
+tape('toType', function(t) {
+ t.test('from Number', function(st) {
+ const num = 1000
+ st.test('should convert to Number', function(st) {
+ const result = toType(num, TypeOutput.Number)
+ st.strictEqual(result, num)
+ st.end()
+ })
+ st.test('should convert to BN', function(st) {
+ const result = toType(num, TypeOutput.BN)
+ st.ok(result.eq(new BN(num)))
+ st.end()
+ })
+ st.test('should convert to Buffer', function(st) {
+ const result = toType(num, TypeOutput.Buffer)
+ st.ok(result.equals(intToBuffer(num)))
+ st.end()
+ })
+ st.test('should convert to PrefixedHexString', function(st) {
+ const result = toType(num, TypeOutput.PrefixedHexString)
+ 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()
+ })
+ })
+ t.test('from BN', function(st) {
+ const num = new BN(1000)
+ st.test('should convert to Number', function(st) {
+ const result = toType(num, TypeOutput.Number)
+ st.strictEqual(result, num.toNumber())
+ st.end()
+ })
+ st.test('should convert to BN', function(st) {
+ const result = toType(num, TypeOutput.BN)
+ st.ok(result.eq(num))
+ st.end()
+ })
+ st.test('should convert to Buffer', function(st) {
+ const result = toType(num, TypeOutput.Buffer)
+ st.ok(result.equals(num.toArrayLike(Buffer)))
+ st.end()
+ })
+ st.test('should convert to PrefixedHexString', function(st) {
+ const result = toType(num, TypeOutput.PrefixedHexString)
+ 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)
+ }, /^Error: The provided number is greater than MAX_SAFE_INTEGER \(please use an alternative output type\)$/)
+ st.end()
+ }
+ )
+ })
+ t.test('from Buffer', function(st) {
+ const num = intToBuffer(1000)
+ st.test('should convert to Number', function(st) {
+ const result = toType(num, TypeOutput.Number)
+ st.ok(intToBuffer(result).equals(num))
+ st.end()
+ })
+ st.test('should convert to BN', function(st) {
+ const result = toType(num, TypeOutput.BN)
+ st.ok(result.eq(new BN(num)))
+ st.end()
+ })
+ st.test('should convert to Buffer', function(st) {
+ const result = toType(num, TypeOutput.Buffer)
+ st.ok(result.equals(num))
+ st.end()
+ })
+ st.test('should convert to PrefixedHexString', function(st) {
+ const result = toType(num, TypeOutput.PrefixedHexString)
+ st.strictEqual(result, bufferToHex(num))
+ st.end()
+ })
+ })
+ t.test('from HexPrefixedString', function(st) {
+ const num = intToHex(1000)
+ st.test('should convert to Number', function(st) {
+ const result = toType(num, TypeOutput.Number)
+ st.strictEqual(intToHex(result), num)
+ st.end()
+ })
+ st.test('should convert to BN', function(st) {
+ const result = toType(num, TypeOutput.BN)
+ st.strictEqual(bnToHex(result), num)
+ st.end()
+ })
+ st.test('should convert to Buffer', function(st) {
+ const result = toType(num, TypeOutput.Buffer)
+ 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()
+ })
+ })
+})
diff --git a/tsconfig.json b/tsconfig.json
index ddbd8a97..ed3b4809 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,4 +1,4 @@
{
- "extends": "@ethereumjs/config-tsc",
+ "extends": "@ethereumjs/config-typescript",
"include": ["src/**/*.ts", "test/**/*.ts"]
}
diff --git a/tsconfig.prod.json b/tsconfig.prod.json
index 37770820..31187a41 100644
--- a/tsconfig.prod.json
+++ b/tsconfig.prod.json
@@ -1,7 +1,7 @@
{
"extends": "./tsconfig.json",
"compilerOptions": {
- "outDir": "./dist"
+ "outDir": "./dist",
},
"include": ["src/**/*.ts"]
}
diff --git a/tslint.json b/tslint.json
deleted file mode 100644
index 2ba21c41..00000000
--- a/tslint.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
- "extends": "@ethereumjs/config-tslint"
-}
diff --git a/typedoc.js b/typedoc.js
index 3bf7fa03..c8e893a9 100644
--- a/typedoc.js
+++ b/typedoc.js
@@ -5,8 +5,8 @@ module.exports = {
plugin: 'typedoc-plugin-markdown',
readme: 'none',
gitRevision: 'master',
- exclude: '**/*+(index|.spec|.e2e).ts',
+ exclude: ['src/index.ts', 'test/*.ts'],
excludeNotExported: true,
- // excludePrivate: true,
- // excludeProtected: true,
+ excludePrivate: true,
+ excludeProtected: true,
}
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
+
+