subtly
10 years ago
102 changed files with 3040 additions and 1352 deletions
@ -0,0 +1,12 @@ |
|||
#include "CanonBlockChain.h" |
|||
|
|||
CanonBlockChain::CanonBlockChain() |
|||
{ |
|||
|
|||
} |
|||
|
|||
CanonBlockChain::~CanonBlockChain() |
|||
{ |
|||
|
|||
} |
|||
|
|||
@ -0,0 +1,12 @@ |
|||
#ifndef CANONBLOCKCHAIN_H |
|||
#define CANONBLOCKCHAIN_H |
|||
|
|||
|
|||
class CanonBlockChain |
|||
{ |
|||
public: |
|||
CanonBlockChain(); |
|||
~CanonBlockChain(); |
|||
}; |
|||
|
|||
#endif // CANONBLOCKCHAIN_H
|
|||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,66 @@ |
|||
<!doctype> |
|||
<html> |
|||
<head> |
|||
<script type="text/javascript" src="js/bignumber.js/bignumber.min.js"></script> |
|||
<script type="text/javascript" src="../dist/ethereum.js"></script> |
|||
<script type="text/javascript"> |
|||
var web3 = require('web3'); |
|||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
|||
|
|||
var source = "" + |
|||
"contract Contract { " + |
|||
" event Incremented(bool indexed odd, uint x); " + |
|||
" function Contract() { " + |
|||
" x = 69; " + |
|||
" } " + |
|||
" function inc() { " + |
|||
" ++x; " + |
|||
" Incremented(x % 2 == 1, x); " + |
|||
" } " + |
|||
" uint x; " + |
|||
"}"; |
|||
|
|||
var desc = [{ |
|||
"type":"event", |
|||
"name":"Incremented", |
|||
"inputs": [{"name":"odd","type":"bool","indexed":true},{"name":"x","type":"uint","indexed":false}], |
|||
}, { |
|||
"type":"function", |
|||
"name":"inc", |
|||
"inputs": [], |
|||
"outputs": [] |
|||
}]; |
|||
|
|||
var address; |
|||
var contract; |
|||
|
|||
var update = function (x) { |
|||
document.getElementById('result').innerText = JSON.stringify(x); |
|||
}; |
|||
|
|||
var createContract = function () { |
|||
address = web3.eth.transact({code: web3.eth.solidity(source)}); |
|||
contract = web3.eth.contract(address, desc); |
|||
contract.Incremented({odd: true}).changed(update); |
|||
|
|||
}; |
|||
|
|||
var callContract = function () { |
|||
contract.call().inc(); |
|||
}; |
|||
|
|||
|
|||
</script> |
|||
</head> |
|||
|
|||
<body> |
|||
<div> |
|||
<button type="button" onClick="createContract();">create contract</button> |
|||
</div> |
|||
<div> |
|||
<button type="button" onClick="callContract();">test1</button> |
|||
</div> |
|||
<div id="result"> |
|||
</div> |
|||
</body> |
|||
</html> |
|||
@ -0,0 +1,65 @@ |
|||
/* |
|||
This file is part of ethereum.js. |
|||
|
|||
ethereum.js is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
ethereum.js is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file jsonrpc.js |
|||
* @authors: |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
var messageId = 1; |
|||
|
|||
/// Should be called to valid json create payload object
|
|||
/// @param method of jsonrpc call, required
|
|||
/// @param params, an array of method params, optional
|
|||
/// @returns valid jsonrpc payload object
|
|||
var toPayload = function (method, params) { |
|||
if (!method) |
|||
console.error('jsonrpc method should be specified!'); |
|||
|
|||
return { |
|||
jsonrpc: '2.0', |
|||
method: method, |
|||
params: params || [], |
|||
id: messageId++ |
|||
}; |
|||
}; |
|||
|
|||
/// Should be called to check if jsonrpc response is valid
|
|||
/// @returns true if response is valid, otherwise false
|
|||
var isValidResponse = function (response) { |
|||
return !!response && |
|||
!response.error && |
|||
response.jsonrpc === '2.0' && |
|||
typeof response.id === 'number' && |
|||
response.result !== undefined; // only undefined is not valid json object
|
|||
}; |
|||
|
|||
/// Should be called to create batch payload object
|
|||
/// @param messages, an array of objects with method (required) and params (optional) fields
|
|||
var toBatchPayload = function (messages) { |
|||
return messages.map(function (message) { |
|||
return toPayload(message.method, message.params); |
|||
}); |
|||
}; |
|||
|
|||
module.exports = { |
|||
toPayload: toPayload, |
|||
isValidResponse: isValidResponse, |
|||
toBatchPayload: toBatchPayload |
|||
}; |
|||
|
|||
|
|||
@ -0,0 +1,461 @@ |
|||
var assert = require('assert'); |
|||
var BigNumber = require('bignumber.js'); |
|||
var abi = require('../lib/abi.js'); |
|||
var clone = function (object) { return JSON.parse(JSON.stringify(object)); }; |
|||
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "function", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
], |
|||
"outputs": [ |
|||
{ |
|||
"name": "d", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
describe('abi', function() { |
|||
describe('outputParser', function() { |
|||
it('should parse output string', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: "string" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
|||
'hello' |
|||
); |
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[0], |
|||
'world' |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse output uint', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output uint256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output uint128', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint128' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output int', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output int256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output int128', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int128' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output hash', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output hash256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output hash160', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash160' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
// TODO shouldnt' the expected hash be shorter?
|
|||
}); |
|||
|
|||
it('should parse output address', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'address' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output bool', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'bool' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false); |
|||
|
|||
|
|||
}); |
|||
|
|||
it('should parse output real', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'real' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1); |
|||
|
|||
}); |
|||
|
|||
it('should parse output ureal', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'ureal' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); |
|||
|
|||
}); |
|||
|
|||
|
|||
it('should parse multiple output strings', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: "string" }, |
|||
{ type: "string" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[0], |
|||
'hello' |
|||
); |
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[1], |
|||
'world' |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should use proper method name', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].name = 'helloworld(int)'; |
|||
d[0].outputs = [ |
|||
{ type: "int" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
|
|||
}); |
|||
|
|||
|
|||
it('should parse multiple methods', function () { |
|||
|
|||
// given
|
|||
var d = [{ |
|||
name: "test", |
|||
type: "function", |
|||
inputs: [{ type: "int" }], |
|||
outputs: [{ type: "int" }] |
|||
},{ |
|||
name: "test2", |
|||
type: "function", |
|||
inputs: [{ type: "string" }], |
|||
outputs: [{ type: "string" }] |
|||
}]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
//then
|
|||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test2("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
|||
"hello" |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse output array', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'int[]' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000002" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000006")[0][0], |
|||
5 |
|||
); |
|||
assert.equal(parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000002" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000006")[0][1], |
|||
6 |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse 0x value', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'int' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x")[0], 0); |
|||
|
|||
}); |
|||
|
|||
it('should parse 0x value', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'uint' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x")[0], 0); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
}); |
|||
|
|||
@ -0,0 +1,125 @@ |
|||
var assert = require('assert'); |
|||
var event = require('../lib/event.js'); |
|||
var f = require('../lib/formatters.js'); |
|||
|
|||
describe('event', function () { |
|||
describe('inputParser', function () { |
|||
it('should create basic filter input object', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.inputParser(address, signature, e); |
|||
var result = impl(); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 1); |
|||
assert.equal(result.topic[0], signature); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with options', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.inputParser(address, signature, e); |
|||
var result = impl({}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 1); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with indexed params', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.inputParser(address, signature, e); |
|||
var result = impl({a: 4}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 2); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.topic[1], f.formatInputInt(4)); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with an array of indexed params', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.inputParser(address, signature, e); |
|||
var result = impl({a: [4, 69]}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 2); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.topic[1][0], f.formatInputInt(4)); |
|||
assert.equal(result.topic[1][1], f.formatInputInt(69)); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
@ -1,124 +0,0 @@ |
|||
var assert = require('assert'); |
|||
var event = require('../lib/event.js'); |
|||
var f = require('../lib/formatters.js'); |
|||
|
|||
describe('event', function () { |
|||
it('should create basic filter input object', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event(address, signature, e); |
|||
var result = impl(); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 1); |
|||
assert.equal(result.topic[0], signature); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with options', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event(address, signature, e); |
|||
var result = impl({}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 1); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with indexed params', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event(address, signature, e); |
|||
var result = impl({a: 4}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 2); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.topic[1], f.formatInputInt(4)); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
|
|||
it('should create filter input object with an array of indexed params', function () { |
|||
|
|||
// given
|
|||
var address = '0x012345'; |
|||
var signature = '0x987654'; |
|||
var options = { |
|||
earliest: 1, |
|||
latest: 2, |
|||
offset: 3, |
|||
max: 4 |
|||
}; |
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"hash256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event(address, signature, e); |
|||
var result = impl({a: [4, 69]}, options); |
|||
|
|||
// then
|
|||
assert.equal(result.address, address); |
|||
assert.equal(result.topic.length, 2); |
|||
assert.equal(result.topic[0], signature); |
|||
assert.equal(result.topic[1][0], f.formatInputInt(4)); |
|||
assert.equal(result.topic[1][1], f.formatInputInt(69)); |
|||
assert.equal(result.earliest, options.earliest); |
|||
assert.equal(result.latest, options.latest); |
|||
assert.equal(result.offset, options.offset); |
|||
assert.equal(result.max, options.max); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
|
|||
@ -0,0 +1,81 @@ |
|||
var assert = require('assert'); |
|||
var event = require('../lib/event.js'); |
|||
|
|||
describe('event', function () { |
|||
describe('outputParser', function () { |
|||
it('should parse basic event output object', function () { |
|||
|
|||
// given
|
|||
var output = { |
|||
"address":"0x78dfc5983baecf65f73e3de3a96cee24e6b7981e", |
|||
"data":"0x000000000000000000000000000000000000000000000000000000000000004b", |
|||
"number":2, |
|||
"topic":[ |
|||
"0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad", |
|||
"0x0000000000000000000000000000000000000000000000000000000000000001" |
|||
] |
|||
}; |
|||
|
|||
var e = { |
|||
name: 'Event', |
|||
inputs: [{"name":"a","type":"bool","indexed":true},{"name":"b","type":"uint256","indexed":false}] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.outputParser(e); |
|||
var result = impl(output); |
|||
|
|||
// then
|
|||
assert.equal(result.event, 'Event'); |
|||
assert.equal(result.number, 2); |
|||
assert.equal(Object.keys(result.args).length, 2); |
|||
assert.equal(result.args.a, true); |
|||
assert.equal(result.args.b, 75); |
|||
}); |
|||
|
|||
it('should parse event output object arguments in correct order', function () { |
|||
|
|||
// given
|
|||
var output = { |
|||
"address":"0x78dfc5983baecf65f73e3de3a96cee24e6b7981e", |
|||
"data": "0x" + |
|||
"000000000000000000000000000000000000000000000000000000000000004b" + |
|||
"000000000000000000000000000000000000000000000000000000000000004c" + |
|||
"0000000000000000000000000000000000000000000000000000000000000001", |
|||
"number":3, |
|||
"topic":[ |
|||
"0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad", |
|||
"0x0000000000000000000000000000000000000000000000000000000000000001", |
|||
"0x0000000000000000000000000000000000000000000000000000000000000005" |
|||
] |
|||
}; |
|||
|
|||
var e = { |
|||
name: 'Event2', |
|||
inputs: [ |
|||
{"name":"a","type":"bool","indexed":true}, |
|||
{"name":"b","type":"int","indexed":false}, |
|||
{"name":"c","type":"int","indexed":false}, |
|||
{"name":"d","type":"int","indexed":true}, |
|||
{"name":"e","type":"bool","indexed":false} |
|||
] |
|||
}; |
|||
|
|||
// when
|
|||
var impl = event.outputParser(e); |
|||
var result = impl(output); |
|||
|
|||
// then
|
|||
assert.equal(result.event, 'Event2'); |
|||
assert.equal(result.number, 3); |
|||
assert.equal(Object.keys(result.args).length, 5); |
|||
assert.equal(result.args.a, true); |
|||
assert.equal(result.args.b, 75); |
|||
assert.equal(result.args.c, 76); |
|||
assert.equal(result.args.d, 5); |
|||
assert.equal(result.args.e, true); |
|||
|
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
@ -0,0 +1,143 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('isValidResponse', function () { |
|||
it('should validate basic jsonrpc response', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, true); |
|||
}); |
|||
|
|||
it('should validate basic undefined response', function () { |
|||
|
|||
// given
|
|||
var response = undefined; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without jsonrpc field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with wrong jsonrpc version', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '1.0', |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without id number', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with wrong id field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 'x', |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without result field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1 |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with result field === false', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1, |
|||
result: false |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, true); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with result field === 0', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1, |
|||
result: 0 |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, true); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,47 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('toBatchPayload', function () { |
|||
it('should create basic batch payload', function () { |
|||
|
|||
// given
|
|||
var messages = [{ |
|||
method: 'helloworld' |
|||
}, { |
|||
method: 'test2', |
|||
params: [1] |
|||
}]; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toBatchPayload(messages); |
|||
|
|||
// then
|
|||
assert.equal(payload instanceof Array, true); |
|||
assert.equal(payload.length, 2); |
|||
assert.equal(payload[0].jsonrpc, '2.0'); |
|||
assert.equal(payload[1].jsonrpc, '2.0'); |
|||
assert.equal(payload[0].method, 'helloworld'); |
|||
assert.equal(payload[1].method, 'test2'); |
|||
assert.equal(payload[0].params instanceof Array, true); |
|||
assert.equal(payload[1].params.length, 1); |
|||
assert.equal(payload[1].params[0], 1); |
|||
assert.equal(typeof payload[0].id, 'number'); |
|||
assert.equal(typeof payload[1].id, 'number'); |
|||
assert.equal(payload[0].id + 1, payload[1].id); |
|||
}); |
|||
|
|||
it('should create batch payload for empty input array', function () { |
|||
|
|||
// given
|
|||
var messages = []; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toBatchPayload(messages); |
|||
|
|||
// then
|
|||
assert.equal(payload instanceof Array, true); |
|||
assert.equal(payload.length, 0); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,40 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('toPayload', function () { |
|||
it('should create basic payload', function () { |
|||
|
|||
// given
|
|||
var method = 'helloworld'; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toPayload(method); |
|||
|
|||
// then
|
|||
assert.equal(payload.jsonrpc, '2.0'); |
|||
assert.equal(payload.method, method); |
|||
assert.equal(payload.params instanceof Array, true); |
|||
assert.equal(payload.params.length, 0); |
|||
assert.equal(typeof payload.id, 'number'); |
|||
}); |
|||
|
|||
it('should create payload with params', function () { |
|||
|
|||
// given
|
|||
var method = 'helloworld1'; |
|||
var params = [123, 'test']; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toPayload(method, params); |
|||
|
|||
// then
|
|||
assert.equal(payload.jsonrpc, '2.0'); |
|||
assert.equal(payload.method, method); |
|||
assert.equal(payload.params.length, 2); |
|||
assert.equal(payload.params[0], params[0]); |
|||
assert.equal(payload.params[1], params[1]); |
|||
assert.equal(typeof payload.id, 'number'); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,42 @@ |
|||
var assert = require('assert'); |
|||
var utils = require('../lib/utils.js'); |
|||
|
|||
describe('utils', function () { |
|||
describe('extractDisplayName', function () { |
|||
it('should extract display name from method with no params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld()'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld'); |
|||
}); |
|||
|
|||
it('should extract display name from method with one param' , function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld1(int)'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld1'); |
|||
}); |
|||
|
|||
it('should extract display name from method with two params' , function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld2(int,string)'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld2'); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,55 @@ |
|||
var assert = require('assert'); |
|||
var utils = require('../lib/utils.js'); |
|||
|
|||
describe('utils', function () { |
|||
describe('extractTypeName', function () { |
|||
it('should extract type name from method with no params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld()'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, ''); |
|||
}); |
|||
|
|||
it('should extract type name from method with one param', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld1(int)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int'); |
|||
}); |
|||
|
|||
it('should extract type name from method with two params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld2(int,string)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int,string'); |
|||
}); |
|||
|
|||
it('should extract type name from method with spaces between params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld3(int, string)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int,string'); |
|||
}); |
|||
|
|||
}); |
|||
}); |
|||
@ -0,0 +1,45 @@ |
|||
#!/bin/bash |
|||
|
|||
# solves problem with macdeployqt on Qt 5.4 RC |
|||
# http://qt-project.org/forums/viewthread/50118 |
|||
|
|||
BUILD_FOLDER_PATH=$1 |
|||
BUILD_QML_FOLDER_PATH="$BUILD_FOLDER_PATH/Resources/qml" |
|||
BUILD_PLUGINS_FOLDER_PATH="$BUILD_FOLDER_PATH/PlugIns" |
|||
|
|||
if [ ! -d ${BUILD_QML_FOLDER_PATH} ]; then |
|||
# we are not using any qml files |
|||
# gracefully exit |
|||
exit 0 |
|||
fi |
|||
|
|||
declare -a BROKEN_FILES; |
|||
k=0; |
|||
for j in $(find ${BUILD_QML_FOLDER_PATH} -name *.dylib); do |
|||
BROKEN_FILES[${k}]=$j |
|||
|
|||
((k=k+1)) |
|||
done |
|||
|
|||
|
|||
for i in "${BROKEN_FILES[@]}"; do |
|||
REPLACE_STRING="$BUILD_FOLDER_PATH/" |
|||
APP_CONTENT_FILE=${i//$REPLACE_STRING/""} |
|||
IFS='/' read -a array <<< "$APP_CONTENT_FILE" |
|||
LENGTH=${#array[@]} |
|||
LAST_ITEM_INDEX=$((LENGTH-1)) |
|||
FILE=${array[${LENGTH} - 1]} |
|||
|
|||
ORIGINE_PATH=$(find ${BUILD_PLUGINS_FOLDER_PATH} -name ${FILE}) |
|||
ORIGINE_PATH=${ORIGINE_PATH//$REPLACE_STRING/""} |
|||
s="" |
|||
for((l=0;l<${LAST_ITEM_INDEX};l++)) do |
|||
s=$s"../" |
|||
done |
|||
s=$s$ORIGINE_PATH |
|||
echo "s: $s" |
|||
|
|||
REMOVE_BROKEN_ALIAS=$(rm -rf $i) |
|||
RESULT=$(ln -s $s $i) |
|||
done |
|||
|
|||
@ -0,0 +1,79 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file MixClient.h
|
|||
* @author Yann yann@ethdev.com |
|||
* @author Arkadiy Paronyan arkadiy@ethdev.com |
|||
* @date 2015 |
|||
* Ethereum IDE client. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
#include <map> |
|||
#include <stdint.h> |
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcrypto/Common.h> |
|||
#include <libevmcore/Instruction.h> |
|||
#include <libethereum/TransactionReceipt.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace mix |
|||
{ |
|||
|
|||
/**
|
|||
* @brief Store information about a machine state. |
|||
*/ |
|||
struct MachineState |
|||
{ |
|||
uint64_t steps; |
|||
dev::Address address; |
|||
dev::u256 curPC; |
|||
dev::eth::Instruction inst; |
|||
dev::bigint newMemSize; |
|||
dev::u256 gas; |
|||
dev::u256s stack; |
|||
dev::bytes memory; |
|||
dev::bigint gasCost; |
|||
std::map<dev::u256, dev::u256> storage; |
|||
std::vector<unsigned> levels; |
|||
unsigned codeIndex; |
|||
unsigned dataIndex; |
|||
}; |
|||
|
|||
/**
|
|||
* @brief Store information about a machine states. |
|||
*/ |
|||
struct ExecutionResult |
|||
{ |
|||
ExecutionResult() : receipt(dev::h256(), dev::h256(), dev::eth::LogEntries()) {} |
|||
|
|||
std::vector<MachineState> machineStates; |
|||
std::vector<bytes> transactionData; |
|||
std::vector<bytes> executionCode; |
|||
bytes returnValue; |
|||
dev::Address address; |
|||
dev::Address sender; |
|||
dev::Address contractAddress; |
|||
dev::u256 value; |
|||
dev::eth::TransactionReceipt receipt; |
|||
}; |
|||
|
|||
using ExecutionResults = std::vector<ExecutionResult>; |
|||
} |
|||
} |
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QBoolType 1.0 |
|||
|
|||
QBoolType |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,42 @@ |
|||
import QtQuick 2.0 |
|||
import QtQuick.Controls 1.3 |
|||
|
|||
Item |
|||
{ |
|||
id: editRoot |
|||
property string text |
|||
property string defaultValue |
|||
|
|||
Rectangle { |
|||
anchors.fill: parent |
|||
ComboBox |
|||
{ |
|||
property bool inited: false |
|||
Component.onCompleted: |
|||
{ |
|||
if (text === "") |
|||
currentIndex = parseInt(defaultValue); |
|||
else |
|||
currentIndex = parseInt(text); |
|||
inited = true |
|||
} |
|||
|
|||
id: boolCombo |
|||
anchors.fill: parent |
|||
onCurrentIndexChanged: |
|||
{ |
|||
if (inited) |
|||
text = comboModel.get(currentIndex).value; |
|||
} |
|||
model: ListModel |
|||
{ |
|||
id: comboModel |
|||
ListElement { text: qsTr("False"); value: "0" } |
|||
ListElement { text: qsTr("True"); value: "1" } |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QHashType 1.0 |
|||
|
|||
QHashType |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,22 @@ |
|||
import QtQuick 2.0 |
|||
|
|||
Item |
|||
{ |
|||
property alias text: textinput.text |
|||
id: editRoot |
|||
Rectangle { |
|||
anchors.fill: parent |
|||
TextInput { |
|||
id: textinput |
|||
text: text |
|||
anchors.fill: parent |
|||
wrapMode: Text.WrapAnywhere |
|||
MouseArea { |
|||
id: mouseArea |
|||
anchors.fill: parent |
|||
hoverEnabled: true |
|||
onClicked: textinput.forceActiveFocus() |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QIntType 1.0 |
|||
|
|||
QIntType |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,24 @@ |
|||
import QtQuick 2.0 |
|||
|
|||
Item |
|||
{ |
|||
property alias text: textinput.text |
|||
id: editRoot |
|||
Rectangle { |
|||
anchors.fill: parent |
|||
TextInput { |
|||
id: textinput |
|||
text: text |
|||
anchors.fill: parent |
|||
MouseArea { |
|||
id: mouseArea |
|||
anchors.fill: parent |
|||
hoverEnabled: true |
|||
onClicked: textinput.forceActiveFocus() |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QRealType 1.0 |
|||
|
|||
QRealType |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,15 @@ |
|||
import QtQuick 2.0 |
|||
|
|||
Component |
|||
{ |
|||
Rectangle { |
|||
anchors.fill: parent |
|||
Text{ |
|||
anchors.fill: parent |
|||
text: qsTr("Real") |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QStringType 1.0 |
|||
|
|||
QStringType |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,25 @@ |
|||
import QtQuick 2.0 |
|||
|
|||
Item |
|||
{ |
|||
property alias text: textinput.text |
|||
id: editRoot |
|||
Rectangle { |
|||
anchors.fill: parent |
|||
TextInput { |
|||
id: textinput |
|||
text: text |
|||
anchors.fill: parent |
|||
wrapMode: Text.WrapAnywhere |
|||
MouseArea { |
|||
id: mouseArea |
|||
anchors.fill: parent |
|||
hoverEnabled: true |
|||
onClicked: textinput.forceActiveFocus() |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,7 @@ |
|||
import QtQuick 2.0 |
|||
import org.ethereum.qml.QVariableDeclaration 1.0 |
|||
|
|||
QVariableDeclaration |
|||
{ |
|||
} |
|||
|
|||
@ -0,0 +1,13 @@ |
|||
/* |
|||
* Used to instanciate a QVariableDefinition obj using Qt.createComponent function. |
|||
*/ |
|||
import QtQuick 2.2 |
|||
import QtQuick.Controls 1.1 |
|||
import QtQuick.Layouts 1.1 |
|||
import QtQuick.Controls.Styles 1.1 |
|||
import org.ethereum.qml.QVariableDefinition 1.0 |
|||
|
|||
QVariableDefinition |
|||
{ |
|||
id: qVariableDefinition |
|||
} |
|||
@ -1,47 +0,0 @@ |
|||
import QtQuick 2.2 |
|||
|
|||
Rectangle { |
|||
property variant itemToStick; |
|||
property int itemMinimumWidth; |
|||
property string direction; |
|||
property variant brother; |
|||
|
|||
Component.onCompleted: |
|||
{ |
|||
if (direction === "left") |
|||
anchors.right = itemToStick.left; |
|||
else if (direction === "right") |
|||
anchors.left = itemToStick.right; |
|||
} |
|||
|
|||
width: 5 |
|||
height: parent.height |
|||
anchors.top: parent.top; |
|||
MouseArea |
|||
{ |
|||
property int startX: 0; |
|||
anchors.fill: parent |
|||
onPressed: startX = mouseX; |
|||
onPositionChanged: |
|||
{ |
|||
parent.x += mouseX; |
|||
var diff = 0; |
|||
if (direction == "left") |
|||
diff = mouseX - startX; |
|||
else if (direction == "right") |
|||
diff = -(mouseX - startX); |
|||
|
|||
if (itemMinimumWidth > itemToStick.width - diff) |
|||
{ |
|||
brother.width = brother.width + diff; |
|||
itemToStick.width = itemMinimumWidth; |
|||
} |
|||
else |
|||
{ |
|||
brother.width = brother.width + diff; |
|||
itemToStick.width = itemToStick.width - diff; |
|||
} |
|||
} |
|||
cursorShape: Qt.SizeHorCursor |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue