aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorGreg Hysen <greg.hysen@gmail.com>2018-11-20 02:34:04 +0800
committerGreg Hysen <greg.hysen@gmail.com>2018-11-29 08:38:10 +0800
commit880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13 (patch)
tree908bdc1b8b71704899ec88da9849bf67b12730a7
parent8a8b904a292063d1adb3df0a84023610a3985f7f (diff)
downloaddexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar.gz
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar.bz2
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar.lz
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar.xz
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.tar.zst
dexon-sol-tools-880540f4b8fd8dd7a7f1a93cf7fbcdc17e1fbb13.zip
Fixed issue with decoding negative ints with width < 256
-rw-r--r--packages/utils/src/abi_encoder/data_type.ts4
-rw-r--r--packages/utils/src/abi_encoder/evm_data_types.ts5
-rw-r--r--packages/utils/test/abi_encoder_test.ts475
3 files changed, 246 insertions, 238 deletions
diff --git a/packages/utils/src/abi_encoder/data_type.ts b/packages/utils/src/abi_encoder/data_type.ts
index f5a8087ea..15de12a2f 100644
--- a/packages/utils/src/abi_encoder/data_type.ts
+++ b/packages/utils/src/abi_encoder/data_type.ts
@@ -41,7 +41,8 @@ export abstract class DataType {
}
public decode(calldata: string, rules?: DecodingRules): any {
- const rawCalldata = new RawCalldata(calldata);
+ const rawCalldata = new RawCalldata(calldata, false);
+ console.log(`HERE DUDE ${JSON.stringify(rawCalldata)}`);
const rules_ = rules ? rules : DataType.DEFAULT_DECODING_RULES;
const value = this.generateValue(rawCalldata, rules_);
return value;
@@ -277,6 +278,7 @@ export abstract class MemberDataType extends DataType {
value = [];
_.each(members, (member: DataType, idx: number) => {
let memberValue = member.generateValue(calldata, rules);
+ console.log(`MEMBER VALUE: ${memberValue}`);
(value as any[]).push(memberValue);
});
}
diff --git a/packages/utils/src/abi_encoder/evm_data_types.ts b/packages/utils/src/abi_encoder/evm_data_types.ts
index d024a9bfa..bfb2808da 100644
--- a/packages/utils/src/abi_encoder/evm_data_types.ts
+++ b/packages/utils/src/abi_encoder/evm_data_types.ts
@@ -154,9 +154,8 @@ abstract class Number extends PayloadDataType {
if (this instanceof Int) {
// Check if we're negative
const binBase = 2;
- const paddedValueBin = value.toString(binBase);
- const valueBin = paddedValueBin.slice(paddedValueBin.length - this.width);
- if (valueBin[0].startsWith('1')) {
+ const valueBin = value.toString(2);
+ if (valueBin.length === 256 && valueBin[0].startsWith('1')) {
// Negative
// Step 1/3: Invert binary value
let invertedValueBin = '';
diff --git a/packages/utils/test/abi_encoder_test.ts b/packages/utils/test/abi_encoder_test.ts
index 8add41af6..d2d7b9825 100644
--- a/packages/utils/test/abi_encoder_test.ts
+++ b/packages/utils/test/abi_encoder_test.ts
@@ -13,9 +13,9 @@ describe.only('ABI Encoder', () => {
});
- describe.only('ABI Tests at Method Level', () => {
+ describe('ABI Tests at Method Level', () => {
- it.only('Should reuse duplicated strings in string array', async () => {
+ it('Should reuse duplicated strings in string array', async () => {
const method = new AbiEncoder.Method(AbiSamples.GAbi);
const args = [
@@ -723,237 +723,244 @@ describe.only('ABI Encoder', () => {
expect(calldata).to.be.equal(expectedCalldata);
});
});
- /*
- describe('Array', () => {
- it('sample', async () => {
- const testDataItem = { name: 'testArray', type: 'int[2]' };
- const dataType = new AbiEncoder.SolArray(testDataItem);
- console.log(JSON.stringify(dataType, null, 4));
- console.log('*'.repeat(60));
- dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
- console.log(JSON.stringify(dataType, null, 4));
- const hexValue = dataType.getHexValue();
- console.log('*'.repeat(60));
- console.log(hexValue);
- });
-
- it('sample undefined size', async () => {
- const testDataItem = { name: 'testArray', type: 'int[]' };
- const dataType = new AbiEncoder.SolArray(testDataItem);
- console.log(JSON.stringify(dataType, null, 4));
- console.log('*'.repeat(60));
- dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
- console.log(JSON.stringify(dataType, null, 4));
- const hexValue = dataType.getHexValue();
- console.log('*'.repeat(60));
- console.log(hexValue);
- });
-
- it('sample dynamic types', async () => {
- const testDataItem = { name: 'testArray', type: 'string[]' };
- const dataType = new AbiEncoder.SolArray(testDataItem);
- console.log(JSON.stringify(dataType, null, 4));
- console.log('*'.repeat(60));
- dataType.assignValue(['five', 'six', 'seven']);
- console.log(JSON.stringify(dataType, null, 4));
- const hexValue = dataType.getHexValue();
- console.log('*'.repeat(60));
- console.log(hexValue);
- const calldata = new AbiEncoder.Calldata('0x01020304', 1);
- dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
- console.log('*'.repeat(60));
- console.log(calldata.getHexValue());
- });
- });
-
- describe('Address', () => {
- const testAddressDataItem = { name: 'testAddress', type: 'address' };
- it('Valid Address', async () => {
- const addressDataType = new AbiEncoder.Address(testAddressDataItem);
- addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
- const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
-
- console.log(addressDataType.getHexValue());
- console.log(expectedAbiEncodedAddress);
- expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
- });
- });
-
- describe('Bool', () => {
- const testBoolDataItem = { name: 'testBool', type: 'bool' };
- it('True', async () => {
- const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
- boolDataType.assignValue(true);
- const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
- expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
- });
-
- it('False', async () => {
- const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
- boolDataType.assignValue(false);
- const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
- expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
- });
- });
-
- describe('Integer', () => {
- const testIntDataItem = { name: 'testInt', type: 'int' };
- it('Positive - Base case', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(1));
- const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
- });
-
- it('Positive', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(437829473));
- const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
- });
-
- it('Negative - Base case', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(-1));
- const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
- });
-
- it('Negative', async () => {
- const intDataType = new AbiEncoder.Int(testIntDataItem);
- intDataType.assignValue(new BigNumber(-437829473));
- const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
- expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
- });
-
- // TODO: Add bounds tests + tests for different widths
- });
-
- describe('Unsigned Integer', () => {
- const testIntDataItem = { name: 'testUInt', type: 'uint' };
- it('Lower Bound', async () => {
- const uintDataType = new AbiEncoder.UInt(testIntDataItem);
- uintDataType.assignValue(new BigNumber(0));
- const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
- expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
- });
-
- it('Base Case', async () => {
- const uintDataType = new AbiEncoder.UInt(testIntDataItem);
- uintDataType.assignValue(new BigNumber(1));
- const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
- expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
- });
-
- it('Random value', async () => {
- const uintDataType = new AbiEncoder.UInt(testIntDataItem);
- uintDataType.assignValue(new BigNumber(437829473));
- const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
- expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
- });
-
- // TODO: Add bounds tests + tests for different widths
- });
-
- describe('Static Bytes', () => {
- it('Byte (padded)', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
- byteDataType.assignValue('0x05');
- const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
- expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
- });
-
- it.skip('Byte (no padding)', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-
- // @TODO: This does not catch the Error
- expect(byteDataType.assignValue('0x5')).to.throw();
- });
-
- it('Bytes1', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
- byteDataType.assignValue('0x05');
- const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
- expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
- });
-
- it('Bytes32 (padded)', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
- byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
- const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
- expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
- });
-
- it('Bytes32 (unpadded)', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
- byteDataType.assignValue('0x1a18bf61');
- const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
- expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
- });
-
- it.skip('Bytes32 - Too long', async () => {
- const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
- const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-
- // @TODO: This does not catch the Error
- expect(
- byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
- ).to.throw(
- `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
- );
- });
- });
-
- describe('Bytes (Dynamic)', () => {
- const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
- it('Less than 32 bytes', async () => {
- const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
- bytesDataType.assignValue('0x010203');
- const expectedAbiEncodedBytes =
- '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
-
- expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
- });
-
- it('Greater than 32 bytes', async () => {
- const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
- const testValue = '0x' + '61'.repeat(40);
- bytesDataType.assignValue(testValue);
- const expectedAbiEncodedBytes =
- '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
- expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
- });
-
- // @TODO: Add test for throw on half-byte
- // @TODO: Test with no 0x prefix
- // @TODO: Test with Buffer as input
- });
-
- describe('String', () => {
- const testStringDataItem = { name: 'testString', type: 'string' };
- it('Less than 32 bytes', async () => {
- const stringDataType = new AbiEncoder.SolString(testStringDataItem);
- stringDataType.assignValue('five');
- const expectedAbiEncodedString =
- '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
-
- console.log(stringDataType.getHexValue());
- console.log(expectedAbiEncodedString);
- expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
- });
-
- it('Greater than 32 bytes', async () => {
- const stringDataType = new AbiEncoder.SolString(testStringDataItem);
- const testValue = 'a'.repeat(40);
- stringDataType.assignValue(testValue);
- const expectedAbiEncodedString =
- '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
- expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
- });
+
+ describe.only('Array', () => {
+ it.only('sample', async () => {
+ // Create DataType object
+ const testDataItem = { name: 'testArray', type: 'int[2]' };
+ const dataType = new AbiEncoder.SolArray(testDataItem);
+ // Construct args to be encoded
+ const args = [new BigNumber(5), new BigNumber(6)];
+ // Encode Args and validate result
+ const encodedArgs = dataType.encode(args);
+ const expectedEncodedArgs = '0x00000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006';
+ expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+ // Decode Encoded Args and validate result
+ const decodedArgs = dataType.decode(encodedArgs);
+ const decodedArgsAsJson = JSON.stringify(decodedArgs);
+ const argsAsJson = JSON.stringify(args);
+ expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+ });
+
+ /*
+ it('sample undefined size', async () => {
+ const testDataItem = { name: 'testArray', type: 'int[]' };
+ const dataType = new AbiEncoder.SolArray(testDataItem);
+ console.log(JSON.stringify(dataType, null, 4));
+ console.log('*'.repeat(60));
+ dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
+ console.log(JSON.stringify(dataType, null, 4));
+ const hexValue = dataType.getHexValue();
+ console.log('*'.repeat(60));
+ console.log(hexValue);
+ });
+
+ it('sample dynamic types', async () => {
+ const testDataItem = { name: 'testArray', type: 'string[]' };
+ const dataType = new AbiEncoder.SolArray(testDataItem);
+ console.log(JSON.stringify(dataType, null, 4));
+ console.log('*'.repeat(60));
+ dataType.assignValue(['five', 'six', 'seven']);
+ console.log(JSON.stringify(dataType, null, 4));
+ const hexValue = dataType.getHexValue();
+ console.log('*'.repeat(60));
+ console.log(hexValue);
+ const calldata = new AbiEncoder.Calldata('0x01020304', 1);
+ dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
+ console.log('*'.repeat(60));
+ console.log(calldata.getHexValue());
});*/
+ });
+
+ /*
+ describe('Address', () => {
+ const testAddressDataItem = { name: 'testAddress', type: 'address' };
+ it('Valid Address', async () => {
+ const addressDataType = new AbiEncoder.Address(testAddressDataItem);
+ addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
+ const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
+
+ console.log(addressDataType.getHexValue());
+ console.log(expectedAbiEncodedAddress);
+ expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
+ });
+ });
+
+ describe('Bool', () => {
+ const testBoolDataItem = { name: 'testBool', type: 'bool' };
+ it('True', async () => {
+ const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+ boolDataType.assignValue(true);
+ const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
+ expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+ });
+
+ it('False', async () => {
+ const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+ boolDataType.assignValue(false);
+ const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
+ expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+ });
+ });
+
+ describe('Integer', () => {
+ const testIntDataItem = { name: 'testInt', type: 'int' };
+ it('Positive - Base case', async () => {
+ const intDataType = new AbiEncoder.Int(testIntDataItem);
+ intDataType.assignValue(new BigNumber(1));
+ const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+ expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ });
+
+ it('Positive', async () => {
+ const intDataType = new AbiEncoder.Int(testIntDataItem);
+ intDataType.assignValue(new BigNumber(437829473));
+ const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+ expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ });
+
+ it('Negative - Base case', async () => {
+ const intDataType = new AbiEncoder.Int(testIntDataItem);
+ intDataType.assignValue(new BigNumber(-1));
+ const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+ expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ });
+
+ it('Negative', async () => {
+ const intDataType = new AbiEncoder.Int(testIntDataItem);
+ intDataType.assignValue(new BigNumber(-437829473));
+ const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
+ expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+ });
+
+ // TODO: Add bounds tests + tests for different widths
+ });
+
+ describe('Unsigned Integer', () => {
+ const testIntDataItem = { name: 'testUInt', type: 'uint' };
+ it('Lower Bound', async () => {
+ const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+ uintDataType.assignValue(new BigNumber(0));
+ const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
+ expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+ });
+
+ it('Base Case', async () => {
+ const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+ uintDataType.assignValue(new BigNumber(1));
+ const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+ expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+ });
+
+ it('Random value', async () => {
+ const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+ uintDataType.assignValue(new BigNumber(437829473));
+ const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+ expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+ });
+
+ // TODO: Add bounds tests + tests for different widths
+ });
+
+ describe('Static Bytes', () => {
+ it('Byte (padded)', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+ byteDataType.assignValue('0x05');
+ const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+ expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+ });
+
+ it.skip('Byte (no padding)', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+
+ // @TODO: This does not catch the Error
+ expect(byteDataType.assignValue('0x5')).to.throw();
+ });
+
+ it('Bytes1', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+ byteDataType.assignValue('0x05');
+ const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+ expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+ });
+
+ it('Bytes32 (padded)', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+ byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
+ const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
+ expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+ });
+
+ it('Bytes32 (unpadded)', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+ byteDataType.assignValue('0x1a18bf61');
+ const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
+ expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+ });
+
+ it.skip('Bytes32 - Too long', async () => {
+ const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+ const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+
+ // @TODO: This does not catch the Error
+ expect(
+ byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
+ ).to.throw(
+ `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
+ );
+ });
+ });
+
+ describe('Bytes (Dynamic)', () => {
+ const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
+ it('Less than 32 bytes', async () => {
+ const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+ bytesDataType.assignValue('0x010203');
+ const expectedAbiEncodedBytes =
+ '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
+
+ expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+ });
+
+ it('Greater than 32 bytes', async () => {
+ const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+ const testValue = '0x' + '61'.repeat(40);
+ bytesDataType.assignValue(testValue);
+ const expectedAbiEncodedBytes =
+ '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+ expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+ });
+
+ // @TODO: Add test for throw on half-byte
+ // @TODO: Test with no 0x prefix
+ // @TODO: Test with Buffer as input
+ });
+
+ describe('String', () => {
+ const testStringDataItem = { name: 'testString', type: 'string' };
+ it('Less than 32 bytes', async () => {
+ const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+ stringDataType.assignValue('five');
+ const expectedAbiEncodedString =
+ '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
+
+ console.log(stringDataType.getHexValue());
+ console.log(expectedAbiEncodedString);
+ expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+ });
+
+ it('Greater than 32 bytes', async () => {
+ const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+ const testValue = 'a'.repeat(40);
+ stringDataType.assignValue(testValue);
+ const expectedAbiEncodedString =
+ '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+ expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+ });
+ });*/
});