Smart Contracts-Enabled Simulation for Hyperconnected Logistics

Smart Contracts-Enabled
Simulation for
Hyperconnected Logistics
Quentin Betti, Benoît Montreuil,
Raphaël Khoury, Sylvain Hallé
Université du Québec à Chicoutimi, Canada
Georgia Institute of Technology, USA

Overview
Physical Internet
Challenges for hyperconnected logistics
Monitoring lifecycle policies
Implementation and experiments
Conclusion

1.
A
2. B
3. C
$ 9,999
Centralized planning
Pre-defined path

Bolzano
248
Bolzano
Bolzano
Decentralized planning
No pre-defined path

Physical Internet
Notion introduced by Benoît Montreuil
(Georgia Tech).
" A global hyperconnected logistics system
enabling seamless open asset sharing and flow
consolidation through standardized
encapsulation, modularization, protocols and
interfaces. "
Keynote talk at EDOC 2017

Physical Internet
unified set of standard containers
containerized logistics equipment
standard logistics protocols
certified open logistics facilities
global monitoring system
open decisional and transactional
platforms, analytics, optimization and
simulation
certified providers
7 core components:

Hyperconnected Logistics
unit zone ⊂ cell ⊂ area ⊂ region
The world is split into unit zones:
Hubs link elements of each layer:
access hub < local hub < gateway hub
Montreuil et al.,
Proc. IMHRC 2018

Some Challenges
No centralized, pre-planned route
No complete view of the "network"
No complete view of any package's history
How to verify compliance to
correctness properties / service
level agreements?
How to perform analytics?

Some Challenges
Operations must be recorded in (near)
real-time
Verification must be possible from
"anywhere" in the network
Goal: create a permanent, tamper-proof
record of the manipulations made on each
parcel.

Artifact-centric solution
S. Hallé, R. Khoury, A. El-Hokayem, Y. Falcone. Decentralized
Enforcement of Artifact Lifecycles. EDOC 2016.
Back in
2016....

Artifact-centric solution
Concretely, affix a small memory device to
the parcel and append elements to its
peer-action sequence.
Decentralized,
tamper-proof
Requires physical
access to the parcel

Blockchain-based solution
Implement actions on parcels as smart
contracts*, and store their occurrence in a
blockchain.
Code stored with the blockchain and that can be called by
transactions sent to its address. Newly received
corresponding transactions will then trigger the code to
be executed on each node of the blockchain network.
*

The blockchain is private.
Made of a set of nodes that can
communicate with each other.
These nodes are separate from the "main"
blockchain of the chosen platform
(Ethereum).
Each maintains a synchronized, agreed-
upon copy of the blockchain.
The contents of the blockchain can be
queried from any node.

Two smart contracts:
Represents a single parcel in the simulation and stores
every action performed on it. Actions can be appended,
or fetched by their index.
Shipment
Interface responsible for managing Shipment contracts.
Used to create new parcels, or to access existing parcels
by their identifier. Can be also used to enforce access
control restrictions or other validation tasks.
ShipmentManager

Package Event Streams
Execution of the smart contracts produces
new elements added to the blockchain.
They can be considered as events in a
particular type of stream.
Proposal: use a stream processing engine
to verify compliance and perform analytics.

Open source event stream processing
library
Based on basic computing blocks called
processors
Processors can be freely* connected to
each other, producing processing pipelines
https://liflab.github.io/beepbeep-3

300 pages
150+ code examples
Color illustrations
Open access
https://bit.ly/beepbeep-book

