Merge branch '1.0' of https://github.com/ethereum/web3.js into featur…

…e/exactVersionDependencies

.gitignore

@@ -12,3 +12,4 @@ bower_components
 /bower
 .idea/
 .npm/
+.vscode/

packages/web3-bzz/package.json

@@ -8,7 +8,7 @@
     "main": "src/index.js",
     "dependencies": {
         "got": "7.1.0",
-        "swarm-js": "0.1.35",
+        "swarm-js": "0.1.37",
         "underscore": "1.8.3"
     }
 }

packages/web3-bzz/src/index.js

@@ -65,6 +65,13 @@ Bzz.prototype.setProvider = function(provider) {
         this.currentProvider = provider;
     } else {
         this.currentProvider = null;
+
+        var noProviderError = new Error('No provider set, please set one using bzz.setProvider().');
+
+        this.download = this.upload = this.isAvailable = function(){
+            throw noProviderError;
+        };
+
         return false;
     }
 

packages/web3-eth-abi/src/formatters.js

@@ -62,6 +62,10 @@ var formatInputBytes = function (value) {
         throw new Error('Given parameter bytes has an invalid length: "'+ value + '"');
     }
 
+    if (result.length > 64) {
+        throw new Error('Given parameter bytes is too long: "' + value + '"');
+    }
+
     var l = Math.floor((result.length + 63) / 64);
     result = utils.padRight(result, l * 64);
     return new SolidityParam(result);

packages/web3/index.d.ts

@@ -10,7 +10,7 @@ declare class Web3 {
     Shh: new (provider: t.Provider) => t.Shh
     Bzz: new (provider: t.Provider) => t.Bzz
   }
-  constructor(provider: t.Provider)
+  constructor(provider: t.Provider | string)
   version: string
   BatchRequest: new () => t.BatchRequest
   extend(methods: any): any // TODO

packages/web3/types.d.ts

@@ -112,6 +112,22 @@ export declare interface TransactionReceipt {
   logs?: Array<Log>
   events?: {
     [eventName: string]: EventLog
+  },
+  status: string
+}
+export declare interface EncodedTransaction {
+  raw: string,
+  tx: {
+    nonce: string,
+    gasPrice: string,
+    gas: string,
+    to: string,
+    value: string,
+    input: string,
+    v: string,
+    r: string,
+    s: string,
+    hash: string
   }
 }
 export declare interface BlockHeader {
@@ -265,6 +281,10 @@ export declare interface Contract {
   options: {
     address: string
     jsonInterface: ABIDefinition[]
+    data: string
+    from: string
+    gasPrice: string
+    gas: number
   }
   methods: {
     [fnName: string]: (...args) => TransactionObject<any>
@@ -313,7 +333,7 @@ export declare class Eth {
   }
   accounts: {
     'new'(entropy?: string): Account
-    privateToAccount(privKey: string): Account
+    privateKeyToAccount(privKey: string): Account
     publicToAddress(key: string): string
     signTransaction(tx: Tx, privateKey: string, returnSignature?: boolean, cb?: (err: Error, result: string | Signature) => void): Promise<string> | Signature
     recoverTransaction(signature: string | Signature): string
@@ -376,6 +396,7 @@ export declare class Eth {
   isSyncing(cb?: Callback<boolean>): Promise<boolean>
   net: Net
   personal: Personal
+  signTransaction(tx: Tx, address?: string, cb?: Callback<string>): Promise<EncodedTransaction>
   sendSignedTransaction(data: string, cb?: Callback<string>): PromiEvent<TransactionReceipt>
   sendTransaction(tx: Tx, cb?: Callback<string>): PromiEvent<TransactionReceipt>
   submitWork(nonce: string, powHash: string, digest: string, cb?: Callback<boolean>): Promise<boolean>

test/contract.encodeABI.js

@@ -0,0 +1,108 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Eth = require('../packages/web3-eth');
+var sha3 = require('../packages/web3-utils').sha3;
+var FakeIpcProvider = require('./helpers/FakeIpcProvider');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var Promise = require('bluebird');
+
+var abi = [
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "a",
+                type: "bytes32"
+            },
+            {
+                name: "b",
+                type: "bytes32"
+            }
+        ],
+        name: "takesTwoBytes32",
+        outputs: [
+            {
+                name: "",
+                type: "bytes32"
+            }
+        ],
+        payable: false,
+        type: "function",
+        stateMutability: "view"
+    }
+];
+
+describe('contract', function () {
+    describe('method.encodeABI', function () {
+        it('should handle bytes32 arrays that only contain 1 byte', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(2)), '0x'.concat('b'.repeat(2))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aa00000000000000000000000000000000000000000000000000000000000000',
+                'bb00000000000000000000000000000000000000000000000000000000000000'
+            ].join(''));
+        });
+
+        it('should handle bytes32 arrays that are short 1 byte', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(62)), '0x'.concat('b'.repeat(62))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00',
+                'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00'
+            ].join(''));
+        });
+
+        it('should throw an exception on bytes32 arrays that have an invalid length', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var test = function () {
+                contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(63)), '0x'.concat('b'.repeat(63))).encodeABI();
+            }
+
+            assert.throws(test, 'Given parameter bytes has an invalid length: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+        });
+
+        it('should handle bytes32 arrays that are full', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(64)), '0x'.concat('b'.repeat(64))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+            ].join(''));
+        });
+
+        it('should throw an exception on bytes32 arrays that are too long', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var test = function() {
+                contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(66)), '0x'.concat('b'.repeat(66))).encodeABI();
+            }
+
+            assert.throws(test, 'Given parameter bytes is too long: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+        });
+    });
+});