27 |
28 |
33 | 34 |
66 |
94 |
115 |
127 |
131 |
29 |
30 |
31 |
32 | 
Decentralized Spare Route Service
30 | 33 | 34 |
35 |
36 |
64 |
65 |
37 |
39 |
40 | Send Parts to Manufacturer
38 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 | 66 |
67 |
68 |
92 |
93 |
69 |
71 |
72 | Use Parts Sent By OEM
70 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 | Remaining Parts :
88 |
89 |
90 |
91 | 94 |
95 |
114 |
96 |
98 | Vehicle To Dealer
97 |
99 |
100 |
101 |
102 |
103 | Vehicle Name :
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 | 115 |
116 |
117 |
118 |
119 |
120 |
126 |
121 |
122 |
123 |
124 |
125 | 127 |
128 | Made with By Satoshi Lab, Next Tech
129 |
130 | 
42 |
43 |
44 | ## Architecture and Tech-stack
45 |
46 | 
47 |
48 |
49 | ### Architecture Modules
50 | 1. **Add parts** - The OEM uses the function Add parts for adding the produced spare part with its name,quantity,ID and price per unit.
51 | 2. **Buy parts show price** - The Automobile Manufacturer finds the price he has to pay by calling this function with the name and number of part he needs.
52 | 3. **Use OEM parts** - The Automobile Manufacturer pays money temporarily for the parts only if the parts are found to be genuine.
53 | 4. **Pay to OEM** - The OEM can call this function to claim the money for the parts only after 10 hours from the time the Manufacturer pays(if defective products are found the Manufacturer refunds the part).
54 | 5. **Part to vehicle** - This function is used to assign the part to the Vehicle in which the part is to be installed.
55 | 6. **Check part location** - This function is used to check the vehicle in which the part is installed.
56 | 7. **Vehicle assembled** - This function is used to set the vehicle as manufactured completely and ready to be sent to the dealer.
57 | 8. **Showroom** - The Dealer and client can get the final vehicle from here.
58 |
59 | ### Tech Stack
60 | 1. Ethereum smart constracts (in solidity)
61 | 2. Ropsten testnet
62 | 3. Truffle framework
63 | 4. Remix IDE
64 | 5. Web3.js
65 | 6. Geth
66 |
67 | ##### Steps to compile in Truffle
68 | 1. git clone https://github.com/SatoshiNextTechLab/BlockSCM.git
69 | 2. truffle compile
70 | 3. truffle migrate
71 | 4. truffle console
72 | 5. Interact using Web3.js
73 |
74 | ##### Steps to compile GUI
75 | 1. clone repo https://github.com/SatoshiNextTechLab/BlockSCM.git
76 | 2. cd into TheSpareRoute-master/GUI
77 | 2. npm install .
78 | 3. npm install lite-server --save-dev
79 | 3. npm run dev
80 |
81 | ## Built by undergraduates at [Next Tech Lab, SRM Institute of Science and Technology](http://nextech.io/index2.html)
82 |
--------------------------------------------------------------------------------
/UML SCM.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SatoshiNextTechLab/BlockSCM/d5886437baa3ede25013afc3f403ee6dc2b33175/UML SCM.jpg
--------------------------------------------------------------------------------
/Vyper-contracts/auto.vy:
--------------------------------------------------------------------------------
1 | #Vyper Contract
2 | time_now: public(timestamp)
3 | string_hash: public(bytes32)
4 | pooltime: public(timestamp)
5 |
6 | auto_industry: public({
7 | typ: uint256,
8 | _add: address
9 | }[address])
10 |
11 |
12 | vehicle: public({
13 | vehicle_id: uint256,
14 | vehicle_name: bytes32
15 | }[uint256])
16 |
17 | parts_mapping: public(uint256[bytes32])
18 | id_mapping: public(uint256[bytes32])
19 | time_mapping: public(timestamp[bytes32])
20 | hashing_item: public(bytes32[bytes32])
21 | price_mapping: public(uint256[bytes32])
22 | completeness: public(uint256[uint256])
23 |
24 | @public
25 | @payable
26 | def __init__():
27 | pass
28 |
29 |
30 | @public
31 | def add_OEM():
32 | self.auto_industry[msg.sender]= {typ: 1,_add: msg.sender}
33 |
34 | @public
35 | def add_AUTO_MANU():
36 | self.auto_industry[msg.sender]= {typ: 2,_add: msg.sender}
37 |
38 |
39 | @public
40 | def addparts(name: bytes32,quantity: uint256,ids: uint256,price: uint256):
41 | assert self.auto_industry[msg.sender].typ == 1
42 | self.parts_mapping[name]+=quantity
43 | self.time_now=block.timestamp
44 | self.id_mapping[name]=ids
45 | self.time_mapping[name]=self.time_now
46 | self.price_mapping[name]=price
47 | # figure out a way to hash name,ids and time together
48 | self.hashing_item[name]=sha3(name)
49 |
50 | @public
51 | @constant
52 | def display(part_name: bytes32) -> uint256:
53 | return self.parts_mapping[part_name]
54 |
55 | @public
56 | @constant
57 | def buy_part_amount_show(name_of_part: bytes32, how_many: uint256) -> uint256:
58 | return how_many*self.price_mapping[name_of_part]
59 |
60 | @public
61 | @payable
62 | def use_OEM_Parts(name_of_part: bytes32,how_many: uint256,id_of_item: bytes32):
63 | #include hash check here
64 | assert self.parts_mapping[name_of_part] > how_many
65 | self.parts_mapping[name_of_part]-=how_many
66 | self.pooltime = block.timestamp
67 |
68 |
69 | @public
70 | @constant
71 | def getPoolMoney() -> uint256(wei):
72 | return self.balance
73 |
74 | @public
75 | def defective(_name_of_part: bytes32, no_of_pieces: uint256(wei)):
76 | assert self.auto_industry[msg.sender].typ == 2
77 | send(msg.sender,no_of_pieces*self.price_mapping[_name_of_part])
78 |
79 |
80 | @public
81 | @payable
82 | def pay_to_OEM():
83 | assert self.auto_industry[msg.sender].typ == 1
84 | if (block.timestamp - self.pooltime) > 36000 :
85 | send(msg.sender,self.balance)
86 |
87 | @public
88 | def part_to_vehicle(partid: uint256,vehicle_n: bytes32,_vehicle_id: uint256):
89 | assert self.auto_industry[msg.sender].typ ==2
90 | assert self.completeness[_vehicle_id]!=1
91 | self.vehicle[partid] = {vehicle_id: _vehicle_id,vehicle_name: vehicle_n}
92 |
93 |
94 | @public
95 | @constant
96 | def check_part_location(partid: uint256) -> uint256:
97 | return self.vehicle[partid].vehicle_id
98 |
99 | @public
100 | @constant
101 | def check_part_location2(partid: uint256) -> bytes32:
102 | return self.vehicle[partid].vehicle_name
103 |
104 |
105 | @public
106 | def vehicle_assembled(vehicle_id: uint256):
107 | self.completeness[vehicle_id]=1
108 |
109 |
110 | @public
111 | @payable
112 | def __default__():
113 | pass
114 |
--------------------------------------------------------------------------------
/contracts/Migrations.sol:
--------------------------------------------------------------------------------
1 | pragma solidity ^0.4.4;
2 |
3 | contract Migrations {
4 | address public owner;
5 | uint public last_completed_migration;
6 |
7 | modifier restricted() {
8 | if (msg.sender == owner) _;
9 | }
10 |
11 | function Migrations() {
12 | owner = msg.sender;
13 | }
14 |
15 | function setCompleted(uint completed) restricted {
16 | last_completed_migration = completed;
17 | }
18 |
19 | function upgrade(address new_address) restricted {
20 | Migrations upgraded = Migrations(new_address);
21 | upgraded.setCompleted(last_completed_migration);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/contracts/auto.sol:
--------------------------------------------------------------------------------
1 | //Blockchain consortium for Automobile Sector –
2 | //Setup a private blockchain consortium with
3 | //minimum 2 parties (Automobile manufacturer and
4 | //OEM manufacturer). The Blockchain solution is
5 | //enabled to track the movement of automobile spare parts from
6 | //OEM warehouse to Automobile manufacturer facility where
7 | //they are also recorded in the blockchain while
8 | //each part is installed in a vehicle and the
9 | //information of vehicle is recorded in the ledger as well.
10 |
11 |
12 | pragma solidity ^0.4.0;
13 |
14 | contract SomeContract {
15 |
16 | function SomeContract() public payable{
17 |
18 | }
19 |
20 | event TheOemAddedAnItem(address oemaddress,bytes32 itemname,uint quantityofitem);
21 | event TheManufacturerRequestedForParts(bytes32 nameofpart,uint numberofparts);
22 | event TheManufacturerRequestedForMoreParts(bytes32 nameofthepart,uint numberoftheparts);
23 | event TheOemGotPaid(address _oemsaddress,uint moneyinthepoolforoem);
24 | event TheManufacturerRefundedTheDefectiveItem(bytes32 defectiveitem,uint numberofdefective);
25 | event TheVehicleIsReadyToBeSendToTheDealer(uint thevehicleid);
26 |
27 | struct auto_industry {
28 |
29 | uint typ;
30 | address add;
31 |
32 | }
33 |
34 | // add oem to the network
35 | mapping(address => auto_industry ) addautoindustry;
36 |
37 | function add_OEM() {
38 |
39 | addautoindustry[msg.sender]=auto_industry(1,msg.sender);
40 |
41 | }
42 |
43 | modifier only_OEM() {
44 |
45 | if (addautoindustry[msg.sender].typ==1){
46 | _;
47 | }
48 |
49 | else {
50 | throw;
51 | }
52 |
53 | }
54 | // add automobile manufacturer
55 | function add_AUTO_MANU() {
56 |
57 | addautoindustry[msg.sender]=auto_industry(2,msg.sender);
58 |
59 | }
60 |
61 | modifier only_AUTO_MANU() {
62 |
63 | if (addautoindustry[msg.sender].typ==2){
64 | _;
65 | }
66 |
67 | else {
68 | throw;
69 | }
70 |
71 | }
72 |
73 | mapping (bytes32 => uint) parts_mapping;
74 | mapping (bytes32 => uint) id_mapping;
75 | mapping (bytes32 => uint) time_mapping;
76 | mapping (bytes32 => bytes32) hashing_item;
77 | mapping (bytes32 => uint) price_mapping;
78 |
79 | //takes input of part name,no of part,part id (for adding the part to list)
80 | function addparts(bytes32 name, uint quantity, uint ids,uint price) only_OEM {
81 |
82 | uint p=parts_mapping[name];
83 | parts_mapping[name]=p+quantity;
84 | uint time_now=now;
85 | id_mapping[name] = ids;
86 | time_mapping[name]=time_now;
87 | price_mapping[name]=price;
88 | hashing_item[name]=sha3(name,ids,time_now);
89 | TheOemAddedAnItem(msg.sender,name,quantity);
90 |
91 | }
92 |
93 | //displays the no of quantity remaining for a particular part
94 | function display(bytes32 part_name) constant returns(uint) {
95 |
96 | return parts_mapping[part_name];
97 |
98 | }
99 |
100 | //not useful just for testing
101 | function display_time(bytes32 part_name) constant returns(uint) {
102 |
103 | return time_mapping[part_name];
104 |
105 | }
106 |
107 | //modiier takes name and id of the part and tells weather it is genuine
108 | modifier auth_part(bytes32 name, uint id_item) {
109 |
110 | uint time_created=time_mapping[name];
111 | bytes32 hash_temp=sha3(name,id_item,time_created);
112 | bytes32 orig_hash=hashing_item[name];
113 | if(hash_temp==orig_hash) {
114 | _;
115 | }
116 | else {
117 | throw;
118 | }
119 |
120 | }
121 |
122 | uint pooltime;
123 |
124 | // used to calculate money for desired part from oem
125 | function buy_part_amount_show (bytes32 name_of_part , uint how_many) constant returns(uint) {
126 |
127 | uint amount = how_many * price_mapping[name_of_part];
128 | return amount;
129 |
130 | }
131 |
132 | // checking for authenticity of parts and paying temporarily to the pool
133 | function use_OEM_Parts(bytes32 name_of_part, uint how_many, uint id_of_item) auth_part(name_of_part , id_of_item) payable {
134 |
135 | if( parts_mapping[name_of_part] < how_many ){
136 | TheManufacturerRequestedForMoreParts(name_of_part,how_many);
137 | }
138 |
139 | parts_mapping[name_of_part] = parts_mapping[name_of_part] - how_many;
140 | uint amount = msg.value;
141 | this.transfer(amount);
142 | pooltime=now;
143 |
144 | TheManufacturerRequestedForParts(name_of_part,how_many);
145 |
146 |
147 | }
148 |
149 | //give the amount present in the pool
150 | function getPoolMoney() constant returns (uint){
151 |
152 | return this.balance;
153 |
154 | }
155 |
156 | //for giving back defective items,after this manufacturer gets his money and oem takes the defective part
157 | function defective(bytes32 _name_of_part, uint no_of_pieces) only_AUTO_MANU {
158 |
159 | uint __amount = no_of_pieces * price_mapping[_name_of_part];
160 | msg.sender.transfer(__amount);
161 | TheManufacturerRefundedTheDefectiveItem(_name_of_part,no_of_pieces);
162 |
163 | }
164 |
165 | //by this function oem can take out money out of the pool to his account after 10 hrs
166 | function pay_to_OEM() payable only_OEM() {
167 |
168 | if(now-pooltime > 36000){
169 | TheOemGotPaid(msg.sender, this.balance);
170 | msg.sender.transfer(this.balance);
171 | }
172 |
173 | }
174 | mapping (uint => vehicle) partinauto;
175 | struct vehicle
176 | {
177 | uint vehicle_id;
178 | string vehicle_name;
179 | }
180 | mapping (uint => uint) completeness;
181 | //for assigning the part to the vehicle
182 | function part_to_vehicle(uint partid,string vehicle_n,uint _vehicle_id) only_AUTO_MANU
183 | {
184 | if(completeness[_vehicle_id]==1)
185 | {
186 | throw;
187 | }
188 | else
189 | {
190 | partinauto[partid]=vehicle(_vehicle_id,vehicle_n);
191 | }
192 | }
193 | //for finding the location(the vehicle) where the part is installed
194 | function check_part_location(uint partid) constant returns(uint a,string b)
195 | {
196 | a=partinauto[partid].vehicle_id;
197 | b=partinauto[partid].vehicle_name;
198 | }
199 | //to set the status of manufactiring complete and is ready to be sent to the dealer
200 | function vehicle_assembled(uint vehicle_id_)
201 | {
202 | completeness[vehicle_id_]=1;
203 | TheVehicleIsReadyToBeSendToTheDealer(vehicle_id_);
204 | }
205 | function () payable{
206 |
207 | }
208 |
209 | }
210 |
--------------------------------------------------------------------------------
/migrations/1_initial_migration.js:
--------------------------------------------------------------------------------
1 | var Migrations = artifacts.require("./Migrations.sol");
2 |
3 | module.exports = function(deployer) {
4 | deployer.deploy(Migrations);
5 | };
6 |
--------------------------------------------------------------------------------
/migrations/2_deploy_contracts.js:
--------------------------------------------------------------------------------
1 | var auto = artifacts.require("./auto.sol");
2 |
3 | module.exports = function(deployer) {
4 | deployer.deploy(auto);
5 | };
6 |
--------------------------------------------------------------------------------
/test/TestMetacoin.sol:
--------------------------------------------------------------------------------
1 | pragma solidity ^0.4.2;
2 |
3 | import "truffle/Assert.sol";
4 | import "truffle/DeployedAddresses.sol";
5 | import "../contracts/MetaCoin.sol";
6 |
7 | contract TestMetacoin {
8 |
9 | function testInitialBalanceUsingDeployedContract() {
10 | MetaCoin meta = MetaCoin(DeployedAddresses.MetaCoin());
11 |
12 | uint expected = 10000;
13 |
14 | Assert.equal(meta.getBalance(tx.origin), expected, "Owner should have 10000 MetaCoin initially");
15 | }
16 |
17 | function testInitialBalanceWithNewMetaCoin() {
18 | MetaCoin meta = new MetaCoin();
19 |
20 | uint expected = 10000;
21 |
22 | Assert.equal(meta.getBalance(tx.origin), expected, "Owner should have 10000 MetaCoin initially");
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/test/metacoin.js:
--------------------------------------------------------------------------------
1 | var MetaCoin = artifacts.require("./MetaCoin.sol");
2 |
3 | contract('MetaCoin', function(accounts) {
4 | it("should put 10000 MetaCoin in the first account", function() {
5 | return MetaCoin.deployed().then(function(instance) {
6 | return instance.getBalance.call(accounts[0]);
7 | }).then(function(balance) {
8 | assert.equal(balance.valueOf(), 10000, "10000 wasn't in the first account");
9 | });
10 | });
11 | it("should call a function that depends on a linked library", function() {
12 | var meta;
13 | var metaCoinBalance;
14 | var metaCoinEthBalance;
15 |
16 | return MetaCoin.deployed().then(function(instance) {
17 | meta = instance;
18 | return meta.getBalance.call(accounts[0]);
19 | }).then(function(outCoinBalance) {
20 | metaCoinBalance = outCoinBalance.toNumber();
21 | return meta.getBalanceInEth.call(accounts[0]);
22 | }).then(function(outCoinBalanceEth) {
23 | metaCoinEthBalance = outCoinBalanceEth.toNumber();
24 | }).then(function() {
25 | assert.equal(metaCoinEthBalance, 2 * metaCoinBalance, "Library function returned unexpected function, linkage may be broken");
26 | });
27 | });
28 | it("should send coin correctly", function() {
29 | var meta;
30 |
31 | // Get initial balances of first and second account.
32 | var account_one = accounts[0];
33 | var account_two = accounts[1];
34 |
35 | var account_one_starting_balance;
36 | var account_two_starting_balance;
37 | var account_one_ending_balance;
38 | var account_two_ending_balance;
39 |
40 | var amount = 10;
41 |
42 | return MetaCoin.deployed().then(function(instance) {
43 | meta = instance;
44 | return meta.getBalance.call(account_one);
45 | }).then(function(balance) {
46 | account_one_starting_balance = balance.toNumber();
47 | return meta.getBalance.call(account_two);
48 | }).then(function(balance) {
49 | account_two_starting_balance = balance.toNumber();
50 | return meta.sendCoin(account_two, amount, {from: account_one});
51 | }).then(function() {
52 | return meta.getBalance.call(account_one);
53 | }).then(function(balance) {
54 | account_one_ending_balance = balance.toNumber();
55 | return meta.getBalance.call(account_two);
56 | }).then(function(balance) {
57 | account_two_ending_balance = balance.toNumber();
58 |
59 | assert.equal(account_one_ending_balance, account_one_starting_balance - amount, "Amount wasn't correctly taken from the sender");
60 | assert.equal(account_two_ending_balance, account_two_starting_balance + amount, "Amount wasn't correctly sent to the receiver");
61 | });
62 | });
63 | });
64 |
--------------------------------------------------------------------------------
/truffle.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | networks: {
3 | development: {
4 | host: "localhost",
5 | port: 8545,
6 | network_id: "*" // Match any network id
7 | }
8 | }
9 | };
10 |
--------------------------------------------------------------------------------