f
f n
n
P
{
Σ
f
P
n
Apply a function
to each event
Keep one event
every n
Trim the first n
events
Cumulate values of
a function
Fork a stream into
multiple copies
Slice a stream into
multiple sub-
streams
Apply a processor
to a sliding
window of events
Filter events based
on a control signal
f
S. Hallé. A Formalization of Complex Event Processing. EDOC 2014.

Listening to blockchain events
An extension to BeepBeep adds a new
processor that listens to events from an
Ethereum blockchain.
CatchEthContractLogs source =
new CatchEthContractLogs("http://host:8545",
"0x6702413C52c8Cf0fc5f", true);
The processor is a
source producing
tuples.

Typical parcel events
A simple parcel event can contain the
following attributes:
parcel ID
current x / current y
destination x / destination y
timestamp
action (pickup or delivery)

1
2
3
4
6
9
10
ID
8b0
34c
8b0
8b0
34c
34c
34c
(xC,yC)
(0,0)
(2,7)
(1,1)
(1,2)
(8,6)
(8,6)
(3,3)
(xD,yD)
(5,3)
(9,9)
(5,3)
(5,3)
(9,9)
(9,9)
(9,9)
Action

How It Is Done
CatchEthContractLogs catcher = new CatchEthContractLogs(
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
Event myEvent = new Event(
"Instructor",
Arrays.asList(
new TypeReference<Utf8String>() {},
new TypeReference<Uint256>() {}
));
ApplyFunction get = new ApplyFunction(
new GetEventParameters(myEvent)
);
Connector.connect(listener, get);
Connector.connect(get, ...);
catcher.start();
Thread.sleep(30000);
catcher.stop();

Setup the Ethereum
Beepbeep source
How It Is Done
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
"Instructor",
Arrays.asList(
));
);
catcher.start();
catcher.stop();

Define an event
type to catch
How It Is Done
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
"Instructor",
Arrays.asList(
));
);
catcher.start();
catcher.stop();

Filter on that
event type
How It Is Done
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
"Instructor",
Arrays.asList(
));
);
catcher.start();
catcher.stop();

Connect these
processors to the
desired pipeline
How It Is Done
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
"Instructor",
Arrays.asList(
));
);
catcher.start();
catcher.stop();

Start the process
and wait for
events
How It Is Done
"http://host:8545",
"0x6702413C52c8Cf0fc5f061C89960a262f40C850c",
true);
"Instructor",
Arrays.asList(
));
);
catcher.start();
catcher.stop();

Properties on parcel streams
Correctness / lifecycle properties

Properties on parcel streams
Analytical queries

Lifecycle Property
?
T
T
T
*
*
*
*
=?
pickup
[type]
:=
x [loc_x]
=?
pickup
[type]
=?
delivery
[type]
:=
y [loc_y]
=?
[loc_x]
$x
=?
[loc_y]
$y
∧
∧
[id]
f
∧
[*]
T
*
∧
¬
∧
=?
[loc_x] [dst_x]
=?
[loc_y] [dst_y]
=?
delivery
[type]
1
3
2
3
4
5

Lifecycle Property
?
T
T
T
*
*
*
*
=?
pickup
[type]
:=
x [loc_x]
=?
pickup
[type]
=?
delivery
[type]
:=
y [loc_y]
=?
[loc_x]
$x
=?
[loc_y]
$y
∧
∧
[id]
f
∧
[*]
T
*
∧
¬
∧
=?
[loc_x] [dst_x]
=?
[loc_y] [dst_y]
=?
delivery
[type]
1
3
2
3
4
5
slice stream for each
parcel ID

Lifecycle Property
?
T
T
T
*
*
*
*
=?
pickup
[type]
:=
x [loc_x]
=?
pickup
[type]
=?
delivery
[type]
:=
y [loc_y]
=?
[loc_x]
$x
=?
[loc_y]
$y
∧
∧
[id]
f
∧
[*]
T
*
∧
¬
∧
=?
[loc_x] [dst_x]
=?
[loc_y] [dst_y]
=?
delivery
[type]
1
3
2
3
4
5
finite-state
machine
($x,$y) = last location

Lifecycle Property
?
T
T
T
*
*
*
*
=?
pickup
[type]
:=
x [loc_x]
=?
pickup
[type]
=?
delivery
[type]
:=
y [loc_y]
=?
[loc_x]
$x
=?
[loc_y]
$y
∧
∧
[id]
f
∧
[*]
T
*
∧
¬
∧
=?
[loc_x] [dst_x]
=?
[loc_y] [dst_y]
=?
delivery
[type]
1
3
2
3
4
5
status must not be ⊥ for
any slice

