Skip to content

Commit 9065b31

Browse files
wangjj9219wangjj9219
committed
impl DEXV2 to support bootstrap
1 parent 95e0d85 commit 9065b31

15 files changed

+925
-100
lines changed

‎contracts/dex/DEX.sol

+37-96
Original file line numberDiff line numberDiff line change
@@ -10,116 +10,75 @@ import {IDEX} from "./IDEX.sol";
1010
/// @dev This contracts will interact with dex pallet
1111
contract DEX is IDEX {
1212
/// @dev The DEX precompile address.
13-
address private constant PRECOMPILE =
14-
address(0x0000000000000000000000000000000000000405);
13+
address internal constant PRECOMPILE = address(0x0000000000000000000000000000000000000405);
1514

1615
/// @inheritdoc IDEX
17-
function getLiquidityPool(
18-
address tokenA,
19-
address tokenB
20-
) public view override returns (uint256, uint256) {
16+
function getLiquidityPool(address tokenA, address tokenB) public view override returns (uint256, uint256) {
2117
require(tokenA != address(0), "DEX: tokenA is zero address");
2218
require(tokenB != address(0), "DEX: tokenB is zero address");
2319

24-
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
25-
abi.encodeWithSignature(
26-
"getLiquidityPool(address,address)",
27-
tokenA,
28-
tokenB
29-
)
30-
);
20+
(bool success, bytes memory returnData) =
21+
PRECOMPILE.staticcall(abi.encodeWithSignature("getLiquidityPool(address,address)", tokenA, tokenB));
3122
assembly {
32-
if eq(success, 0) {
33-
revert(add(returnData, 0x20), returndatasize())
34-
}
23+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
3524
}
3625

3726
return abi.decode(returnData, (uint256, uint256));
3827
}
3928

4029
/// @inheritdoc IDEX
41-
function getLiquidityTokenAddress(
42-
address tokenA,
43-
address tokenB
44-
) public view override returns (address) {
30+
function getLiquidityTokenAddress(address tokenA, address tokenB) public view override returns (address) {
4531
require(tokenA != address(0), "DEX: tokenA is zero address");
4632
require(tokenB != address(0), "DEX: tokenB is zero address");
4733

48-
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
49-
abi.encodeWithSignature(
50-
"getLiquidityTokenAddress(address,address)",
51-
tokenA,
52-
tokenB
53-
)
54-
);
34+
(bool success, bytes memory returnData) =
35+
PRECOMPILE.staticcall(abi.encodeWithSignature("getLiquidityTokenAddress(address,address)", tokenA, tokenB));
5536
assembly {
56-
if eq(success, 0) {
57-
revert(add(returnData, 0x20), returndatasize())
58-
}
37+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
5938
}
6039

6140
return abi.decode(returnData, (address));
6241
}
6342

6443
/// @inheritdoc IDEX
65-
function getSwapTargetAmount(
66-
address[] memory path,
67-
uint256 supplyAmount
68-
) public view override returns (uint256) {
69-
for (uint i = 0; i < path.length; i++) {
44+
function getSwapTargetAmount(address[] memory path, uint256 supplyAmount) public view override returns (uint256) {
45+
for (uint256 i = 0; i < path.length; i++) {
7046
require(path[i] != address(0), "DEX: token is zero address");
7147
}
7248
require(supplyAmount != 0, "DEX: supplyAmount is zero");
7349

74-
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
75-
abi.encodeWithSignature(
76-
"getSwapTargetAmount(address[],uint256)",
77-
path,
78-
supplyAmount
79-
)
80-
);
50+
(bool success, bytes memory returnData) =
51+
PRECOMPILE.staticcall(abi.encodeWithSignature("getSwapTargetAmount(address[],uint256)", path, supplyAmount));
8152
assembly {
82-
if eq(success, 0) {
83-
revert(add(returnData, 0x20), returndatasize())
84-
}
53+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
8554
}
8655

8756
return abi.decode(returnData, (uint256));
8857
}
8958

9059
/// @inheritdoc IDEX
91-
function getSwapSupplyAmount(
92-
address[] memory path,
93-
uint256 targetAmount
94-
) public view override returns (uint256) {
95-
for (uint i = 0; i < path.length; i++) {
60+
function getSwapSupplyAmount(address[] memory path, uint256 targetAmount) public view override returns (uint256) {
61+
for (uint256 i = 0; i < path.length; i++) {
9662
require(path[i] != address(0), "DEX: token is zero address");
9763
}
9864
require(targetAmount != 0, "DEX: targetAmount is zero");
9965

100-
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
101-
abi.encodeWithSignature(
102-
"getSwapSupplyAmount(address[],uint256)",
103-
path,
104-
targetAmount
105-
)
106-
);
66+
(bool success, bytes memory returnData) =
67+
PRECOMPILE.staticcall(abi.encodeWithSignature("getSwapSupplyAmount(address[],uint256)", path, targetAmount));
10768
assembly {
108-
if eq(success, 0) {
109-
revert(add(returnData, 0x20), returndatasize())
110-
}
69+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
11170
}
11271

11372
return abi.decode(returnData, (uint256));
11473
}
11574

11675
/// @inheritdoc IDEX
117-
function swapWithExactSupply(
118-
address[] memory path,
119-
uint256 supplyAmount,
120-
uint256 minTargetAmount
121-
) public override returns (bool) {
122-
for (uint i = 0; i < path.length; i++) {
76+
function swapWithExactSupply(address[] memory path, uint256 supplyAmount, uint256 minTargetAmount)
77+
public
78+
override
79+
returns (bool)
80+
{
81+
for (uint256 i = 0; i < path.length; i++) {
12382
require(path[i] != address(0), "DEX: token is zero address");
12483
}
12584
require(supplyAmount != 0, "DEX: supplyAmount is zero");
@@ -134,27 +93,20 @@ contract DEX is IDEX {
13493
)
13594
);
13695
assembly {
137-
if eq(success, 0) {
138-
revert(add(returnData, 0x20), returndatasize())
139-
}
96+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
14097
}
14198

142-
emit Swaped(
143-
msg.sender,
144-
path,
145-
supplyAmount,
146-
abi.decode(returnData, (uint256))
147-
);
99+
emit Swaped(msg.sender, path, supplyAmount, abi.decode(returnData, (uint256)));
148100
return true;
149101
}
150102

151103
/// @inheritdoc IDEX
152-
function swapWithExactTarget(
153-
address[] memory path,
154-
uint256 targetAmount,
155-
uint256 maxSupplyAmount
156-
) public override returns (bool) {
157-
for (uint i = 0; i < path.length; i++) {
104+
function swapWithExactTarget(address[] memory path, uint256 targetAmount, uint256 maxSupplyAmount)
105+
public
106+
override
107+
returns (bool)
108+
{
109+
for (uint256 i = 0; i < path.length; i++) {
158110
require(path[i] != address(0), "DEX: token is zero address");
159111
}
160112
require(targetAmount != 0, "DEX: targetAmount is zero");
@@ -169,17 +121,10 @@ contract DEX is IDEX {
169121
)
170122
);
171123
assembly {
172-
if eq(success, 0) {
173-
revert(add(returnData, 0x20), returndatasize())
174-
}
124+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
175125
}
176126

177-
emit Swaped(
178-
msg.sender,
179-
path,
180-
abi.decode(returnData, (uint256)),
181-
targetAmount
182-
);
127+
emit Swaped(msg.sender, path, abi.decode(returnData, (uint256)), targetAmount);
183128
return true;
184129
}
185130

@@ -208,9 +153,7 @@ contract DEX is IDEX {
208153
)
209154
);
210155
assembly {
211-
if eq(success, 0) {
212-
revert(add(returnData, 0x20), returndatasize())
213-
}
156+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
214157
}
215158

216159
emit AddedLiquidity(msg.sender, tokenA, tokenB, maxAmountA, maxAmountB);
@@ -241,9 +184,7 @@ contract DEX is IDEX {
241184
)
242185
);
243186
assembly {
244-
if eq(success, 0) {
245-
revert(add(returnData, 0x20), returndatasize())
246-
}
187+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
247188
}
248189

249190
emit RemovedLiquidity(msg.sender, tokenA, tokenB, removeShare);

‎contracts/dex/DEXV2.sol

+121
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
// SPDX-License-Identifier: GPL-3.0-or-later
2+
3+
pragma solidity ^0.8.0;
4+
5+
import {IDEX} from "./IDEX.sol";
6+
import {DEX} from "./DEX.sol";
7+
import {IBootstrap} from "./IBootstrap.sol";
8+
9+
/// @title DEX Predeploy Contract, V2, support bootstrap
10+
/// @author Acala Developers
11+
/// @notice You can use this predeploy contract to call dex pallet
12+
/// @dev This contracts will interact with dex pallet
13+
contract DEXV2 is DEX, IBootstrap {
14+
/// @inheritdoc IBootstrap
15+
function getProvisionPool(address tokenA, address tokenB) public view override returns (uint256, uint256) {
16+
require(tokenA != address(0), "DEX: tokenA is zero address");
17+
require(tokenB != address(0), "DEX: tokenB is zero address");
18+
19+
(bool success, bytes memory returnData) =
20+
PRECOMPILE.staticcall(abi.encodeWithSignature("getProvisionPool(address,address)", tokenA, tokenB));
21+
assembly {
22+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
23+
}
24+
25+
return abi.decode(returnData, (uint256, uint256));
26+
}
27+
28+
/// @inheritdoc IBootstrap
29+
function getProvisionPoolOf(address who, address tokenA, address tokenB)
30+
public
31+
view
32+
override
33+
returns (uint256, uint256)
34+
{
35+
require(tokenA != address(0), "DEX: tokenA is zero address");
36+
require(tokenB != address(0), "DEX: tokenB is zero address");
37+
38+
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
39+
abi.encodeWithSignature("getProvisionPoolOf(address, address,address)", who, tokenA, tokenB)
40+
);
41+
assembly {
42+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
43+
}
44+
45+
return abi.decode(returnData, (uint256, uint256));
46+
}
47+
48+
/// @inheritdoc IBootstrap
49+
function getInitialShareExchangeRate(address tokenA, address tokenB)
50+
public
51+
view
52+
override
53+
returns (uint256, uint256)
54+
{
55+
require(tokenA != address(0), "DEX: tokenA is zero address");
56+
require(tokenB != address(0), "DEX: tokenB is zero address");
57+
58+
(bool success, bytes memory returnData) = PRECOMPILE.staticcall(
59+
abi.encodeWithSignature("getInitialShareExchangeRate(address,address)", tokenA, tokenB)
60+
);
61+
assembly {
62+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
63+
}
64+
65+
return abi.decode(returnData, (uint256, uint256));
66+
}
67+
68+
/// @inheritdoc IBootstrap
69+
function addProvision(address tokenA, address tokenB, uint256 amountA, uint256 amountB)
70+
public
71+
override
72+
returns (bool)
73+
{
74+
require(tokenA != address(0), "DEX: tokenA is zero address");
75+
require(tokenB != address(0), "DEX: tokenB is zero address");
76+
require(amountA != 0 || amountB != 0, "DEX: invalid contribution amount");
77+
78+
(bool success, bytes memory returnData) = PRECOMPILE.call(
79+
abi.encodeWithSignature(
80+
"addProvision(address,address,address,uint256,uint256)", msg.sender, tokenA, tokenB, amountA, amountB
81+
)
82+
);
83+
assembly {
84+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
85+
}
86+
87+
emit AddProvision(msg.sender, tokenA, tokenB, amountA, amountB);
88+
return true;
89+
}
90+
91+
/// @inheritdoc IBootstrap
92+
function claimDexShare(address who, address tokenA, address tokenB) public override returns (bool) {
93+
require(who != address(0), "DEX: who is zero address");
94+
require(tokenA != address(0), "DEX: tokenA is zero address");
95+
require(tokenB != address(0), "DEX: tokenB is zero address");
96+
97+
(bool success, bytes memory returnData) =
98+
PRECOMPILE.call(abi.encodeWithSignature("claimDexShare(address,address,address)", who, tokenA, tokenB));
99+
assembly {
100+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
101+
}
102+
103+
emit ClaimShare(who, tokenA, tokenB, abi.decode(returnData, (uint256)));
104+
return true;
105+
}
106+
107+
/// @inheritdoc IBootstrap
108+
function refundProvision(address who, address tokenA, address tokenB) public override returns (bool) {
109+
require(who != address(0), "DEX: who is zero address");
110+
require(tokenA != address(0), "DEX: tokenA is zero address");
111+
require(tokenB != address(0), "DEX: tokenB is zero address");
112+
113+
(bool success, bytes memory returnData) =
114+
PRECOMPILE.call(abi.encodeWithSignature("refundProvision(address,address,address)", who, tokenA, tokenB));
115+
assembly {
116+
if eq(success, 0) { revert(add(returnData, 0x20), returndatasize()) }
117+
}
118+
119+
return true;
120+
}
121+
}

0 commit comments

Comments
 (0)