-
Notifications
You must be signed in to change notification settings - Fork 1
/
index.html
2076 lines (1404 loc) · 65.1 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="description" content="Blockchain Notes" />
<meta name="author" content="Debi Prasad Mishra" />
<title>Blockchain Notes</title>
<style>
body {
max-width: fit-content;
}
pre {
white-space: pre-wrap;
}
#contents {
/* text-align: center; */
margin-left: 10%;
margin-right: 10%;
display: flex;
justify-content: space-between;
}
#to-top {
position: fixed;
bottom: 10px;
right: 10px;
background-color: #efefef;
color: black;
padding: 10px;
}
#to-top a {
text-decoration: none;
color: black;
font-weight: bold;
}
</style>
</head>
<body>
<div id="contents">
<a href="#csamm">CSAMM</a>
<a href="#cpamm">CPAMM</a>
<a href="#vault">Vault</a>
<a href="#syntetix">Syntetix</a>
<a href="#compound">Compound</a>
<a href="#uniswap">UNISWAP</a>
</div>
<div id="to-top">
<a href="#contents">Back To Top 🔝</a>
</div>
<div id="intro">
<pre>
Application Ecosystem
------------------------------
- Centralized: App that run on a single server or a single computer and performs its various functions under a single authority.
- Decentralized: also known as "dApps" or "dapps"—are digital applications that run on a blockchain network of computers instead of relying on a single computer. Because dApps are decentralized, they are free from the control and interference of a single authority.
- Dapps have their backend code (smart contracts) running on a decentralised network and not a centralized server. They use the Ethereum blockchain for data storage and smart contracts for their app logic. A smart contract is like a set of rules that live on-chain for all to see and run exactly according to those rules.
- Dapps enable peer-to-peer(P2P) communication/trading/transaction without involvement of a third-party or a middleware.
https://www.youtube.com/watch?v=HcOWNxL3Iy0
https://www.youtube.com/watch?v=3xGLc-zz9cA&list=RDLV93E_GzvpMA0&index=2
https://www.youtube.com/watch?v=93E_GzvpMA0
Blockchain and Ethereum
=======================================
- Blockchain is a shared, immutable ledger that facilitates the process of recording transactions and tracking assets in a business network. An asset can be tangible (a house, car, cash, land) or intangible (intellectual property, patents, copyrights, branding). Virtually anything of value can be tracked and traded on a blockchain network, reducing risk and cutting costs for all involved.
https://ethereum.org/en/developers/docs/intro-to-ethereum/
History
-------------------
- Oct 31, 2008: Origin of Bitcoin white paper. The paper described the creation of a system that would allow people each other directly without need for a central authority like a bank.
- The Bitcoin network was eventually brought online on Jan 2009, the original bitcoin network. The idea was based on idea of a blockchain.
- The blockchain tech was then evolved and used to create different complex applications
- So, was the born of Ethereum, to enable creation of decentralised autonomous corporation
- It introduced the idea of Smart Contract as an entity that can send and receive currency, beyond the humans.
- The Ethereum network became online on july 30th 2015.
Types of blockchain networks
---------------------------------------
- Public blockchain networks
A public blockchain is one that anyone can join and participate in, such as Bitcoin. Drawbacks might include substantial computational power required, little or no privacy for transactions, and weak security. These are important considerations for enterprise use cases of blockchain.
- Private blockchain networks
A private blockchain network, similar to a public blockchain network, is a decentralized peer-to-peer network. However, one organization governs the network, controlling who is allowed to participate, execute a consensus protocol and maintain the shared ledger. Depending on the use case, this can significantly boost trust and confidence between participants. A private blockchain can be run behind a corporate firewall and even be hosted on premises.
- Permissioned blockchain networks
Businesses who set up a private blockchain will generally set up a permissioned blockchain network. It is important to note that public blockchain networks can also be permissioned. This places restrictions on who is allowed to participate in the network and in what transactions. Participants need to obtain an invitation or permission to join.
- Consortium blockchains
Multiple organizations can share the responsibilities of maintaining a blockchain. These pre-selected organizations determine who may submit transactions or access the data. A consortium blockchain is ideal for business when all participants need to be permissioned and have a shared responsibility for the blockchain.
Bitcoin:
A Peer-to-Peer Electronic Cash System (https://bitcoin.org/bitcoin.pdf)
Ethereum:
The Ultimate Smart Contract and Decentralized Application Platform (http://web.archive.org/web/20131228111141/http://vbuterin.com/ethereum.html)
What is Ethereum
--------------------------------
- In Ethereum, we are dealing with a series of computers and networks.
- Ethereum networks are used to transfer money and store data.
- There are many Ethereum networks. like Main, Test, Private...
- Networks are formed by one or more nodes.
- Each node is a machine running an ethereum client
- Anyone can run a node
- Each node can contain a full copy of the blockchain.
- The blockchain is a database that stores a record of every movement of money between different parties or record of every transaction that has ever taken place.
Interfacing with Ethereum Networks
--------------------------------------------
- For Developers: web3.js
- For Consumers: Extension: Metamask
Mint Browser
Metamask Account
-----------------------
Account Address: unique identifier
Public Key:
Private Key:
- public and private key combinely form a password to send funds
- Account Address, public and private key are stored as hexadecimal numbers
- To see the decimal value, in web console, write
0x<hex_number>
Ethereum Networks
------------------------
Main Network
Ropsten Test Network
Kovan Test Network
Rinkeby Test Network
Goerli Test Network
localhost 8545
https://faucets.chain.link/rinkeby
https://faucet.rinkeby.io/
https://www.rinkeby.io/#stats
What is a transaction
--------------------------------
- A transaction is described as one account attempting to send money to another account
- During transaction, a object is created and submitted to Ethereum network to be processed
- This object has different properties:
1. nonce: How many times the sender has sent a transaction
2. to: address of account this money is going to
3. value: Amount of ether to send to the target address
4. gasPrice: Amount of ether the sender is willing to pay per unit gas to get this transaction processed
5. startGas/gasLimit: units of gas that this transaction can consume
6. v:
7. r:
8: s:
Cryptographic pieces of data that can be used to generate the senders account address. Generated from the sender's private key.
- When users want to make a transaction, they must pay ether to have their transaction recognized on the blockchain. These usage costs are known as gas fees, and the gas fee depends on the amount of computing power required to execute the transaction and the network-wide demand for computing power at the time.
Mining Process
--------------------
1. When we send a transaction object into a Ethereum network, it gets connected to a node in the network
2. The node collects several of these transactions and combines them as one block to get processed in the blockchain i.e, inside the node.
3. The node then runs some validation logic on the block to make this authentic, and that validation logic takes some amount of time to run and provide a response and is called mining or crypto-mining.
https://andersbrownworth.com/blockchain/
Block Time
----------------------
- The amount of time it takes to find an appropriate nonce value to generate a required hash and complete the mining process is called block time.
- Ethereum network has an ideal target block-time of 15 secs. After that the network will move to next block. But in practice, it is variable.
Smart Contracts
--------------------------
- An account controlled by code.
Contract Account
-------------------
Fields Description
----------- ----------------
balance Amount of ether this account owns
storage Data storage for this contract
code Raw machine code for this contract
- The Metamask account owned by User/Individual, it is a external account. They are completel de-coupled from an individual networks, and reside in their own universe.
- It can be used to connect to any of the network like Main/Rinkeby/Kovan...
- Contract Accounts are specific to individual network. It can not be accessed in other network.
Solidity
----------------
- A programming language invented for developing smart contracts
- Written in .sol files
- strongly typed
- similar to javascript
- Has several huge gigantic 'gotchas'
Contract Definition
(Solidity)
|
|
v
Solidity Compiler
|
|
---------------------------------
V V
Byte code Application Binary
ready for Interface (ABI)
deployment
https://remix.ethereum.org/
A Simple Contract
-----------------------
pragma solidity ^0.4.17;
contract Inbox {
string public message;
function Inbox(string initialMessage) public {
message = initialMessage;
}
function setMessage(string newMessage) public {
message = newMessage;
}
function getMessage() public view returns (string) {
return message;
}
}
pragma solidity ^0.4.17;
Specifies the version of solidity that our code is written with
contract Inbox {
Defines a new contract(like classes) that will have some number of methods and variables
string public message;
Storage/Instance variable that will exist for the life of the contract.
type scope <variable-name>;
function Inbox(string initialMessage) public {
Constructor function, automatically ccalled when the contract is first created
Variable Declrations
--------------------------
Basic Types
--------------------
string Sequence of characters "Hi There"
bool Boolean Value true / false
int Integer, positive / negative, 1, -200, 0
no decimal
uint Unsigned Integer, Positive number 0, 10, 1000
no decimal
fixed / ufixed Fixed point number, Number with decimal 20.01, -10.23
address Has methods tied to it for sending money 0x141bhjv1g41v2412j4k14hj1b24h1j...
Reference Types
-----------------------
fixed array Array that contains a single type of element. Has an unchanging length. int[3] -> [1, 2, 3]
dynamic array Array that contains a single type of element. Can change in size over time. int[] -> [1, 2, 3]
mapping Collection of key, value pairs. Think of objects in JS, Ruby hashes, Python mapping(int => bool)
dictionaries, Java Maps. All keys must be of same type, and all values mapping (string => string)
must be of the same type.
struct Collection of key value pairs that can have different types struct Car {
string make;
string model;
uint value;
}
Function Declarations
----------------------------
function <function-name>() <function-type> <return-type> {
}
function types
-----------------
public - Anyone can call this function
private - Only this contract can call this function
view - This function returns data and does not modify the contract's data, can read data from blockchain
OR
constant - This function returns data and does not modify the contract's data
pure - This function will not modify or even read the contract's data, can not read data from blockchain
payable - When someone call this function they might send ether along
/////////////////////////////////////////////
public - all can access
external - Can NOT be accessed internally, only externally
internal - only this contract and contracts deriving from it can access
private - can be accessed only from this contract
/*
// Getter method is provided by compiler if the storage scope is public
function getMessage() public view returns (string) {
return message;
}
*/
Behind the scene
------------------------------
- Creating a contract is very similar to transfer of money between two parties.
- whenever we want to send money from one person to another we are going to create a new transaction.
- This transaction will have the purpose to create a new contract. and we are going to send that from our account to a specific network and that's what make sure that specific network(rinkeby) attempts to create a new contract.
External account to create a Contract Transaction
-----------------------------------------------------
1. nonce: How many times the sender has sent a transaction
2. to: <BLANK>, this shows we are going to create a new contract
3. data: Compiled bytecode of the contract
3. value: Amount of Wei to send to the target address
4. gasPrice: Amount of Wei the sender is willing to pay per unit gas to get this transaction processed
5. startGas/gasLimit: units of gas that this transaction can consume
6. v:
7. r:
8: s:
Cryptographic pieces of data that can be used to generate the senders account address. Generated from the sender's private key.
- Any time we want to change any data in blockchain, we have to submit a transaction and wait for it to be mined, or to go through that validation algorithm which can take from 10 to 30 secs to get approved.
- In above contract, setMessage involves a transaction as it is modifying the message data that is stored in Inbox contract, however, getMessage des not involve a transaction.
- There are 2 ways in which we invoke functions that belong to our contracts and they result in very different behaviour.
Calling a Function Sending a transaction to a function
---------------------- ----------------------------------------
Can not modify contract's data Can modify contract's data
Can return data Returns transaction hash
Runs instantly Takes time to execute
Free to do Costs money!
Wei vs Ether
---------------
- They're different unit of measurement for Ethereum.
like 1$ = 100cents
1 Ether = 1,000,000,000,000,000,000 wei
- other units: wei, Gwei, Finney, Ether
Gas and Transaction
---------------------------------
- In order to get someone else or some other service to run our contracts we have to pay them some money.
- This mone is reflected in terms of gas
- When we send a transaction to Ethereum network, there is some amount of gas price attached to it.
- Search google for gas price for yellow paper
- GasPrice: Amount of wei the sender is willing to pay per unit gas to get this transaction processed
- startGas/gasLimit: units of gas that this transaction can consume
- Total cost to execute one transaction:
gasPrice * gasRequired
Mnemonic Phrases
-----------------------------
- BIP39 mnemonic algorithm
https://iancoleman.io/bip39/
- Generate accounts from 12 word mnemonic
Contract deployment
-------------------------
- To deploy remix editor takes care of that but for production, we need to use our own editor
- To generate ABI and the byteCode, we use "Truffle"
Truffle
--------------
Contract Creation
Local Testing ----------> Rinkeby
Deployment
- https://trufflesuite.com/
Boilerplate Design
---------------------------
Issue Solution
--------- -----------------------
Need to be able to Set up the Solidity compiler
write Solidity code to build our contracts
in a JS project
Need some way to Set up a custom Mocha test
rapidly test contracts runner that can somehow test
without doing the manual Solidity code
testing like in remix
Need some way to deploy Set up a deploy script to
our contract to public compile + deploy our contract
networks
- solc lib for solidity compiler
- Ganache/TestRPC to create a local Eth Test Network
- web3 lib as a portal to connect with contract
directory structure
contracts
scripts
tests
>> npm i solc mocha ganache-cli [email protected]
Web3.js
------------------
- require the constructor function from web3
- create and instance of it
- To create an instance we need to make some configuration and we have to set up a "provider"
- provider can be thought of as a communication layer between web3 and some Ethereum Network
- Every provider connecting to different networks has identical set of networks on it
- They allow web3 to send request and receive response
Testing with Mocha
------------------------------
it Run a test and make an assertion
describe Groups together "it" functions
beforeEach Execute some general setup code
class Car {
park() {
return "stopped";
}
drive() {
return "vroom";
}
}
let car;
beforeEach("Car setup", () => {
car = new Car();
});
describe("Car", () => {
it("car parking", () => {
// const car = new Car();
assert.equal(car.park(), "stopped");
// assert.equal(car.park(), "stoppedd");
});
it("car drive", () => {
// const car = new Car();
assert.equal(car.drive(), "vroom");
});
});
Control Flow
------------------
1. Mocha Starts
2. Deploy a new contract (beforeEach)
3. Manipulate the contract (it)
4. Make an assertion about the contract (it) ----> go to 2
Infura API
-------------------------
- Like ganache, but deploys to real rinkeby test network
https://infura.io/
PROJECT ID
4279d3142bcf4543bd4e27b2fe31738c
PROJECT SECRET
338c0a6ceb184ae68e00f060f1e40375
ENDPOINTS
RINKEBY
https://rinkeby.infura.io/v3/4279d3142bcf4543bd4e27b2fe31738c
wss://rinkeby.infura.io/ws/v3/4279d3142bcf4543bd4e27b2fe31738c
>> npm i truffle-hdwallet-provider
- Whenever we create an instance and initiate a function call / transaction, a global object is assigned to it and that is "msg" object.
- It contains some properties / metadata about the contract.
msg.data "Data" field from the call or transaction that invoked the current transaction
msg.gas Amount of gas the current function invocation has available
msg.sender Address of the account that started the current function invocation
msg.value Amount of ether(in wei) that was sent along with the function invocation.
NOTE: Return dynamic string array
-------------------------------------------
// SPDX-License-Identifier: GPL-3.0
// pragma solidity ^0.4.17;
pragma solidity >=0.7.0 <0.9.0;
contract Lottery {
address public manager;
string[] public array;
// function Lottery() public {
constructor () {
manager = msg.sender;
array.push("hi");
}
function getData() public view returns (string[] memory) {
return array;
}
}
NOTE: Lottery Contract
-----------------------------------
pragma solidity ^0.4.17;
contract Lottery {
address public manager;
address[] public players;
function Lottery() public {
manager = msg.sender;
}
function enter() public payable {
require(msg.value > 0.01 ether);
players.push(msg.sender);
}
function random() private view returns(uint) {
// sha3(block.difficulty, now, players);
return uint(keccak256(block.difficulty, now, players));
}
function pickWinner() public restricted{
// require(msg.sender == manager);
uint index = random() % players.length;
players[index].transfer(this.balance);
players = new address[](0);
}
modifier restricted() {
require(msg.sender == manager);
_;
}
function getPlayers() public view returns(address[]) {
return players;
}
}
Frontend Ethereum App Architecture
================================================
HTML/JS Assets Reading from the
+<----------<---------<-----------------<------ Server block chain can
| be done on the server
Client |
|
| Web3
+----------------------> Metamask ---------------> Ethereum Network
Public/Private Transaction
keys
Solving Real World Applications
============================================
- Campaign scam or fraud
Campaign Contract
----------------------------
Request Struct:
description string Describes why the request is being created
value uint Amount of money that the manager wants to send
recipient address address that the money will be sent to
complete bool True if request has aready been processed
??? ??? voting mechanism
Storage vs Memory
--------------------------------
- Sometimes references where our contract stores data
- Sometimes references how our solidity variables store values
Storage: Holds data between function calls (like hard drive): like heap memory
Memory: Temporary place to store data (like RAM): function arguments: like stack memory
calldata: Like memory but can be used only in function inputs, and the data is not modifiable
: while passing arguments to another function, for "memory", it creates a copy, but for calldata, it doesn't resulting in saving gas
NOTE: Example on storage and memory
pragma solidity ^0.4.17;
contract Numbers {
int[] public numbers;
function Numbers() public {
numbers.push(10);
numbers.push(20);
changeArray(numbers);
}
// function changeArray(int[] array) private {
// function changeArray(int[] memory array) private {
function changeArray(int[] storage array) private {
array[0] = 1;
}
}
- default is "memory", make a copy of the numbers and send it to changeArray function.
- "storage" keyword specifies do not make a copy of the array and send the array as such.
Mapping vs Arrays
-----------------------------
Key-value pairs
Array: Linear search
Mapping: Constant Search like Hashes of HashMap
Mappings
----------------
- Keys are not stored
- Search happens through Hash Table
- Values are not iterable
- All values exist
NOTE: Campaign Contract
-------------------------------
pragma solidity ^0.4.17;
contract CampaignFactory {
address[] public deployedCampaigns;
function createCampaign(uint minimum) public {
address newCampaign = new Campaign(minimum, msg.sender);
deployedCampaigns.push(newCampaign);
}
function getDeployedCampaigns() public view returns(address[]) {
return deployedCampaigns;
}
}
contract Campaign {
struct Request { // struct is a type just like string / uint
string description;
uint value;
address recipient;
bool complete;
uint approvalCount;
mapping(address => bool) approvals;
}
Request[] public requests;
address public manager;
uint public minimumContribution;
// address[] public approvers;
mapping(address => bool) public approvers;
uint public approversCount;
modifier restricted() {
require(msg.sender == manager);
_;
}
function Campaign(uint minimum, address creator) public {
manager = creator;
minimumContribution = minimum;
}
function contribute() public payable {
require(msg.value > minimumContribution);
// approvers.push(msg.sender);
approvers[msg.sender] = true;
approversCount++;
}
function createRequest(string description, uint value, address recipient) public restricted {
Request memory newRequest = Request({
description: description,
value: value,
recipient: recipient,
complete: false,
approvalCount: 0
});
/*
Alterntive syntax: pass values in order
Request req = Request(description, value, recipient, false);
*/
requests.push(newRequest);
}
function approveRequest(uint index) public {
Request storage request = requests[index];
require(approvers[msg.sender]);
require(!request.approvals[msg.sender]);
request.approvals[msg.sender] = true;
request.approvalCount++;
}
function finaliseRequest(uint index) public restricted {
Request storage request = requests[index];
require(request.approvalCount > (approversCount / 2));
require(!request.complete);
request.recipient.transfer(request.value);
request.complete = true;
}
}
Truffle Suite
=================================
https://trufflesuite.com/tutorial/index.html
- npm i -g truffle
>> truffle unbox pet-shop
Directory structure
The default Truffle directory structure contains the following:
- contracts/: Contains the Solidity source files for our smart contracts. There is an important contract in here called Migrations.sol, which we'll talk about later.
- migrations/: Truffle uses a migration system to handle smart contract deployments. A migration is an additional special smart contract that keeps track of changes.
- test/: Contains both JavaScript and Solidity tests for our smart contracts
- truffle-config.js: Truffle configuration file
The pet-shop Truffle Box has extra files and folders in it, but we won't worry about those just yet
DeFI
==================
Pillars of DeFI
- StableCoin
- Lending and Borrowing
- Decentralized Exchanges
- Insurance
- Margin Trading
</pre>
</div>
<div id="csamm">
<pre>
AMM (Automated Market Maker)
==============================================
- It is DEX where the price of a token is determined by mathematical equation defined in the contract.
- This is wrt centralized exchange, where the price of an asset/token is determined by traders
- You can
1. Add Liquidity
2. Swap
3. Remove Liquidity
in an AMM
- When an user adds Liquidity, they are adding tokens into the AMM and is called a Liquidity Provider
- When a users provides liquidity the AMM mints shares back to the user.
- The share represents partial ownership of the total liquidity
- A swap is when a user trades a token
- User trading 10 Token B to get 10 Token A
- Remove Liquidity
- An user is withdrawing his tokens in exchange for his shares
- the amount of tokens being traded and the amount of tokens user gets back when the user calls remove liquidity depends on the AMM
Questins to ask
- Why this AMM is called CSAMM
- How many tokens does a user get back in a trade
- How many shares are minted when a liquidity provider adds liquidity
- How many tokens does a liquidity provider get back when the liquidity provider removes liquidity.
=> CSAMM : Constant Sum Automated Market Maker
---------------------------------------------------------
price of tokens are determined by equation:
X + Y = K
X = amount of token A in the AMM
Y = amount of token B in the AMM
upon added we get a constant called K
- when a user trades in CSAMM, the cconstant K must remain same regarless of X and Y changes.
example:
User sells token A and buy Token B
dx = amount of token A coming in
dy = amount of token B going out
B
|