@1delta/abis 0.0.16 → 0.0.18
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/dolomite/borrowPositionProxy.d.ts +77 -0
- package/dist/dolomite/borrowPositionProxy.d.ts.map +1 -0
- package/dist/dolomite/borrowPositionProxy.js +61 -0
- package/dist/dolomite/depositWithdrawalProxy.d.ts +164 -0
- package/dist/dolomite/depositWithdrawalProxy.d.ts.map +1 -0
- package/dist/dolomite/depositWithdrawalProxy.js +141 -0
- package/dist/dolomite/dolomiteMargin.d.ts +271 -0
- package/dist/dolomite/dolomiteMargin.d.ts.map +1 -0
- package/dist/dolomite/dolomiteMargin.js +185 -0
- package/dist/dolomite/dolomiteMarginOperate.d.ts +75 -0
- package/dist/dolomite/dolomiteMarginOperate.d.ts.map +1 -0
- package/dist/dolomite/dolomiteMarginOperate.js +71 -0
- package/dist/dolomite/genericTraderProxy.d.ts +146 -0
- package/dist/dolomite/genericTraderProxy.d.ts.map +1 -0
- package/dist/dolomite/genericTraderProxy.js +99 -0
- package/dist/dolomite/index.d.ts +6 -0
- package/dist/dolomite/index.d.ts.map +1 -0
- package/dist/dolomite/index.js +5 -0
- package/dist/fluid/index.d.ts +1 -0
- package/dist/fluid/index.d.ts.map +1 -1
- package/dist/fluid/index.js +1 -0
- package/dist/fluid/vaultFactory.d.ts +14 -0
- package/dist/fluid/vaultFactory.d.ts.map +1 -0
- package/dist/fluid/vaultFactory.js +17 -0
- package/dist/index.d.ts +2 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2 -1
- package/package.json +1 -1
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
export declare const BorrowPositionProxyV1Abi: readonly [{
|
|
2
|
+
readonly inputs: readonly [{
|
|
3
|
+
readonly name: "fromAccountNumber";
|
|
4
|
+
readonly type: "uint256";
|
|
5
|
+
}, {
|
|
6
|
+
readonly name: "toAccountNumber";
|
|
7
|
+
readonly type: "uint256";
|
|
8
|
+
}, {
|
|
9
|
+
readonly name: "collateralMarketId";
|
|
10
|
+
readonly type: "uint256";
|
|
11
|
+
}, {
|
|
12
|
+
readonly name: "amountWei";
|
|
13
|
+
readonly type: "uint256";
|
|
14
|
+
}, {
|
|
15
|
+
readonly name: "balanceCheckFlag";
|
|
16
|
+
readonly type: "uint8";
|
|
17
|
+
}];
|
|
18
|
+
readonly name: "openBorrowPosition";
|
|
19
|
+
readonly outputs: readonly [];
|
|
20
|
+
readonly stateMutability: "nonpayable";
|
|
21
|
+
readonly type: "function";
|
|
22
|
+
}, {
|
|
23
|
+
readonly inputs: readonly [{
|
|
24
|
+
readonly name: "borrowAccountNumber";
|
|
25
|
+
readonly type: "uint256";
|
|
26
|
+
}, {
|
|
27
|
+
readonly name: "toAccountNumber";
|
|
28
|
+
readonly type: "uint256";
|
|
29
|
+
}, {
|
|
30
|
+
readonly name: "collateralMarketIds";
|
|
31
|
+
readonly type: "uint256[]";
|
|
32
|
+
}];
|
|
33
|
+
readonly name: "closeBorrowPosition";
|
|
34
|
+
readonly outputs: readonly [];
|
|
35
|
+
readonly stateMutability: "nonpayable";
|
|
36
|
+
readonly type: "function";
|
|
37
|
+
}, {
|
|
38
|
+
readonly inputs: readonly [{
|
|
39
|
+
readonly name: "fromAccountNumber";
|
|
40
|
+
readonly type: "uint256";
|
|
41
|
+
}, {
|
|
42
|
+
readonly name: "toAccountNumber";
|
|
43
|
+
readonly type: "uint256";
|
|
44
|
+
}, {
|
|
45
|
+
readonly name: "marketId";
|
|
46
|
+
readonly type: "uint256";
|
|
47
|
+
}, {
|
|
48
|
+
readonly name: "amountWei";
|
|
49
|
+
readonly type: "uint256";
|
|
50
|
+
}, {
|
|
51
|
+
readonly name: "balanceCheckFlag";
|
|
52
|
+
readonly type: "uint8";
|
|
53
|
+
}];
|
|
54
|
+
readonly name: "transferBetweenAccounts";
|
|
55
|
+
readonly outputs: readonly [];
|
|
56
|
+
readonly stateMutability: "nonpayable";
|
|
57
|
+
readonly type: "function";
|
|
58
|
+
}, {
|
|
59
|
+
readonly inputs: readonly [{
|
|
60
|
+
readonly name: "fromAccountNumber";
|
|
61
|
+
readonly type: "uint256";
|
|
62
|
+
}, {
|
|
63
|
+
readonly name: "borrowAccountNumber";
|
|
64
|
+
readonly type: "uint256";
|
|
65
|
+
}, {
|
|
66
|
+
readonly name: "marketId";
|
|
67
|
+
readonly type: "uint256";
|
|
68
|
+
}, {
|
|
69
|
+
readonly name: "balanceCheckFlag";
|
|
70
|
+
readonly type: "uint8";
|
|
71
|
+
}];
|
|
72
|
+
readonly name: "repayAllForBorrowPosition";
|
|
73
|
+
readonly outputs: readonly [];
|
|
74
|
+
readonly stateMutability: "nonpayable";
|
|
75
|
+
readonly type: "function";
|
|
76
|
+
}];
|
|
77
|
+
//# sourceMappingURL=borrowPositionProxy.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"borrowPositionProxy.d.ts","sourceRoot":"","sources":["../../src/dolomite/borrowPositionProxy.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkD3B,CAAA"}
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
// BorrowPositionProxyV1 — manage isolated sub-account positions on DolomiteMargin.
|
|
2
|
+
// These are the UNGATED, same-owner functions: they operate on `msg.sender`'s own
|
|
3
|
+
// account numbers (the proxy hardcodes the owner = msg.sender). Use THESE for a
|
|
4
|
+
// direct integration.
|
|
5
|
+
//
|
|
6
|
+
// NB: do NOT use BorrowPositionProxyV2's `...WithDifferentAccounts` variants —
|
|
7
|
+
// they are gated by a governance-managed caller allowlist (AuthorizationBase) and
|
|
8
|
+
// revert for non-whitelisted callers.
|
|
9
|
+
//
|
|
10
|
+
// `balanceCheckFlag`: Both = 0, From = 1, To = 2, None = 3
|
|
11
|
+
export const BorrowPositionProxyV1Abi = [
|
|
12
|
+
{
|
|
13
|
+
inputs: [
|
|
14
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
15
|
+
{ name: 'toAccountNumber', type: 'uint256' },
|
|
16
|
+
{ name: 'collateralMarketId', type: 'uint256' },
|
|
17
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
18
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
19
|
+
],
|
|
20
|
+
name: 'openBorrowPosition',
|
|
21
|
+
outputs: [],
|
|
22
|
+
stateMutability: 'nonpayable',
|
|
23
|
+
type: 'function',
|
|
24
|
+
},
|
|
25
|
+
{
|
|
26
|
+
inputs: [
|
|
27
|
+
{ name: 'borrowAccountNumber', type: 'uint256' },
|
|
28
|
+
{ name: 'toAccountNumber', type: 'uint256' },
|
|
29
|
+
{ name: 'collateralMarketIds', type: 'uint256[]' },
|
|
30
|
+
],
|
|
31
|
+
name: 'closeBorrowPosition',
|
|
32
|
+
outputs: [],
|
|
33
|
+
stateMutability: 'nonpayable',
|
|
34
|
+
type: 'function',
|
|
35
|
+
},
|
|
36
|
+
{
|
|
37
|
+
inputs: [
|
|
38
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
39
|
+
{ name: 'toAccountNumber', type: 'uint256' },
|
|
40
|
+
{ name: 'marketId', type: 'uint256' },
|
|
41
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
42
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
43
|
+
],
|
|
44
|
+
name: 'transferBetweenAccounts',
|
|
45
|
+
outputs: [],
|
|
46
|
+
stateMutability: 'nonpayable',
|
|
47
|
+
type: 'function',
|
|
48
|
+
},
|
|
49
|
+
{
|
|
50
|
+
inputs: [
|
|
51
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
52
|
+
{ name: 'borrowAccountNumber', type: 'uint256' },
|
|
53
|
+
{ name: 'marketId', type: 'uint256' },
|
|
54
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
55
|
+
],
|
|
56
|
+
name: 'repayAllForBorrowPosition',
|
|
57
|
+
outputs: [],
|
|
58
|
+
stateMutability: 'nonpayable',
|
|
59
|
+
type: 'function',
|
|
60
|
+
},
|
|
61
|
+
];
|
|
@@ -0,0 +1,164 @@
|
|
|
1
|
+
export declare const DepositWithdrawalProxyAbi: readonly [{
|
|
2
|
+
readonly inputs: readonly [{
|
|
3
|
+
readonly name: "toAccountNumber";
|
|
4
|
+
readonly type: "uint256";
|
|
5
|
+
}, {
|
|
6
|
+
readonly name: "marketId";
|
|
7
|
+
readonly type: "uint256";
|
|
8
|
+
}, {
|
|
9
|
+
readonly name: "amountWei";
|
|
10
|
+
readonly type: "uint256";
|
|
11
|
+
}];
|
|
12
|
+
readonly name: "depositWei";
|
|
13
|
+
readonly outputs: readonly [];
|
|
14
|
+
readonly stateMutability: "nonpayable";
|
|
15
|
+
readonly type: "function";
|
|
16
|
+
}, {
|
|
17
|
+
readonly inputs: readonly [{
|
|
18
|
+
readonly name: "marketId";
|
|
19
|
+
readonly type: "uint256";
|
|
20
|
+
}, {
|
|
21
|
+
readonly name: "amountWei";
|
|
22
|
+
readonly type: "uint256";
|
|
23
|
+
}];
|
|
24
|
+
readonly name: "depositWeiIntoDefaultAccount";
|
|
25
|
+
readonly outputs: readonly [];
|
|
26
|
+
readonly stateMutability: "nonpayable";
|
|
27
|
+
readonly type: "function";
|
|
28
|
+
}, {
|
|
29
|
+
readonly inputs: readonly [{
|
|
30
|
+
readonly name: "toAccountNumber";
|
|
31
|
+
readonly type: "uint256";
|
|
32
|
+
}, {
|
|
33
|
+
readonly name: "marketId";
|
|
34
|
+
readonly type: "uint256";
|
|
35
|
+
}, {
|
|
36
|
+
readonly name: "amountPar";
|
|
37
|
+
readonly type: "uint256";
|
|
38
|
+
}];
|
|
39
|
+
readonly name: "depositPar";
|
|
40
|
+
readonly outputs: readonly [];
|
|
41
|
+
readonly stateMutability: "nonpayable";
|
|
42
|
+
readonly type: "function";
|
|
43
|
+
}, {
|
|
44
|
+
readonly inputs: readonly [{
|
|
45
|
+
readonly name: "marketId";
|
|
46
|
+
readonly type: "uint256";
|
|
47
|
+
}, {
|
|
48
|
+
readonly name: "amountPar";
|
|
49
|
+
readonly type: "uint256";
|
|
50
|
+
}];
|
|
51
|
+
readonly name: "depositParIntoDefaultAccount";
|
|
52
|
+
readonly outputs: readonly [];
|
|
53
|
+
readonly stateMutability: "nonpayable";
|
|
54
|
+
readonly type: "function";
|
|
55
|
+
}, {
|
|
56
|
+
readonly inputs: readonly [{
|
|
57
|
+
readonly name: "toAccountNumber";
|
|
58
|
+
readonly type: "uint256";
|
|
59
|
+
}];
|
|
60
|
+
readonly name: "depositPayable";
|
|
61
|
+
readonly outputs: readonly [];
|
|
62
|
+
readonly stateMutability: "payable";
|
|
63
|
+
readonly type: "function";
|
|
64
|
+
}, {
|
|
65
|
+
readonly inputs: readonly [];
|
|
66
|
+
readonly name: "depositPayableIntoDefaultAccount";
|
|
67
|
+
readonly outputs: readonly [];
|
|
68
|
+
readonly stateMutability: "payable";
|
|
69
|
+
readonly type: "function";
|
|
70
|
+
}, {
|
|
71
|
+
readonly inputs: readonly [{
|
|
72
|
+
readonly name: "fromAccountNumber";
|
|
73
|
+
readonly type: "uint256";
|
|
74
|
+
}, {
|
|
75
|
+
readonly name: "marketId";
|
|
76
|
+
readonly type: "uint256";
|
|
77
|
+
}, {
|
|
78
|
+
readonly name: "amountWei";
|
|
79
|
+
readonly type: "uint256";
|
|
80
|
+
}, {
|
|
81
|
+
readonly name: "balanceCheckFlag";
|
|
82
|
+
readonly type: "uint8";
|
|
83
|
+
}];
|
|
84
|
+
readonly name: "withdrawWei";
|
|
85
|
+
readonly outputs: readonly [];
|
|
86
|
+
readonly stateMutability: "nonpayable";
|
|
87
|
+
readonly type: "function";
|
|
88
|
+
}, {
|
|
89
|
+
readonly inputs: readonly [{
|
|
90
|
+
readonly name: "marketId";
|
|
91
|
+
readonly type: "uint256";
|
|
92
|
+
}, {
|
|
93
|
+
readonly name: "amountWei";
|
|
94
|
+
readonly type: "uint256";
|
|
95
|
+
}, {
|
|
96
|
+
readonly name: "balanceCheckFlag";
|
|
97
|
+
readonly type: "uint8";
|
|
98
|
+
}];
|
|
99
|
+
readonly name: "withdrawWeiFromDefaultAccount";
|
|
100
|
+
readonly outputs: readonly [];
|
|
101
|
+
readonly stateMutability: "nonpayable";
|
|
102
|
+
readonly type: "function";
|
|
103
|
+
}, {
|
|
104
|
+
readonly inputs: readonly [{
|
|
105
|
+
readonly name: "fromAccountNumber";
|
|
106
|
+
readonly type: "uint256";
|
|
107
|
+
}, {
|
|
108
|
+
readonly name: "marketId";
|
|
109
|
+
readonly type: "uint256";
|
|
110
|
+
}, {
|
|
111
|
+
readonly name: "amountPar";
|
|
112
|
+
readonly type: "uint256";
|
|
113
|
+
}, {
|
|
114
|
+
readonly name: "balanceCheckFlag";
|
|
115
|
+
readonly type: "uint8";
|
|
116
|
+
}];
|
|
117
|
+
readonly name: "withdrawPar";
|
|
118
|
+
readonly outputs: readonly [];
|
|
119
|
+
readonly stateMutability: "nonpayable";
|
|
120
|
+
readonly type: "function";
|
|
121
|
+
}, {
|
|
122
|
+
readonly inputs: readonly [{
|
|
123
|
+
readonly name: "marketId";
|
|
124
|
+
readonly type: "uint256";
|
|
125
|
+
}, {
|
|
126
|
+
readonly name: "amountPar";
|
|
127
|
+
readonly type: "uint256";
|
|
128
|
+
}, {
|
|
129
|
+
readonly name: "balanceCheckFlag";
|
|
130
|
+
readonly type: "uint8";
|
|
131
|
+
}];
|
|
132
|
+
readonly name: "withdrawParFromDefaultAccount";
|
|
133
|
+
readonly outputs: readonly [];
|
|
134
|
+
readonly stateMutability: "nonpayable";
|
|
135
|
+
readonly type: "function";
|
|
136
|
+
}, {
|
|
137
|
+
readonly inputs: readonly [{
|
|
138
|
+
readonly name: "fromAccountNumber";
|
|
139
|
+
readonly type: "uint256";
|
|
140
|
+
}, {
|
|
141
|
+
readonly name: "amountWei";
|
|
142
|
+
readonly type: "uint256";
|
|
143
|
+
}, {
|
|
144
|
+
readonly name: "balanceCheckFlag";
|
|
145
|
+
readonly type: "uint8";
|
|
146
|
+
}];
|
|
147
|
+
readonly name: "withdrawPayable";
|
|
148
|
+
readonly outputs: readonly [];
|
|
149
|
+
readonly stateMutability: "nonpayable";
|
|
150
|
+
readonly type: "function";
|
|
151
|
+
}, {
|
|
152
|
+
readonly inputs: readonly [{
|
|
153
|
+
readonly name: "amountWei";
|
|
154
|
+
readonly type: "uint256";
|
|
155
|
+
}, {
|
|
156
|
+
readonly name: "balanceCheckFlag";
|
|
157
|
+
readonly type: "uint8";
|
|
158
|
+
}];
|
|
159
|
+
readonly name: "withdrawPayableFromDefaultAccount";
|
|
160
|
+
readonly outputs: readonly [];
|
|
161
|
+
readonly stateMutability: "nonpayable";
|
|
162
|
+
readonly type: "function";
|
|
163
|
+
}];
|
|
164
|
+
//# sourceMappingURL=depositWithdrawalProxy.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"depositWithdrawalProxy.d.ts","sourceRoot":"","sources":["../../src/dolomite/depositWithdrawalProxy.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkI5B,CAAA"}
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
// DepositWithdrawalProxy — base lending ops (supply / withdraw / borrow / repay)
|
|
2
|
+
// against the DolomiteMargin core. Registered as a global operator, so it acts
|
|
3
|
+
// on `msg.sender`'s own margin accounts; the only prerequisite for pull-deposits
|
|
4
|
+
// is an ERC-20 approval to the DolomiteMargin core (NOT to this proxy).
|
|
5
|
+
//
|
|
6
|
+
// `balanceCheckFlag` is the AccountBalanceLib.BalanceCheckFlag enum:
|
|
7
|
+
// Both = 0, From = 1, To = 2, None = 3
|
|
8
|
+
//
|
|
9
|
+
// Native (ETH/BNB/…) uses the `*Payable` entry points, which wrap/unwrap against
|
|
10
|
+
// the network WETH and carry the native amount as msg.value.
|
|
11
|
+
export const DepositWithdrawalProxyAbi = [
|
|
12
|
+
// ── deposits (Wei) ──
|
|
13
|
+
{
|
|
14
|
+
inputs: [
|
|
15
|
+
{ name: 'toAccountNumber', type: 'uint256' },
|
|
16
|
+
{ name: 'marketId', type: 'uint256' },
|
|
17
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
18
|
+
],
|
|
19
|
+
name: 'depositWei',
|
|
20
|
+
outputs: [],
|
|
21
|
+
stateMutability: 'nonpayable',
|
|
22
|
+
type: 'function',
|
|
23
|
+
},
|
|
24
|
+
{
|
|
25
|
+
inputs: [
|
|
26
|
+
{ name: 'marketId', type: 'uint256' },
|
|
27
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
28
|
+
],
|
|
29
|
+
name: 'depositWeiIntoDefaultAccount',
|
|
30
|
+
outputs: [],
|
|
31
|
+
stateMutability: 'nonpayable',
|
|
32
|
+
type: 'function',
|
|
33
|
+
},
|
|
34
|
+
// ── deposits (Par) ──
|
|
35
|
+
{
|
|
36
|
+
inputs: [
|
|
37
|
+
{ name: 'toAccountNumber', type: 'uint256' },
|
|
38
|
+
{ name: 'marketId', type: 'uint256' },
|
|
39
|
+
{ name: 'amountPar', type: 'uint256' },
|
|
40
|
+
],
|
|
41
|
+
name: 'depositPar',
|
|
42
|
+
outputs: [],
|
|
43
|
+
stateMutability: 'nonpayable',
|
|
44
|
+
type: 'function',
|
|
45
|
+
},
|
|
46
|
+
{
|
|
47
|
+
inputs: [
|
|
48
|
+
{ name: 'marketId', type: 'uint256' },
|
|
49
|
+
{ name: 'amountPar', type: 'uint256' },
|
|
50
|
+
],
|
|
51
|
+
name: 'depositParIntoDefaultAccount',
|
|
52
|
+
outputs: [],
|
|
53
|
+
stateMutability: 'nonpayable',
|
|
54
|
+
type: 'function',
|
|
55
|
+
},
|
|
56
|
+
// ── deposits (native, payable) ──
|
|
57
|
+
{
|
|
58
|
+
inputs: [{ name: 'toAccountNumber', type: 'uint256' }],
|
|
59
|
+
name: 'depositPayable',
|
|
60
|
+
outputs: [],
|
|
61
|
+
stateMutability: 'payable',
|
|
62
|
+
type: 'function',
|
|
63
|
+
},
|
|
64
|
+
{
|
|
65
|
+
inputs: [],
|
|
66
|
+
name: 'depositPayableIntoDefaultAccount',
|
|
67
|
+
outputs: [],
|
|
68
|
+
stateMutability: 'payable',
|
|
69
|
+
type: 'function',
|
|
70
|
+
},
|
|
71
|
+
// ── withdrawals (Wei) ──
|
|
72
|
+
{
|
|
73
|
+
inputs: [
|
|
74
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
75
|
+
{ name: 'marketId', type: 'uint256' },
|
|
76
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
77
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
78
|
+
],
|
|
79
|
+
name: 'withdrawWei',
|
|
80
|
+
outputs: [],
|
|
81
|
+
stateMutability: 'nonpayable',
|
|
82
|
+
type: 'function',
|
|
83
|
+
},
|
|
84
|
+
{
|
|
85
|
+
inputs: [
|
|
86
|
+
{ name: 'marketId', type: 'uint256' },
|
|
87
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
88
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
89
|
+
],
|
|
90
|
+
name: 'withdrawWeiFromDefaultAccount',
|
|
91
|
+
outputs: [],
|
|
92
|
+
stateMutability: 'nonpayable',
|
|
93
|
+
type: 'function',
|
|
94
|
+
},
|
|
95
|
+
// ── withdrawals (Par) ──
|
|
96
|
+
{
|
|
97
|
+
inputs: [
|
|
98
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
99
|
+
{ name: 'marketId', type: 'uint256' },
|
|
100
|
+
{ name: 'amountPar', type: 'uint256' },
|
|
101
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
102
|
+
],
|
|
103
|
+
name: 'withdrawPar',
|
|
104
|
+
outputs: [],
|
|
105
|
+
stateMutability: 'nonpayable',
|
|
106
|
+
type: 'function',
|
|
107
|
+
},
|
|
108
|
+
{
|
|
109
|
+
inputs: [
|
|
110
|
+
{ name: 'marketId', type: 'uint256' },
|
|
111
|
+
{ name: 'amountPar', type: 'uint256' },
|
|
112
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
113
|
+
],
|
|
114
|
+
name: 'withdrawParFromDefaultAccount',
|
|
115
|
+
outputs: [],
|
|
116
|
+
stateMutability: 'nonpayable',
|
|
117
|
+
type: 'function',
|
|
118
|
+
},
|
|
119
|
+
// ── withdrawals (native, unwraps to msg.sender) ──
|
|
120
|
+
{
|
|
121
|
+
inputs: [
|
|
122
|
+
{ name: 'fromAccountNumber', type: 'uint256' },
|
|
123
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
124
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
125
|
+
],
|
|
126
|
+
name: 'withdrawPayable',
|
|
127
|
+
outputs: [],
|
|
128
|
+
stateMutability: 'nonpayable',
|
|
129
|
+
type: 'function',
|
|
130
|
+
},
|
|
131
|
+
{
|
|
132
|
+
inputs: [
|
|
133
|
+
{ name: 'amountWei', type: 'uint256' },
|
|
134
|
+
{ name: 'balanceCheckFlag', type: 'uint8' },
|
|
135
|
+
],
|
|
136
|
+
name: 'withdrawPayableFromDefaultAccount',
|
|
137
|
+
outputs: [],
|
|
138
|
+
stateMutability: 'nonpayable',
|
|
139
|
+
type: 'function',
|
|
140
|
+
},
|
|
141
|
+
];
|