1
2
3
4
6
9
10
ID
8b0
34c
8b0
8b0
34c
34c
34c
(xC,yC)
(0,0)
(2,7)
(1,1)
(1,2)
(8,6)
(8,6)
(3,3)
(xD,yD)
(5,3)
(9,9)
(5,3)
(5,3)
(9,9)
(9,9)
(9,9)
Action
Lifecycle Property

Decreasing Distance Property
=?
delivery
[type]
[id]
[loc_x] [dst_x]
−
x2
[loc_y] [dst_y]
−
x2
+
√
1
≥
f
∧
[*]
4
1
2
3
5
6

1
2
3
4
6
9
10
ID
8b0
34c
8b0
8b0
34c
34c
34c
(xC,yC)
(0,0)
(2,7)
(1,1)
(1,2)
(8,6)
(8,6)
(3,3)
(xD,yD)
(5,3)
(9,9)
(5,3)
(5,3)
(9,9)
(9,9)
(9,9)
Action

1
2
3
4
6
9
10
ID
8b0
34c
8b0
8b0
34c
34c
34c
(xC,yC)
(0,0)
(2,7)
(1,1)
(1,2)
(8,6)
(8,6)
(3,3)
(xD,yD)
(5,3)
(9,9)
(5,3)
(5,3)
(9,9)
(9,9)
(9,9)
Action
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Delivery Time Distribution
=?
delivery
[type]
=?
[loc_x]
$x
=?
[loc_y]
$y
∧
∧
=?
[loc_x]
x
∧
=?
[loc_y]
:=
b
s ys
∧
=?
[dst_x]
x
=?
[dst_y]
d yd
∧
:=
x :=
y
[dst_x] [dst_y]
*
:=
t [time]
*
*
$d
$b
:=
d
[time] $t
−
[id]
÷
1 100
1
3 4
2
3
1
5

Experimental Evaluation
To assess the feasibility of the approach, a
simulation of a "mega-city" has been
implemented in .
Low parcel density
High parcel density

Experimental Evaluation
The simulation was instrumented so that
each action is trapped and turned into a
transaction to an external blockchain.

Blockchain Performance
Simulation is run for 100 seconds = 4
hours of real-time.
0
100
200
300
400
500
600
0 20 40 60 80 100
Size
(ko)
Time (s)
0
100
200
300
400
500
600
0 50 100 150 200 250 300
Size
(ko)
Number of actions

The blockchain reaches 532 kb (1.6 kb per
action) at the end of the simulation.
The simulation achieves 3.2 transactions
per second (Ethereum's main net can go
up to "a few dozen").
There exist networks that have much
higher processing speeds (Futurepia,
300k).
Blockchain Performance

Stream Processing
Few properties are affected by the number
of parcels (for a fixed event rate)
Throughput is much higher than the
blockchain (10⁵ to 10⁶ events per second)
Real-world estimate for Shenzen (China):
400M events per day (i.e. 4,000/s)

Conclusion
Lifecycle and analytical properties can be
evaluated on a stream extracted from a
blockchain
Bottleneck likely to be the blockchain
transaction speed
Future work:
monitor directly in smart contract?
fine-grained diagnostics?

3
{
f
0
>
Σ
1
×
2
!
?
0
4
0
4
0
4
2
0
2
0
4
f
>
⊥
2
0
2
0
2
Σ
1
×
0
1
2
0
3
2
0
4
3
{
0
2
0 0
2
0
2
3
1
1
2
4
3
0
4
5
5
?
1
⊥
2
⊥
3
⊥
4
⊥
S. Hallé. Explainable Queries over Event Logs. EDOC 2020.
Conclusion

Thank You!
https://liflab.ca
https://github.com/liflab/bb-palette-blockchain
HOME

Smart Contracts-Enabled Simulation for Hyperconnected Logistics

More Related Content

Similar to Smart Contracts-Enabled Simulation for Hyperconnected Logistics

More from Sylvain Hallé

Recently uploaded

Smart Contracts-Enabled Simulation for Hyperconnected Logistics