w8 · tx · 6gH···vPz

tx · 6gHBgENsotbG5F4UtyAVR6rPs49dpK4euuHh7AUaovPz

3MzqQ3HKdkHmJmk9mDhAeAMxmK5D2ztdAe5:  -0.14000000 Waves

2022.11.16 13:42 [2319559] smart account 3MzqQ3HKdkHmJmk9mDhAeAMxmK5D2ztdAe5 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6gHBgENsotbG5F4UtyAVR6rPs49dpK4euuHh7AUaovPz",
    "fee": 14000000,
    "feeAssetId": null,
    "timestamp": 1668595358404,
    "version": 2,
    "chainId": 84,
    "sender": "3MzqQ3HKdkHmJmk9mDhAeAMxmK5D2ztdAe5",
    "senderPublicKey": "FEnkfXnQZkk1FmjhH6QZqyK2taN6ngnZBexevKxouLUM",
    "proofs": [
        "2VLMpBbZxbtxw19hE47NK4jYL1YsTfW3BE7pAY61CQPc14H6hmcwE1HmbeEBGHRJRHfJWHYK29vgecCG3G6XQiLT",
        "3eNLr6MLvyS2ZrpqeUGUc22mwnQaDCXfMJbFeecrTyKwdWvA8axvoagqd7Do4SzHHSZnvauKb4sgnGovKdMJtwqG"
    ],
    "script": "base64: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",
    "height": 2319559,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EXjsEDasfUDCeLqiocpK38baYdeKgfySzDbtYJmEpT2c
Next: DPyp1jZciazAD3rf9Q7azcsWbqaaB7Unonk6KPBh4d2T

Diff: 
Old New Differences
741 741          else $Tuple2(0, shareAssetId)
742 742      let pmtAmount = $t03012630534._1
743 743      let pmtAssetId = $t03012630534._2
744 -     if ((size(args) != 3))
744 +     if ((size(args) != 1))
745 745          then throw("Wrong args size")
746 746          else if ((size(pAmounts) > 1))
747 747              then throw("One attached payment expected")
810 810      let virtMinToRecive = parseIntValue(args[1])
811 811      if ((size(args) != 3))
812 812          then throw("Wrong args size")
813 -         else if ((size(pAmounts) != 1))
813 +         else if ((size(pAmounts) > 1))
814 814              then throw("One attached payment expected")
815 815              else if ((pmtAssetId != shareAssetId))
816 816                  then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
830 830                                      let withdrawAmount = (pmtAmount + unlockAmount)
831 831                                      let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
832 832                                      let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
833 -                                     let $t03481434872 = getFeeParams(i.caller, i.originCaller)
834 -                                     let fee = $t03481434872._1
835 -                                     let govFee = $t03481434872._2
836 -                                     let $t03488935289 = if ((withdrawAsset == assetIdA))
833 +                                     let $t03481334871 = getFeeParams(i.caller, i.originCaller)
834 +                                     let fee = $t03481334871._1
835 +                                     let govFee = $t03481334871._2
836 +                                     let $t03488835288 = if ((withdrawAsset == assetIdA))
837 837                                          then calculateFees(amountToPayB, virtMinToRecive, (balanceB - amountToPayB), (balanceA - amountToPayA), fee, govFee)
838 838                                          else calculateFees(amountToPayA, virtMinToRecive, (balanceA - amountToPayA), (balanceB - amountToPayB), fee, govFee)
839 -                                     let amountWithoutFee = $t03488935289._1
840 -                                     let amountWithFee = $t03488935289._2
841 -                                     let governanceReward = $t03488935289._3
842 -                                     let $t03530636652 = if ((withdrawAsset == assetIdA))
839 +                                     let amountWithoutFee = $t03488835288._1
840 +                                     let amountWithFee = $t03488835288._2
841 +                                     let governanceReward = $t03488835288._3
842 +                                     let $t03530536651 = if ((withdrawAsset == assetIdA))
843 843                                          then {
844 844                                              let unstake = if (contains(stakingAssets, strAssetIdA))
845 845                                                  then invoke(i.caller, "stakeUnstake", [false, ((amountToPayA + amountWithFee) + governanceReward), strAssetIdA], nil)
856 856                                                  then $Tuple4(balanceA, (((balanceB - amountToPayB) - amountWithFee) - governanceReward), assetIdB, [ScriptTransfer(caller, (amountToPayB + amountWithFee), assetIdB)])
857 857                                                  else throw("Strict value is not equal to itself.")
858 858                                              }
859 -                                     let newBalanceA = $t03530636652._1
860 -                                     let newBalanceB = $t03530636652._2
861 -                                     let govRewardAssetId = $t03530636652._3
862 -                                     let userTransfer = $t03530636652._4
859 +                                     let newBalanceA = $t03530536651._1
860 +                                     let newBalanceB = $t03530536651._2
861 +                                     let govRewardAssetId = $t03530536651._3
862 +                                     let userTransfer = $t03530536651._4
863 863                                      $Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(moneyBoxAddress, governanceReward, govRewardAssetId)] ++ userTransfer), nil))
864 864                                      }
865 865                                  else throw("Strict value is not equal to itself.")
870 870  
871 871  @Callable(i)
872 872  func takeIntoAccountExtraFunds (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
873 -     let $t03737737453 = getPoolAssets(i.caller)
874 -     let strAssetIdA = $t03737737453._1
875 -     let strAssetIdB = $t03737737453._2
876 -     let assetIdA = $t03737737453._3
877 -     let assetIdB = $t03737737453._4
878 -     let $t03746637572 = getPoolBalances(i.caller, assetIdA, assetIdB)
879 -     let balanceA = $t03746637572._1
880 -     let balanceB = $t03746637572._2
881 -     let accountBalanceA = $t03746637572._3
882 -     let accountBalanceB = $t03746637572._4
873 +     let $t03737637452 = getPoolAssets(i.caller)
874 +     let strAssetIdA = $t03737637452._1
875 +     let strAssetIdB = $t03737637452._2
876 +     let assetIdA = $t03737637452._3
877 +     let assetIdB = $t03737637452._4
878 +     let $t03746537571 = getPoolBalances(i.caller, assetIdA, assetIdB)
879 +     let balanceA = $t03746537571._1
880 +     let balanceB = $t03746537571._2
881 +     let accountBalanceA = $t03746537571._3
882 +     let accountBalanceB = $t03746537571._4
883 883      let amountEnrollA = (accountBalanceA - balanceA)
884 884      let amountEnrollB = (accountBalanceB - balanceB)
885 885      if ((size(args) != 0))
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let version = "1.0.0"
5 5  
6 6  let kVersion = "version"
7 7  
8 8  let kActive = "active"
9 9  
10 10  let kAssetIdA = "A_asset_id"
11 11  
12 12  let kAssetIdB = "B_asset_id"
13 13  
14 14  let kBalanceA = "A_asset_balance"
15 15  
16 16  let kBalanceB = "B_asset_balance"
17 17  
18 18  let kBalanceInitA = "A_asset_init"
19 19  
20 20  let kBalanceInitB = "B_asset_init"
21 21  
22 22  let kShareAssetId = "share_asset_id"
23 23  
24 24  let kShareAssetSupply = "share_asset_supply"
25 25  
26 26  let kFee = "commission"
27 27  
28 28  let kCause = "shutdown_cause"
29 29  
30 30  let kFirstHarvest = "first_harvest"
31 31  
32 32  let kFirstHarvestHeight = "first_harvest_height"
33 33  
34 34  let kShareLimit = "share_limit_on_first_harvest"
35 35  
36 36  let kBasePeriod = "base_period"
37 37  
38 38  let kPeriodLength = "period_length"
39 39  
40 40  let kStartHeight = "start_height"
41 41  
42 42  let kUSDNAddress = "staking_usdnnsbt_address"
43 43  
44 44  let kEURNAddress = "staking_eurn_address"
45 45  
46 46  let kLeasingAmount = "leasing_amount"
47 47  
48 48  let kUSDNAssetId = "usdn_asset_id"
49 49  
50 50  let kEURNAssetId = "eurn_asset_id"
51 51  
52 52  let kStakingAssets = "staking_assets"
53 53  
54 54  let kOracleActive = "active_all_contracts"
55 55  
56 56  let kOracleActiveExchangers = "active_global_exchangers"
57 57  
58 58  let kDiscounts = "discounts"
59 59  
60 60  let kDiscountValues = "discount_values"
61 61  
62 62  let kUserGSwopInGov = "_GSwop_amount"
63 63  
64 64  let kUserSwopInGov = "_SWOP_amount"
65 65  
66 66  let kOraclePool = "pool_"
67 67  
68 68  let kAdminPubKey1 = "admin_pub_1"
69 69  
70 70  let kAdminPubKey2 = "admin_pub_2"
71 71  
72 72  let kAdminPubKey3 = "admin_pub_3"
73 73  
74 74  let kAdminInvokePubKey = "admin_invoke_pub"
75 75  
76 76  let kMoneyBoxAddress = "money_box_address"
77 77  
78 78  let kVotingAddress = "voting_address"
79 79  
80 80  let kGovAddress = "governance_address"
81 81  
82 82  let kFarmingAddress = "farming_address"
83 83  
84 84  let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
85 85  
86 86  func getBase58FromOracle (key) = match getString(oracle, key) {
87 87      case string: String => 
88 88          fromBase58String(string)
89 89      case nothing => 
90 90          throw((key + "is empty"))
91 91  }
92 92  
93 93  
94 94  let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
95 95  
96 96  let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
97 97  
98 98  let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
99 99  
100 100  let adminInvokePubKey = getBase58FromOracle(kAdminInvokePubKey)
101 101  
102 102  let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
103 103  
104 104  let votingAddress = Address(getBase58FromOracle(kVotingAddress))
105 105  
106 106  let govAddress = Address(getBase58FromOracle(kGovAddress))
107 107  
108 108  let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
109 109  
110 110  let USDN = getBase58FromOracle(kUSDNAssetId)
111 111  
112 112  let EURN = getBase58FromOracle(kEURNAssetId)
113 113  
114 114  let stakingAssets = getStringValue(oracle, kStakingAssets)
115 115  
116 116  let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
117 117  
118 118  let stakingEURNAddress = Address(getBase58FromOracle(kEURNAddress))
119 119  
120 120  let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
121 121  
122 122  let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
123 123  
124 124  let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
125 125  
126 126  let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
127 127  
128 128  let active = if (getBooleanValue(oracle, kOracleActive))
129 129      then getBooleanValue(oracle, kOracleActiveExchangers)
130 130      else false
131 131  
132 132  let feeScale6 = 1000000
133 133  
134 134  let scale8 = 100000000
135 135  
136 136  func accountBalance (assetId,pool) = match assetId {
137 137      case id: ByteVector => 
138 138          assetBalance(pool, id)
139 139      case waves: Unit => 
140 140          wavesBalance(pool).available
141 141      case _ => 
142 142          throw("Match error")
143 143  }
144 144  
145 145  
146 146  func stakedAmount (assetId,pool) = {
147 147      let stakedAmountCalculated =     match assetId {
148 148          case aId: ByteVector => 
149 149              if ((aId == USDN))
150 150                  then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(pool)))
151 151                  else if ((aId == EURN))
152 152                      then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(pool)))
153 153                      else 0
154 154          case _: Unit => 
155 155              valueOrElse(getInteger(pool, kLeasingAmount), 0)
156 156          case _ => 
157 157              throw("Match error")
158 158      }
159 159      match stakedAmountCalculated {
160 160          case i: Int => 
161 161              i
162 162          case _ => 
163 163              0
164 164      }
165 165      }
166 166  
167 167  
168 168  func getAssetInfo (assetId) = match assetId {
169 169      case id: String|ByteVector => 
170 170          let $t040054177 =         match id {
171 171              case aId: ByteVector => 
172 172                  $Tuple2(toBase58String(aId), aId)
173 173              case aId: String => 
174 174                  $Tuple2(aId, fromBase58String(aId))
175 175              case _ => 
176 176                  throw("Match error")
177 177          }
178 178          let stringId = $t040054177._1
179 179          let bytesId = $t040054177._2
180 180          let info = valueOrErrorMessage(assetInfo(bytesId), (("Asset " + stringId) + " doesn't exist"))
181 181          $Tuple3(stringId, info.name, info.decimals)
182 182      case waves: Unit => 
183 183          $Tuple3("WAVES", "WAVES", 8)
184 184      case _ => 
185 185          throw("Match error")
186 186  }
187 187  
188 188  
189 189  func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
190 190  
191 191  
192 192  func calculateFeeDiscount (userAddr) = {
193 193      let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
194 194      let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
195 195      let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
196 196      let discounts = split(getStringValue(oracle, kDiscounts), ",")
197 197      if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
198 198          then (parseIntValue(discountValues[1]) > gSwopAmount)
199 199          else false)
200 200          then (feeScale6 - parseIntValue(discounts[0]))
201 201          else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
202 202              then (parseIntValue(discountValues[2]) > gSwopAmount)
203 203              else false)
204 204              then (feeScale6 - parseIntValue(discounts[1]))
205 205              else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
206 206                  then (parseIntValue(discountValues[3]) > gSwopAmount)
207 207                  else false)
208 208                  then (feeScale6 - parseIntValue(discounts[2]))
209 209                  else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
210 210                      then (parseIntValue(discountValues[4]) > gSwopAmount)
211 211                      else false)
212 212                      then (feeScale6 - parseIntValue(discounts[3]))
213 213                      else if ((gSwopAmount >= parseIntValue(discountValues[4])))
214 214                          then (feeScale6 - parseIntValue(discounts[4]))
215 215                          else feeScale6
216 216      }
217 217  
218 218  
219 219  func calculateFees (pmtAmount,minAmountToReceive,tokenFrom,tokenTo,fee,feeGovernance) = {
220 220      let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
221 221      let amountWithFee = fraction(amountWithoutFee, (feeScale6 - fee), feeScale6)
222 222      let governanceReward = fraction(amountWithoutFee, feeGovernance, feeScale6)
223 223      if ((minAmountToReceive > amountWithFee))
224 224          then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
225 225          else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
226 226      }
227 227  
228 228  
229 229  func calculateVirtPay (pmtAmount,balance,fee) = {
230 230      let F = (feeScale6 - fee)
231 231      let k = fraction(fee, 60, 100)
232 232      let a = (scale8 + fraction((F * k), scale8, (feeScale6 * feeScale6)))
233 233      let b = ((((balance + fraction(balance, F, feeScale6)) + fraction(pmtAmount, F, feeScale6)) - pmtAmount) - fraction(pmtAmount, (F * k), (feeScale6 * feeScale6)))
234 234      let c = (-(toBigInt(balance)) * toBigInt(pmtAmount))
235 235      let D = ((toBigInt(b) * toBigInt(b)) - fraction((toBigInt(4) * c), toBigInt(a), toBigInt(scale8)))
236 236      toInt(fraction((-(toBigInt(b)) + sqrtBigInt(D, 0, 0, DOWN)), toBigInt(scale8), toBigInt((2 * a))))
237 237      }
238 238  
239 239  
240 240  func parsePaymentAsset (assetId) = if ((assetId == base58''))
241 241      then unit
242 242      else assetId
243 243  
244 244  
245 245  func suspendSuspicious (accountBalanceA,accountBalanceB,balanceA,balanceB,assetIdA,assetIdB) = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceA)) + " ") + assetIdA) + ", ") + toString(accountBalanceB)) + " ") + assetIdB) + ". State: ") + toString(balanceA)) + " ") + assetIdA) + ", ") + toString(balanceB)) + " ") + assetIdB))
246 246  
247 247  
248 248  func isActive () = if (active)
249 249      then unit
250 250      else throw("DApp is inactive at this moment")
251 251  
252 252  
253 253  func isOraclePool (poolAddress) = if (isDefined(getString(oracle, (kOraclePool + poolAddress))))
254 254      then unit
255 255      else throw("DApp is not registered pool")
256 256  
257 257  
258 258  func getPoolBalances (pool,assetIdA,assetIdB) = {
259 259      let balanceA = getIntegerValue(pool, kBalanceA)
260 260      let balanceB = getIntegerValue(pool, kBalanceB)
261 261      let stakedAmountA = stakedAmount(assetIdA, pool)
262 262      let stakedAmountB = stakedAmount(assetIdB, pool)
263 263      let accountBalanceA = (accountBalance(assetIdA, pool) + stakedAmountA)
264 264      let accountBalanceB = (accountBalance(assetIdB, pool) + stakedAmountB)
265 265      let shareSupply = getIntegerValue(pool, kShareAssetSupply)
266 266      $Tuple5(balanceA, balanceB, accountBalanceA, accountBalanceB, shareSupply)
267 267      }
268 268  
269 269  
270 270  func getPoolAssets (pool) = {
271 271      let strAssetIdA = getStringValue(pool, kAssetIdA)
272 272      let strAssetIdB = getStringValue(pool, kAssetIdB)
273 273      let assetIdA = if ((strAssetIdA == "WAVES"))
274 274          then unit
275 275          else fromBase58String(strAssetIdA)
276 276      let assetIdB = if ((strAssetIdB == "WAVES"))
277 277          then unit
278 278          else fromBase58String(strAssetIdB)
279 279      let shareAssetId = fromBase58String(getStringValue(pool, kShareAssetId))
280 280      $Tuple5(strAssetIdA, strAssetIdB, assetIdA, assetIdB, shareAssetId)
281 281      }
282 282  
283 283  
284 284  func getFeeParams (pool,caller) = {
285 285      let feeDiscount = calculateFeeDiscount(caller)
286 286      let fee = fraction(getIntegerValue(pool, kFee), feeDiscount, feeScale6, CEILING)
287 287      let govFee = fraction(fraction(fee, 40, 100), feeDiscount, feeScale6, CEILING)
288 288      $Tuple2(fee, govFee)
289 289      }
290 290  
291 291  
292 292  @Callable(i)
293 293  func init (callerBytes,args,pAmounts,pAssetIds) = {
294 294      let caller = Address(callerBytes)
295 295      let $t091849262 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
296 296      let pmtAmountA = $t091849262._1
297 297      let pmtAssetIdA = $t091849262._2
298 298      let $t092679345 = $Tuple2(pAmounts[1], parsePaymentAsset(pAssetIds[1]))
299 299      let pmtAmountB = $t092679345._1
300 300      let pmtAssetIdB = $t092679345._2
301 301      if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
302 302          then throw("Only admin can call this function")
303 303          else if ((size(args) != 1))
304 304              then throw("Wrong args size")
305 305              else if (isDefined(getBoolean(caller, kActive)))
306 306                  then throw("DApp is already active")
307 307                  else if ((pmtAssetIdA == pmtAssetIdB))
308 308                      then throw("Assets must be different")
309 309                      else {
310 310                          let $t097809857 = getAssetInfo(pmtAssetIdA)
311 311                          let pmtStrAssetIdA = $t097809857._1
312 312                          let pmtAssetNameA = $t097809857._2
313 313                          let pmtDecimalsA = $t097809857._3
314 314                          let $t098669943 = getAssetInfo(pmtAssetIdB)
315 315                          let pmtStrAssetIdB = $t098669943._1
316 316                          let pmtAssetNameB = $t098669943._2
317 317                          let pmtDecimalsB = $t098669943._3
318 318                          let firstHarvest = (args[0] == "true")
319 319                          let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
320 320                          let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
321 321                          let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
322 322                          let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
323 323                          let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
324 324                          let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
325 325                          let shareInitialSupply = fraction(arg1, arg2, arg3)
326 326                          let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
327 327                          let shareIssueId = calculateAssetId(shareIssue)
328 328                          let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
329 329                              then invoke(i.caller, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
330 330                              else 0
331 331                          if ((stake1 == stake1))
332 332                              then {
333 333                                  let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
334 334                                      then invoke(i.caller, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
335 335                                      else 0
336 336                                  if ((stake2 == stake2))
337 337                                      then {
338 338                                          let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(caller, shareInitialSupply, shareIssueId)]
339 339                                          if (firstHarvest)
340 340                                              then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
341 341                                              else $Tuple2(nil, $Tuple2(baseEntry, nil))
342 342                                          }
343 343                                      else throw("Strict value is not equal to itself.")
344 344                                  }
345 345                              else throw("Strict value is not equal to itself.")
346 346                          }
347 347      }
348 348  
349 349  
350 350  
351 351  @Callable(i)
352 352  func initWithInitRatio (callerBytes,args,pAmounts,pAssetIds) = {
353 353      let caller = Address(callerBytes)
354 354      let $t01216412364 = $Tuple5(parseIntValue(args[0]), parseIntValue(args[1]), args[2], args[3], (args[4] == "true"))
355 355      let amtAssetA = $t01216412364._1
356 356      let amtAssetB = $t01216412364._2
357 357      let assetIdAStr = $t01216412364._3
358 358      let assetIdBStr = $t01216412364._4
359 359      let firstHarvest = $t01216412364._5
360 360      if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
361 361          then throw("Only admin can call this function")
362 362          else if ((size(args) != 5))
363 363              then throw("Wrong args size")
364 364              else if (isDefined(getBoolean(caller, kActive)))
365 365                  then throw("DApp is already active")
366 366                  else if ((assetIdAStr == assetIdBStr))
367 367                      then throw("Assets must be different")
368 368                      else {
369 369                          let $t01279912876 = getAssetInfo(assetIdAStr)
370 370                          let pmtStrAssetIdA = $t01279912876._1
371 371                          let pmtAssetNameA = $t01279912876._2
372 372                          let pmtDecimalsA = $t01279912876._3
373 373                          let $t01288512962 = getAssetInfo(assetIdBStr)
374 374                          let pmtStrAssetIdB = $t01288512962._1
375 375                          let pmtAssetNameB = $t01288512962._2
376 376                          let pmtDecimalsB = $t01288512962._3
377 377                          let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
378 378                          let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
379 379                          let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
380 380                          let shareInitialSupply = 0
381 381                          let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
382 382                          let shareIssueId = calculateAssetId(shareIssue)
383 383                          let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceInitA, amtAssetA), IntegerEntry(kBalanceInitB, amtAssetB), IntegerEntry(kBalanceA, 0), IntegerEntry(kBalanceB, 0), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply)]
384 384                          if (firstHarvest)
385 385                              then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
386 386                              else $Tuple2(nil, $Tuple2(baseEntry, nil))
387 387                          }
388 388      }
389 389  
390 390  
391 391  
392 392  @Callable(i)
393 393  func keepLimitForFirstHarvest (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
394 394      then throw("Only admin can call this function")
395 395      else if ((size(args) != 1))
396 396          then throw("Wrong args size")
397 397          else {
398 398              let shareLimit = parseIntValue(args[0])
399 399              $Tuple2(nil, $Tuple2([IntegerEntry(kShareLimit, shareLimit)], nil))
400 400              }))
401 401  
402 402  
403 403  
404 404  @Callable(i)
405 405  func exchange (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
406 406      let caller = Address(callerBytes)
407 407      let $t01534815424 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
408 408      let pmtAmount = $t01534815424._1
409 409      let pmtAssetId = $t01534815424._2
410 410      let minAmountToReceive = parseIntValue(args[0])
411 411      let $t01549715573 = getPoolAssets(i.caller)
412 412      let strAssetIdA = $t01549715573._1
413 413      let strAssetIdB = $t01549715573._2
414 414      let assetIdA = $t01549715573._3
415 415      let assetIdB = $t01549715573._4
416 416      let $t01558615692 = getPoolBalances(i.caller, assetIdA, assetIdB)
417 417      let balanceA = $t01558615692._1
418 418      let balanceB = $t01558615692._2
419 419      let accountBalanceA = $t01558615692._3
420 420      let accountBalanceB = $t01558615692._4
421 421      if ((size(args) != 1))
422 422          then throw("Wrong args size")
423 423          else if (if ((balanceA == 0))
424 424              then true
425 425              else (balanceB == 0))
426 426              then throw("Can't exchange with zero balance")
427 427              else if ((0 >= minAmountToReceive))
428 428                  then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
429 429                  else if ((size(pAmounts) != 1))
430 430                      then throw("One attached payment expected")
431 431                      else if (!(containsElement([assetIdA, assetIdB], pmtAssetId)))
432 432                          then throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
433 433                          else if (if ((balanceA > accountBalanceA))
434 434                              then true
435 435                              else (balanceB > accountBalanceB))
436 436                              then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
437 437                              else {
438 438                                  let $t01666016718 = getFeeParams(i.caller, i.originCaller)
439 439                                  let fee = $t01666016718._1
440 440                                  let govFee = $t01666016718._2
441 441                                  let $t01673517072 = if ((pmtAssetId == assetIdA))
442 442                                      then calculateFees(pmtAmount, minAmountToReceive, balanceA, balanceB, fee, govFee)
443 443                                      else calculateFees(pmtAmount, minAmountToReceive, balanceB, balanceA, fee, govFee)
444 444                                  let amountWithoutFee = $t01673517072._1
445 445                                  let amountWithFee = $t01673517072._2
446 446                                  let governanceReward = $t01673517072._3
447 447                                  let $t01709017415 = if ((pmtAssetId == assetIdA))
448 448                                      then $Tuple3((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward), assetIdB)
449 449                                      else $Tuple3(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount), assetIdA)
450 450                                  let newBalanceA = $t01709017415._1
451 451                                  let newBalanceB = $t01709017415._2
452 452                                  let assetIdSend = $t01709017415._3
453 453                                  let $t01743317683 = if ((pmtAssetId == assetIdA))
454 454                                      then $Tuple2(pmtAmount, (amountWithFee + governanceReward))
455 455                                      else $Tuple2((amountWithFee + governanceReward), pmtAmount)
456 456                                  let stakeAmountA = $t01743317683._1
457 457                                  let stakeAmountB = $t01743317683._2
458 458                                  let stake1 = if (contains(stakingAssets, strAssetIdA))
459 459                                      then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdA), stakeAmountA, strAssetIdA], nil)
460 460                                      else 0
461 461                                  if ((stake1 == stake1))
462 462                                      then {
463 463                                          let stake2 = if (contains(stakingAssets, strAssetIdB))
464 464                                              then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdB), stakeAmountB, strAssetIdB], nil)
465 465                                              else 0
466 466                                          if ((stake2 == stake2))
467 467                                              then $Tuple2(nil, $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), ScriptTransfer(caller, amountWithFee, assetIdSend), ScriptTransfer(moneyBoxAddress, governanceReward, assetIdSend)], [amountWithFee, assetIdSend]))
468 468                                              else throw("Strict value is not equal to itself.")
469 469                                          }
470 470                                      else throw("Strict value is not equal to itself.")
471 471                                  }
472 472      }))
473 473  
474 474  
475 475  
476 476  @Callable(i)
477 477  func replenishWithTwoTokens (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
478 478      let caller = Address(callerBytes)
479 479      let pmtAssetIdA = parsePaymentAsset(pAssetIds[0])
480 480      let pmtAssetIdB = parsePaymentAsset(pAssetIds[1])
481 481      let stakeFarming = (args[0] == "true")
482 482      let lockType = parseIntValue(args[1])
483 483      let $t01894619036 = getPoolAssets(i.caller)
484 484      let strAssetIdA = $t01894619036._1
485 485      let strAssetIdB = $t01894619036._2
486 486      let assetIdA = $t01894619036._3
487 487      let assetIdB = $t01894619036._4
488 488      let shareAssetId = $t01894619036._5
489 489      let $t01904919173 = getPoolBalances(i.caller, assetIdA, assetIdB)
490 490      let balanceA = $t01904919173._1
491 491      let balanceB = $t01904919173._2
492 492      let accountBalanceA = $t01904919173._3
493 493      let accountBalanceB = $t01904919173._4
494 494      let shareAssetSupply = $t01904919173._5
495 495      if ((size(args) != 2))
496 496          then throw("Wrong args size")
497 497          else if (if ((size(pAmounts) != 2))
498 498              then (size(pAmounts) != 3)
499 499              else false)
500 500              then throw("Two or three payments expected")
501 501              else if (if ((pmtAssetIdA != assetIdA))
502 502                  then true
503 503                  else (pmtAssetIdB != assetIdB))
504 504                  then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
505 505                  else if (if ((balanceA > accountBalanceA))
506 506                      then true
507 507                      else (balanceB > accountBalanceB))
508 508                      then $Tuple2(nil, ([ScriptTransfer(caller, pAmounts[0], pmtAssetIdA), ScriptTransfer(caller, pAmounts[1], pmtAssetIdB)] ++ (if ((size(pAmounts) == 3))
509 509                          then [AttachedPayment(if ((pAssetIds[2] == base58''))
510 510                              then unit
511 511                              else pAssetIds[2], pAmounts[2])]
512 512                          else (nil ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))))
513 513                      else {
514 514                          let $t02017420251 = getAssetInfo(pmtAssetIdA)
515 515                          let pmtStrAssetIdA = $t02017420251._1
516 516                          let pmtAssetNameA = $t02017420251._2
517 517                          let pmtDecimalsA = $t02017420251._3
518 518                          let $t02026820345 = getAssetInfo(pmtAssetIdB)
519 519                          let pmtStrAssetIdB = $t02026820345._1
520 520                          let pmtAssetNameB = $t02026820345._2
521 521                          let pmtDecimalsB = $t02026820345._3
522 522                          let initial = ((balanceA + balanceB) == 0)
523 523                          let $t02042021263 = if (initial)
524 524                              then $Tuple5(pAmounts[0], pAmounts[1], 0, pmtAssetIdA, 1)
525 525                              else {
526 526                                  let ratioShareTokensInA = fraction(scale8, pAmounts[0], balanceA)
527 527                                  let ratioShareTokensInB = fraction(scale8, pAmounts[1], balanceB)
528 528                                  if ((ratioShareTokensInB > ratioShareTokensInA))
529 529                                      then {
530 530                                          let pmt = fraction(pAmounts[0], balanceB, balanceA)
531 531                                          $Tuple5(pAmounts[0], pmt, (pAmounts[1] - pmt), pmtAssetIdB, ratioShareTokensInA)
532 532                                          }
533 533                                      else {
534 534                                          let pmt = fraction(pAmounts[1], balanceA, balanceB)
535 535                                          $Tuple5(pmt, pAmounts[1], (pAmounts[0] - pmt), pmtAssetIdA, ratioShareTokensInB)
536 536                                          }
537 537                                  }
538 538                          let pmtAmountA = $t02042021263._1
539 539                          let pmtAmountB = $t02042021263._2
540 540                          let change = $t02042021263._3
541 541                          let changeAssetId = $t02042021263._4
542 542                          let shareTokenRatio = $t02042021263._5
543 543                          let shareTokenToPayAmount = if (initial)
544 544                              then {
545 545                                  let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
546 546                                  fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
547 547                                  }
548 548                              else fraction(shareTokenRatio, shareAssetSupply, scale8)
549 549                          if ((shareTokenToPayAmount == 0))
550 550                              then throw("Too small amount to replenish")
551 551                              else if ((0 > change))
552 552                                  then throw("Change < 0")
553 553                                  else {
554 554                                      let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
555 555                                          then invoke(i.caller, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
556 556                                          else 0
557 557                                      if ((stake1 == stake1))
558 558                                          then {
559 559                                              let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
560 560                                                  then invoke(i.caller, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
561 561                                                  else 0
562 562                                              if ((stake2 == stake2))
563 563                                                  then {
564 564                                                      let shareTokenST = if (stakeFarming)
565 565                                                          then {
566 566                                                              let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(pAmounts) == 3))
567 567                                                                  then [AttachedPayment(if ((pAssetIds[2] == base58''))
568 568                                                                      then unit
569 569                                                                      else pAssetIds[2], pAmounts[2])]
570 570                                                                  else nil))
571 571                                                              let reissue = invoke(i.caller, "reissueShareToken", [shareTokenToPayAmount], nil)
572 572                                                              if ((reissue == reissue))
573 573                                                                  then {
574 574                                                                      let stake3 = invoke(farmingAddress, "lockShareTokensFromPool", [callerBytes, toString(i.caller), lockType], stPayments)
575 575                                                                      if ((stake3 == stake3))
576 576                                                                          then nil
577 577                                                                          else throw("Strict value is not equal to itself.")
578 578                                                                      }
579 579                                                                  else throw("Strict value is not equal to itself.")
580 580                                                              }
581 581                                                          else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(caller, shareTokenToPayAmount, shareAssetId)]
582 582                                                      $Tuple2(nil, $Tuple2(([IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(caller, change, changeAssetId)] ++ shareTokenST), nil))
583 583                                                      }
584 584                                                  else throw("Strict value is not equal to itself.")
585 585                                              }
586 586                                          else throw("Strict value is not equal to itself.")
587 587                                      }
588 588                          }
589 589      }))
590 590  
591 591  
592 592  
593 593  @Callable(i)
594 594  func replenishWithOneToken (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
595 595      let caller = Address(callerBytes)
596 596      let pmtAssetId = parsePaymentAsset(pAssetIds[0])
597 597      let pmtAmount = pAmounts[0]
598 598      let virtGetMinAmount = parseIntValue(args[0])
599 599      let stakeFarming = (args[1] == "true")
600 600      let lockType = parseIntValue(args[2])
601 601      let $t02416824258 = getPoolAssets(i.caller)
602 602      let strAssetIdA = $t02416824258._1
603 603      let strAssetIdB = $t02416824258._2
604 604      let assetIdA = $t02416824258._3
605 605      let assetIdB = $t02416824258._4
606 606      let shareAssetId = $t02416824258._5
607 607      let $t02427124395 = getPoolBalances(i.caller, assetIdA, assetIdB)
608 608      let balanceA = $t02427124395._1
609 609      let balanceB = $t02427124395._2
610 610      let accountBalanceA = $t02427124395._3
611 611      let accountBalanceB = $t02427124395._4
612 612      let shareAssetSupply = $t02427124395._5
613 613      let initial = ((balanceA + balanceB) == 0)
614 614      if ((size(args) != 3))
615 615          then throw("Wrong args size")
616 616          else if (if ((size(pAmounts) != 1))
617 617              then (size(pAmounts) != 2)
618 618              else false)
619 619              then throw("Two or one attached assets expected")
620 620              else if (if ((pmtAssetId != assetIdA))
621 621                  then (pmtAssetId != assetIdB)
622 622                  else false)
623 623                  then throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
624 624                  else if (initial)
625 625                      then throw("For initial exchanger you need to use two tokens")
626 626                      else if (if ((balanceA > accountBalanceA))
627 627                          then true
628 628                          else (balanceB > accountBalanceB))
629 629                          then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ (if ((size(pAmounts) == 2))
630 630                              then [AttachedPayment(if ((pAssetIds[2] == base58''))
631 631                                  then unit
632 632                                  else pAssetIds[2], pAmounts[2])]
633 633                              else (nil ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))))
634 634                          else {
635 635                              let $t02545125509 = getFeeParams(i.caller, i.originCaller)
636 636                              let fee = $t02545125509._1
637 637                              let govFee = $t02545125509._2
638 638                              let $t02552627732 = if ((pmtAssetId == assetIdA))
639 639                                  then {
640 640                                      let virtPayAmount = calculateVirtPay(pmtAmount, balanceA, fee)
641 641                                      let $t02580525942 = calculateFees(virtPayAmount, virtGetMinAmount, balanceA, balanceB, fee, govFee)
642 642                                      let amountWithoutFee = $t02580525942._1
643 643                                      let amountWithFee = $t02580525942._2
644 644                                      let governanceReward = $t02580525942._3
645 645                                      let balanceAVirt = (balanceA + virtPayAmount)
646 646                                      let balanceBVirt = ((balanceB + amountWithoutFee) - governanceReward)
647 647                                      let newBalanceA = (balanceA + pmtAmount)
648 648                                      let newBalanceB = (balanceB - governanceReward)
649 649                                      let ratioShareTokensInA = fraction((pmtAmount - virtPayAmount), scale8, balanceAVirt)
650 650                                      let ratioShareTokensInB = fraction(amountWithFee, scale8, balanceBVirt)
651 651                                      let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
652 652                                      $Tuple7(newBalanceA, newBalanceB, shareTokenToPayAmount, governanceReward, assetIdB, strAssetIdB, strAssetIdA)
653 653                                      }
654 654                                  else {
655 655                                      let virtPayAmount = calculateVirtPay(pmtAmount, balanceB, fee)
656 656                                      let $t02683726974 = calculateFees(virtPayAmount, virtGetMinAmount, balanceB, balanceA, fee, govFee)
657 657                                      let amountWithoutFee = $t02683726974._1
658 658                                      let amountWithFee = $t02683726974._2
659 659                                      let governanceReward = $t02683726974._3
660 660                                      let balanceAVirt = ((balanceA + amountWithoutFee) - governanceReward)
661 661                                      let balanceBVirt = (balanceB + virtPayAmount)
662 662                                      let newBalanceA = (balanceA - governanceReward)
663 663                                      let newBalanceB = (balanceB + pmtAmount)
664 664                                      let ratioShareTokensInA = fraction(amountWithFee, scale8, balanceAVirt)
665 665                                      let ratioShareTokensInB = fraction((pmtAmount - virtPayAmount), scale8, balanceBVirt)
666 666                                      let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
667 667                                      $Tuple7(newBalanceA, newBalanceB, shareTokenToPayAmount, governanceReward, assetIdA, strAssetIdA, strAssetIdB)
668 668                                      }
669 669                              let newBalanceA = $t02552627732._1
670 670                              let newBalanceB = $t02552627732._2
671 671                              let shareTokenToPayAmount = $t02552627732._3
672 672                              let govReward = $t02552627732._4
673 673                              let govRewardAsset = $t02552627732._5
674 674                              let govRewardAssetStr = $t02552627732._6
675 675                              let pmtAssetIdStr = $t02552627732._7
676 676                              if ((shareTokenToPayAmount == 0))
677 677                                  then throw("Too small amount to replenish")
678 678                                  else {
679 679                                      let stake1 = if (contains(stakingAssets, pmtAssetIdStr))
680 680                                          then invoke(i.caller, "stakeUnstake", [true, pmtAmount, pmtAssetIdStr], nil)
681 681                                          else 0
682 682                                      if ((stake1 == stake1))
683 683                                          then {
684 684                                              let stake2 = if (contains(stakingAssets, govRewardAssetStr))
685 685                                                  then invoke(i.caller, "stakeUnstake", [false, govReward, govRewardAssetStr], nil)
686 686                                                  else 0
687 687                                              if ((stake2 == stake2))
688 688                                                  then {
689 689                                                      let shareTokenST = if (stakeFarming)
690 690                                                          then {
691 691                                                              let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(pAmounts) == 2))
692 692                                                                  then [AttachedPayment(if ((pAssetIds[1] == base58''))
693 693                                                                      then unit
694 694                                                                      else pAssetIds[1], pAmounts[1])]
695 695                                                                  else nil))
696 696                                                              let reissue = invoke(i.caller, "reissueShareToken", [shareTokenToPayAmount], nil)
697 697                                                              if ((reissue == reissue))
698 698                                                                  then {
699 699                                                                      let stake3 = invoke(farmingAddress, "lockShareTokensFromPool", [callerBytes, toString(i.caller), lockType], stPayments)
700 700                                                                      if ((stake3 == stake3))
701 701                                                                          then nil
702 702                                                                          else throw("Strict value is not equal to itself.")
703 703                                                                      }
704 704                                                                  else throw("Strict value is not equal to itself.")
705 705                                                              }
706 706                                                          else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(caller, shareTokenToPayAmount, shareAssetId)]
707 707                                                      $Tuple2(nil, $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(moneyBoxAddress, govReward, govRewardAsset)] ++ shareTokenST), nil))
708 708                                                      }
709 709                                                  else throw("Strict value is not equal to itself.")
710 710                                              }
711 711                                          else throw("Strict value is not equal to itself.")
712 712                                      }
713 713                              }
714 714      }))
715 715  
716 716  
717 717  
718 718  @Callable(i)
719 719  func withdraw (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
720 720      let time = lastBlock.timestamp
721 721      let caller = Address(callerBytes)
722 722      let $t02988629976 = getPoolAssets(i.caller)
723 723      let strAssetIdA = $t02988629976._1
724 724      let strAssetIdB = $t02988629976._2
725 725      let assetIdA = $t02988629976._3
726 726      let assetIdB = $t02988629976._4
727 727      let shareAssetId = $t02988629976._5
728 728      let $t02998930113 = getPoolBalances(i.caller, assetIdA, assetIdB)
729 729      let balanceA = $t02998930113._1
730 730      let balanceB = $t02998930113._2
731 731      let accountBalanceA = $t02998930113._3
732 732      let accountBalanceB = $t02998930113._4
733 733      let shareAssetSupply = $t02998930113._5
734 734      let $t03012630534 = if ((size(pAmounts) == 1))
735 735          then {
736 736              let pAsset = parsePaymentAsset(pAssetIds[0])
737 737              if ((pAsset != shareAssetId))
738 738                  then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
739 739                  else $Tuple2(pAmounts[0], pAsset)
740 740              }
741 741          else $Tuple2(0, shareAssetId)
742 742      let pmtAmount = $t03012630534._1
743 743      let pmtAssetId = $t03012630534._2
744 -     if ((size(args) != 3))
744 +     if ((size(args) != 1))
745 745          then throw("Wrong args size")
746 746          else if ((size(pAmounts) > 1))
747 747              then throw("One attached payment expected")
748 748              else if (if ((balanceA > accountBalanceA))
749 749                  then true
750 750                  else (balanceB > accountBalanceB))
751 751                  then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
752 752                  else {
753 753                      let unlockAmount = parseIntValue(valueOrElse(args[0], "0"))
754 754                      let unlock = if ((unlockAmount > 0))
755 755                          then invoke(farmingAddress, "withdrawShareTokensFromPool", [callerBytes, toString(i.caller), unlockAmount], nil)
756 756                          else 0
757 757                      if ((unlock == unlock))
758 758                          then {
759 759                              let withdrawAmount = (pmtAmount + unlockAmount)
760 760                              let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
761 761                              let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
762 762                              let stake1 = if (contains(stakingAssets, strAssetIdA))
763 763                                  then invoke(i.caller, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
764 764                                  else 0
765 765                              if ((stake1 == stake1))
766 766                                  then {
767 767                                      let stake2 = if (contains(stakingAssets, strAssetIdB))
768 768                                          then invoke(i.caller, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
769 769                                          else 0
770 770                                      if ((stake2 == stake2))
771 771                                          then $Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2([IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(caller, amountToPayA, assetIdA), ScriptTransfer(caller, amountToPayB, assetIdB)], nil))
772 772                                          else throw("Strict value is not equal to itself.")
773 773                                      }
774 774                                  else throw("Strict value is not equal to itself.")
775 775                              }
776 776                          else throw("Strict value is not equal to itself.")
777 777                      }
778 778      }))
779 779  
780 780  
781 781  
782 782  @Callable(i)
783 783  func withdrawOneToken (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
784 784      let caller = Address(callerBytes)
785 785      let withdrawAsset = if ((args[0] == ""))
786 786          then unit
787 787          else fromBase58String(args[0])
788 788      let $t03284532935 = getPoolAssets(i.caller)
789 789      let strAssetIdA = $t03284532935._1
790 790      let strAssetIdB = $t03284532935._2
791 791      let assetIdA = $t03284532935._3
792 792      let assetIdB = $t03284532935._4
793 793      let shareAssetId = $t03284532935._5
794 794      let $t03294833072 = getPoolBalances(i.caller, assetIdA, assetIdB)
795 795      let balanceA = $t03294833072._1
796 796      let balanceB = $t03294833072._2
797 797      let accountBalanceA = $t03294833072._3
798 798      let accountBalanceB = $t03294833072._4
799 799      let shareAssetSupply = $t03294833072._5
800 800      let $t03308533465 = if ((size(pAmounts) == 1))
801 801          then {
802 802              let pAsset = parsePaymentAsset(pAssetIds[0])
803 803              if ((pAsset != shareAssetId))
804 804                  then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
805 805                  else $Tuple2(pAmounts[0], pAsset)
806 806              }
807 807          else $Tuple2(0, shareAssetId)
808 808      let pmtAmount = $t03308533465._1
809 809      let pmtAssetId = $t03308533465._2
810 810      let virtMinToRecive = parseIntValue(args[1])
811 811      if ((size(args) != 3))
812 812          then throw("Wrong args size")
813 -         else if ((size(pAmounts) != 1))
813 +         else if ((size(pAmounts) > 1))
814 814              then throw("One attached payment expected")
815 815              else if ((pmtAssetId != shareAssetId))
816 816                  then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
817 817                  else if (!(containsElement([assetIdA, assetIdB], withdrawAsset)))
818 818                      then throw("Incorrect withdraw asset.")
819 819                      else if (if ((balanceA > accountBalanceA))
820 820                          then true
821 821                          else (balanceB > accountBalanceB))
822 822                          then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
823 823                          else {
824 824                              let unlockAmount = parseIntValue(valueOrElse(args[2], "0"))
825 825                              let unlock = if ((unlockAmount > 0))
826 826                                  then invoke(farmingAddress, "withdrawShareTokensFromPool", [callerBytes, toString(i.caller), unlockAmount], nil)
827 827                                  else 0
828 828                              if ((unlock == unlock))
829 829                                  then {
830 830                                      let withdrawAmount = (pmtAmount + unlockAmount)
831 831                                      let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
832 832                                      let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
833 -                                     let $t03481434872 = getFeeParams(i.caller, i.originCaller)
834 -                                     let fee = $t03481434872._1
835 -                                     let govFee = $t03481434872._2
836 -                                     let $t03488935289 = if ((withdrawAsset == assetIdA))
833 +                                     let $t03481334871 = getFeeParams(i.caller, i.originCaller)
834 +                                     let fee = $t03481334871._1
835 +                                     let govFee = $t03481334871._2
836 +                                     let $t03488835288 = if ((withdrawAsset == assetIdA))
837 837                                          then calculateFees(amountToPayB, virtMinToRecive, (balanceB - amountToPayB), (balanceA - amountToPayA), fee, govFee)
838 838                                          else calculateFees(amountToPayA, virtMinToRecive, (balanceA - amountToPayA), (balanceB - amountToPayB), fee, govFee)
839 -                                     let amountWithoutFee = $t03488935289._1
840 -                                     let amountWithFee = $t03488935289._2
841 -                                     let governanceReward = $t03488935289._3
842 -                                     let $t03530636652 = if ((withdrawAsset == assetIdA))
839 +                                     let amountWithoutFee = $t03488835288._1
840 +                                     let amountWithFee = $t03488835288._2
841 +                                     let governanceReward = $t03488835288._3
842 +                                     let $t03530536651 = if ((withdrawAsset == assetIdA))
843 843                                          then {
844 844                                              let unstake = if (contains(stakingAssets, strAssetIdA))
845 845                                                  then invoke(i.caller, "stakeUnstake", [false, ((amountToPayA + amountWithFee) + governanceReward), strAssetIdA], nil)
846 846                                                  else 0
847 847                                              if ((unstake == unstake))
848 848                                                  then $Tuple4((((balanceA - amountToPayA) - amountWithFee) - governanceReward), balanceB, assetIdA, [ScriptTransfer(caller, (amountToPayA + amountWithFee), assetIdA)])
849 849                                                  else throw("Strict value is not equal to itself.")
850 850                                              }
851 851                                          else {
852 852                                              let unstake = if (contains(stakingAssets, strAssetIdB))
853 853                                                  then invoke(i.caller, "stakeUnstake", [false, ((amountToPayB + amountWithFee) + governanceReward), strAssetIdB], nil)
854 854                                                  else 0
855 855                                              if ((unstake == unstake))
856 856                                                  then $Tuple4(balanceA, (((balanceB - amountToPayB) - amountWithFee) - governanceReward), assetIdB, [ScriptTransfer(caller, (amountToPayB + amountWithFee), assetIdB)])
857 857                                                  else throw("Strict value is not equal to itself.")
858 858                                              }
859 -                                     let newBalanceA = $t03530636652._1
860 -                                     let newBalanceB = $t03530636652._2
861 -                                     let govRewardAssetId = $t03530636652._3
862 -                                     let userTransfer = $t03530636652._4
859 +                                     let newBalanceA = $t03530536651._1
860 +                                     let newBalanceB = $t03530536651._2
861 +                                     let govRewardAssetId = $t03530536651._3
862 +                                     let userTransfer = $t03530536651._4
863 863                                      $Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(moneyBoxAddress, governanceReward, govRewardAssetId)] ++ userTransfer), nil))
864 864                                      }
865 865                                  else throw("Strict value is not equal to itself.")
866 866                              }
867 867      }))
868 868  
869 869  
870 870  
871 871  @Callable(i)
872 872  func takeIntoAccountExtraFunds (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
873 -     let $t03737737453 = getPoolAssets(i.caller)
874 -     let strAssetIdA = $t03737737453._1
875 -     let strAssetIdB = $t03737737453._2
876 -     let assetIdA = $t03737737453._3
877 -     let assetIdB = $t03737737453._4
878 -     let $t03746637572 = getPoolBalances(i.caller, assetIdA, assetIdB)
879 -     let balanceA = $t03746637572._1
880 -     let balanceB = $t03746637572._2
881 -     let accountBalanceA = $t03746637572._3
882 -     let accountBalanceB = $t03746637572._4
873 +     let $t03737637452 = getPoolAssets(i.caller)
874 +     let strAssetIdA = $t03737637452._1
875 +     let strAssetIdB = $t03737637452._2
876 +     let assetIdA = $t03737637452._3
877 +     let assetIdB = $t03737637452._4
878 +     let $t03746537571 = getPoolBalances(i.caller, assetIdA, assetIdB)
879 +     let balanceA = $t03746537571._1
880 +     let balanceB = $t03746537571._2
881 +     let accountBalanceA = $t03746537571._3
882 +     let accountBalanceB = $t03746537571._4
883 883      let amountEnrollA = (accountBalanceA - balanceA)
884 884      let amountEnrollB = (accountBalanceB - balanceB)
885 885      if ((size(args) != 0))
886 886          then throw("Wrong args size")
887 887          else if ((moneyBoxAddress != i.originCaller))
888 888              then throw("Only the wallet can call this function")
889 889              else if (if ((0 > amountEnrollA))
890 890                  then true
891 891                  else (0 > amountEnrollB))
892 892                  then suspend("Enroll amount negative")
893 893                  else if (if ((amountEnrollA == 0))
894 894                      then (amountEnrollB == 0)
895 895                      else false)
896 896                      then throw("No money to take")
897 897                      else {
898 898                          let stake1 = if (if (contains(stakingAssets, strAssetIdA))
899 899                              then (amountEnrollA > 0)
900 900                              else false)
901 901                              then invoke(i.caller, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
902 902                              else 0
903 903                          if ((stake1 == stake1))
904 904                              then {
905 905                                  let stake2 = if (if (contains(stakingAssets, strAssetIdB))
906 906                                      then (amountEnrollB > 0)
907 907                                      else false)
908 908                                      then invoke(i.caller, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
909 909                                      else 0
910 910                                  if ((stake2 == stake2))
911 911                                      then $Tuple2(nil, $Tuple2([IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))], nil))
912 912                                      else throw("Strict value is not equal to itself.")
913 913                                  }
914 914                              else throw("Strict value is not equal to itself.")
915 915                          }
916 916      }))
917 917  
918 918  
919 919  @Verifier(tx)
920 920  func verify () = {
921 921      let multiSignedByAdmins = {
922 922          let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
923 923              then 1
924 924              else 0
925 925          let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
926 926              then 1
927 927              else 0
928 928          let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
929 929              then 1
930 930              else 0
931 931          (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
932 932          }
933 933      multiSignedByAdmins
934 934      }
935 935

Old	New		Differences
741	741		else $Tuple2(0, shareAssetId)
742	742		let pmtAmount = $t03012630534._1
743	743		let pmtAssetId = $t03012630534._2
744		-	if ((size(args) != 3))
	744	+	if ((size(args) != 1))
745	745		then throw("Wrong args size")
746	746		else if ((size(pAmounts) > 1))
747	747		then throw("One attached payment expected")

810	810		let virtMinToRecive = parseIntValue(args[1])
811	811		if ((size(args) != 3))
812	812		then throw("Wrong args size")
813		-	else if ((size(pAmounts) != 1))
	813	+	else if ((size(pAmounts) > 1))
814	814		then throw("One attached payment expected")
815	815		else if ((pmtAssetId != shareAssetId))
816	816		then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))

830	830		let withdrawAmount = (pmtAmount + unlockAmount)
831	831		let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
832	832		let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
833		-	let $~~t03481434872~~ = getFeeParams(i.caller, i.originCaller)
834		-	let fee = $~~t03481434872~~._1
835		-	let govFee = $~~t03481434872~~._2
836		-	let $~~t03488935289~~ = if ((withdrawAsset == assetIdA))
	833	+	let $t03481334871 = getFeeParams(i.caller, i.originCaller)
	834	+	let fee = $t03481334871._1
	835	+	let govFee = $t03481334871._2
	836	+	let $t03488835288 = if ((withdrawAsset == assetIdA))
837	837		then calculateFees(amountToPayB, virtMinToRecive, (balanceB - amountToPayB), (balanceA - amountToPayA), fee, govFee)
838	838		else calculateFees(amountToPayA, virtMinToRecive, (balanceA - amountToPayA), (balanceB - amountToPayB), fee, govFee)
839		-	let amountWithoutFee = $~~t03488935289~~._1
840		-	let amountWithFee = $~~t03488935289~~._2
841		-	let governanceReward = $~~t03488935289~~._3
842		-	let $~~t03530636652~~ = if ((withdrawAsset == assetIdA))
	839	+	let amountWithoutFee = $t03488835288._1
	840	+	let amountWithFee = $t03488835288._2
	841	+	let governanceReward = $t03488835288._3
	842	+	let $t03530536651 = if ((withdrawAsset == assetIdA))
843	843		then {
844	844		let unstake = if (contains(stakingAssets, strAssetIdA))
845	845		then invoke(i.caller, "stakeUnstake", [false, ((amountToPayA + amountWithFee) + governanceReward), strAssetIdA], nil)

856	856		then $Tuple4(balanceA, (((balanceB - amountToPayB) - amountWithFee) - governanceReward), assetIdB, [ScriptTransfer(caller, (amountToPayB + amountWithFee), assetIdB)])
857	857		else throw("Strict value is not equal to itself.")
858	858		}
859		-	let newBalanceA = $~~t03530636652~~._1
860		-	let newBalanceB = $~~t03530636652~~._2
861		-	let govRewardAssetId = $~~t03530636652~~._3
862		-	let userTransfer = $~~t03530636652~~._4
	859	+	let newBalanceA = $t03530536651._1
	860	+	let newBalanceB = $t03530536651._2
	861	+	let govRewardAssetId = $t03530536651._3
	862	+	let userTransfer = $t03530536651._4
863	863		$Tuple2([ScriptTransfer(i.caller, unlockAmount, shareAssetId)], $Tuple2(([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), Burn(shareAssetId, withdrawAmount), ScriptTransfer(moneyBoxAddress, governanceReward, govRewardAssetId)] ++ userTransfer), nil))
864	864		}
865	865		else throw("Strict value is not equal to itself.")

870	870
871	871		@Callable(i)
872	872		func takeIntoAccountExtraFunds (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
873		-	let $~~t03737737453~~ = getPoolAssets(i.caller)
874		-	let strAssetIdA = $~~t03737737453~~._1
875		-	let strAssetIdB = $~~t03737737453~~._2
876		-	let assetIdA = $~~t03737737453~~._3
877		-	let assetIdB = $~~t03737737453~~._4
878		-	let $~~t03746637572~~ = getPoolBalances(i.caller, assetIdA, assetIdB)
879		-	let balanceA = $~~t03746637572~~._1
880		-	let balanceB = $~~t03746637572~~._2
881		-	let accountBalanceA = $~~t03746637572~~._3
882		-	let accountBalanceB = $~~t03746637572~~._4
	873	+	let $t03737637452 = getPoolAssets(i.caller)
	874	+	let strAssetIdA = $t03737637452._1
	875	+	let strAssetIdB = $t03737637452._2
	876	+	let assetIdA = $t03737637452._3
	877	+	let assetIdB = $t03737637452._4
	878	+	let $t03746537571 = getPoolBalances(i.caller, assetIdA, assetIdB)
	879	+	let balanceA = $t03746537571._1
	880	+	let balanceB = $t03746537571._2
	881	+	let accountBalanceA = $t03746537571._3
	882	+	let accountBalanceB = $t03746537571._4
883	883		let amountEnrollA = (accountBalanceA - balanceA)
884	884		let amountEnrollB = (accountBalanceB - balanceB)
885	885		if ((size(args) != 0))

Old	New	Differences
1	1	{-# STDLIB_VERSION 6 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	let version = "1.0.0"
5	5
6	6	let kVersion = "version"
7	7
8	8	let kActive = "active"
9	9
10	10	let kAssetIdA = "A_asset_id"
11	11
12	12	let kAssetIdB = "B_asset_id"
13	13
14	14	let kBalanceA = "A_asset_balance"
15	15
16	16	let kBalanceB = "B_asset_balance"
17	17
18	18	let kBalanceInitA = "A_asset_init"
19	19
20	20	let kBalanceInitB = "B_asset_init"
21	21
22	22	let kShareAssetId = "share_asset_id"
23	23
24	24	let kShareAssetSupply = "share_asset_supply"
25	25
26	26	let kFee = "commission"
27	27
28	28	let kCause = "shutdown_cause"
29	29
30	30	let kFirstHarvest = "first_harvest"
31	31
32	32	let kFirstHarvestHeight = "first_harvest_height"
33	33
34	34	let kShareLimit = "share_limit_on_first_harvest"
35	35
36	36	let kBasePeriod = "base_period"
37	37
38	38	let kPeriodLength = "period_length"
39	39
40	40	let kStartHeight = "start_height"
41	41
42	42	let kUSDNAddress = "staking_usdnnsbt_address"
43	43
44	44	let kEURNAddress = "staking_eurn_address"
45	45
46	46	let kLeasingAmount = "leasing_amount"
47	47
48	48	let kUSDNAssetId = "usdn_asset_id"
49	49
50	50	let kEURNAssetId = "eurn_asset_id"
51	51
52	52	let kStakingAssets = "staking_assets"
53	53
54	54	let kOracleActive = "active_all_contracts"
55	55
56	56	let kOracleActiveExchangers = "active_global_exchangers"
57	57
58	58	let kDiscounts = "discounts"
59	59
60	60	let kDiscountValues = "discount_values"
61	61
62	62	let kUserGSwopInGov = "_GSwop_amount"
63	63
64	64	let kUserSwopInGov = "_SWOP_amount"
65	65
66	66	let kOraclePool = "pool_"
67	67
68	68	let kAdminPubKey1 = "admin_pub_1"
69	69
70	70	let kAdminPubKey2 = "admin_pub_2"
71	71
72	72	let kAdminPubKey3 = "admin_pub_3"
73	73
74	74	let kAdminInvokePubKey = "admin_invoke_pub"
75	75
76	76	let kMoneyBoxAddress = "money_box_address"
77	77
78	78	let kVotingAddress = "voting_address"
79	79
80	80	let kGovAddress = "governance_address"
81	81
82	82	let kFarmingAddress = "farming_address"
83	83
84	84	let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
85	85
86	86	func getBase58FromOracle (key) = match getString(oracle, key) {
87	87	case string: String =>
88	88	fromBase58String(string)
89	89	case nothing =>
90	90	throw((key + "is empty"))
91	91	}
92	92
93	93
94	94	let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
95	95
96	96	let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
97	97
98	98	let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
99	99
100	100	let adminInvokePubKey = getBase58FromOracle(kAdminInvokePubKey)
101	101
102	102	let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
103	103
104	104	let votingAddress = Address(getBase58FromOracle(kVotingAddress))
105	105
106	106	let govAddress = Address(getBase58FromOracle(kGovAddress))
107	107
108	108	let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
109	109
110	110	let USDN = getBase58FromOracle(kUSDNAssetId)
111	111
112	112	let EURN = getBase58FromOracle(kEURNAssetId)
113	113
114	114	let stakingAssets = getStringValue(oracle, kStakingAssets)
115	115
116	116	let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
117	117
118	118	let stakingEURNAddress = Address(getBase58FromOracle(kEURNAddress))
119	119
120	120	let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
121	121
122	122	let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
123	123
124	124	let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
125	125
126	126	let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
127	127
128	128	let active = if (getBooleanValue(oracle, kOracleActive))
129	129	then getBooleanValue(oracle, kOracleActiveExchangers)
130	130	else false
131	131
132	132	let feeScale6 = 1000000
133	133
134	134	let scale8 = 100000000
135	135
136	136	func accountBalance (assetId,pool) = match assetId {
137	137	case id: ByteVector =>
138	138	assetBalance(pool, id)
139	139	case waves: Unit =>
140	140	wavesBalance(pool).available
141	141	case _ =>
142	142	throw("Match error")
143	143	}
144	144
145	145
146	146	func stakedAmount (assetId,pool) = {
147	147	let stakedAmountCalculated = match assetId {
148	148	case aId: ByteVector =>
149	149	if ((aId == USDN))
150	150	then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(pool)))
151	151	else if ((aId == EURN))
152	152	then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(pool)))
153	153	else 0
154	154	case _: Unit =>
155	155	valueOrElse(getInteger(pool, kLeasingAmount), 0)
156	156	case _ =>
157	157	throw("Match error")
158	158	}
159	159	match stakedAmountCalculated {
160	160	case i: Int =>
161	161	i
162	162	case _ =>
163	163	0
164	164	}
165	165	}
166	166
167	167
168	168	func getAssetInfo (assetId) = match assetId {
169	169	case id: String\|ByteVector =>
170	170	let $t040054177 = match id {
171	171	case aId: ByteVector =>
172	172	$Tuple2(toBase58String(aId), aId)
173	173	case aId: String =>
174	174	$Tuple2(aId, fromBase58String(aId))
175	175	case _ =>
176	176	throw("Match error")
177	177	}
178	178	let stringId = $t040054177._1
179	179	let bytesId = $t040054177._2
180	180	let info = valueOrErrorMessage(assetInfo(bytesId), (("Asset " + stringId) + " doesn't exist"))
181	181	$Tuple3(stringId, info.name, info.decimals)
182	182	case waves: Unit =>
183	183	$Tuple3("WAVES", "WAVES", 8)
184	184	case _ =>
185	185	throw("Match error")
186	186	}
187	187
188	188
189	189	func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
190	190
191	191
192	192	func calculateFeeDiscount (userAddr) = {
193	193	let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
194	194	let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
195	195	let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
196	196	let discounts = split(getStringValue(oracle, kDiscounts), ",")
197	197	if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
198	198	then (parseIntValue(discountValues[1]) > gSwopAmount)
199	199	else false)
200	200	then (feeScale6 - parseIntValue(discounts[0]))
201	201	else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
202	202	then (parseIntValue(discountValues[2]) > gSwopAmount)
203	203	else false)
204	204	then (feeScale6 - parseIntValue(discounts[1]))
205	205	else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
206	206	then (parseIntValue(discountValues[3]) > gSwopAmount)
207	207	else false)
208	208	then (feeScale6 - parseIntValue(discounts[2]))
209	209	else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
210	210	then (parseIntValue(discountValues[4]) > gSwopAmount)
211	211	else false)
212	212	then (feeScale6 - parseIntValue(discounts[3]))
213	213	else if ((gSwopAmount >= parseIntValue(discountValues[4])))
214	214	then (feeScale6 - parseIntValue(discounts[4]))
215	215	else feeScale6
216	216	}
217	217
218	218
219	219	func calculateFees (pmtAmount,minAmountToReceive,tokenFrom,tokenTo,fee,feeGovernance) = {
220	220	let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
221	221	let amountWithFee = fraction(amountWithoutFee, (feeScale6 - fee), feeScale6)
222	222	let governanceReward = fraction(amountWithoutFee, feeGovernance, feeScale6)
223	223	if ((minAmountToReceive > amountWithFee))
224	224	then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
225	225	else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
226	226	}
227	227
228	228
229	229	func calculateVirtPay (pmtAmount,balance,fee) = {
230	230	let F = (feeScale6 - fee)
231	231	let k = fraction(fee, 60, 100)
232	232	let a = (scale8 + fraction((F * k), scale8, (feeScale6 * feeScale6)))
233	233	let b = ((((balance + fraction(balance, F, feeScale6)) + fraction(pmtAmount, F, feeScale6)) - pmtAmount) - fraction(pmtAmount, (F * k), (feeScale6 * feeScale6)))
234	234	let c = (-(toBigInt(balance)) * toBigInt(pmtAmount))
235	235	let D = ((toBigInt(b) * toBigInt(b)) - fraction((toBigInt(4) * c), toBigInt(a), toBigInt(scale8)))
236	236	toInt(fraction((-(toBigInt(b)) + sqrtBigInt(D, 0, 0, DOWN)), toBigInt(scale8), toBigInt((2 * a))))
237	237	}
238	238
239	239
240	240	func parsePaymentAsset (assetId) = if ((assetId == base58''))
241	241	then unit
242	242	else assetId
243	243
244	244
245	245	func suspendSuspicious (accountBalanceA,accountBalanceB,balanceA,balanceB,assetIdA,assetIdB) = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceA)) + " ") + assetIdA) + ", ") + toString(accountBalanceB)) + " ") + assetIdB) + ". State: ") + toString(balanceA)) + " ") + assetIdA) + ", ") + toString(balanceB)) + " ") + assetIdB))
246	246
247	247
248	248	func isActive () = if (active)
249	249	then unit
250	250	else throw("DApp is inactive at this moment")
251	251
252	252
253	253	func isOraclePool (poolAddress) = if (isDefined(getString(oracle, (kOraclePool + poolAddress))))
254	254	then unit
255	255	else throw("DApp is not registered pool")
256	256
257	257
258	258	func getPoolBalances (pool,assetIdA,assetIdB) = {
259	259	let balanceA = getIntegerValue(pool, kBalanceA)
260	260	let balanceB = getIntegerValue(pool, kBalanceB)
261	261	let stakedAmountA = stakedAmount(assetIdA, pool)
262	262	let stakedAmountB = stakedAmount(assetIdB, pool)
263	263	let accountBalanceA = (accountBalance(assetIdA, pool) + stakedAmountA)
264	264	let accountBalanceB = (accountBalance(assetIdB, pool) + stakedAmountB)
265	265	let shareSupply = getIntegerValue(pool, kShareAssetSupply)
266	266	$Tuple5(balanceA, balanceB, accountBalanceA, accountBalanceB, shareSupply)
267	267	}
268	268
269	269
270	270	func getPoolAssets (pool) = {
271	271	let strAssetIdA = getStringValue(pool, kAssetIdA)
272	272	let strAssetIdB = getStringValue(pool, kAssetIdB)
273	273	let assetIdA = if ((strAssetIdA == "WAVES"))
274	274	then unit
275	275	else fromBase58String(strAssetIdA)
276	276	let assetIdB = if ((strAssetIdB == "WAVES"))
277	277	then unit
278	278	else fromBase58String(strAssetIdB)
279	279	let shareAssetId = fromBase58String(getStringValue(pool, kShareAssetId))
280	280	$Tuple5(strAssetIdA, strAssetIdB, assetIdA, assetIdB, shareAssetId)
281	281	}
282	282
283	283
284	284	func getFeeParams (pool,caller) = {
285	285	let feeDiscount = calculateFeeDiscount(caller)
286	286	let fee = fraction(getIntegerValue(pool, kFee), feeDiscount, feeScale6, CEILING)
287	287	let govFee = fraction(fraction(fee, 40, 100), feeDiscount, feeScale6, CEILING)
288	288	$Tuple2(fee, govFee)
289	289	}
290	290
291	291
292	292	@Callable(i)
293	293	func init (callerBytes,args,pAmounts,pAssetIds) = {
294	294	let caller = Address(callerBytes)
295	295	let $t091849262 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
296	296	let pmtAmountA = $t091849262._1
297	297	let pmtAssetIdA = $t091849262._2
298	298	let $t092679345 = $Tuple2(pAmounts[1], parsePaymentAsset(pAssetIds[1]))
299	299	let pmtAmountB = $t092679345._1
300	300	let pmtAssetIdB = $t092679345._2
301	301	if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
302	302	then throw("Only admin can call this function")
303	303	else if ((size(args) != 1))
304	304	then throw("Wrong args size")
305	305	else if (isDefined(getBoolean(caller, kActive)))
306	306	then throw("DApp is already active")
307	307	else if ((pmtAssetIdA == pmtAssetIdB))
308	308	then throw("Assets must be different")
309	309	else {
310	310	let $t097809857 = getAssetInfo(pmtAssetIdA)
311	311	let pmtStrAssetIdA = $t097809857._1
312	312	let pmtAssetNameA = $t097809857._2
313	313	let pmtDecimalsA = $t097809857._3
314	314	let $t098669943 = getAssetInfo(pmtAssetIdB)
315	315	let pmtStrAssetIdB = $t098669943._1
316	316	let pmtAssetNameB = $t098669943._2
317	317	let pmtDecimalsB = $t098669943._3
318	318	let firstHarvest = (args[0] == "true")
319	319	let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
320	320	let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
321	321	let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
322	322	let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
323	323	let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
324	324	let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
325	325	let shareInitialSupply = fraction(arg1, arg2, arg3)
326	326	let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
327	327	let shareIssueId = calculateAssetId(shareIssue)
328	328	let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
329	329	then invoke(i.caller, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
330	330	else 0
331	331	if ((stake1 == stake1))
332	332	then {
333	333	let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
334	334	then invoke(i.caller, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
335	335	else 0
336	336	if ((stake2 == stake2))
337	337	then {
338	338	let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(caller, shareInitialSupply, shareIssueId)]
339	339	if (firstHarvest)
340	340	then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
341	341	else $Tuple2(nil, $Tuple2(baseEntry, nil))
342	342	}
343	343	else throw("Strict value is not equal to itself.")
344	344	}
345	345	else throw("Strict value is not equal to itself.")
346	346	}
347	347	}
348	348
349	349
350	350
351	351	@Callable(i)
352	352	func initWithInitRatio (callerBytes,args,pAmounts,pAssetIds) = {
353	353	let caller = Address(callerBytes)
354	354	let $t01216412364 = $Tuple5(parseIntValue(args[0]), parseIntValue(args[1]), args[2], args[3], (args[4] == "true"))
355	355	let amtAssetA = $t01216412364._1
356	356	let amtAssetB = $t01216412364._2
357	357	let assetIdAStr = $t01216412364._3
358	358	let assetIdBStr = $t01216412364._4
359	359	let firstHarvest = $t01216412364._5
360	360	if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
361	361	then throw("Only admin can call this function")
362	362	else if ((size(args) != 5))
363	363	then throw("Wrong args size")
364	364	else if (isDefined(getBoolean(caller, kActive)))
365	365	then throw("DApp is already active")
366	366	else if ((assetIdAStr == assetIdBStr))
367	367	then throw("Assets must be different")
368	368	else {
369	369	let $t01279912876 = getAssetInfo(assetIdAStr)
370	370	let pmtStrAssetIdA = $t01279912876._1
371	371	let pmtAssetNameA = $t01279912876._2
372	372	let pmtDecimalsA = $t01279912876._3
373	373	let $t01288512962 = getAssetInfo(assetIdBStr)
374	374	let pmtStrAssetIdB = $t01288512962._1
375	375	let pmtAssetNameB = $t01288512962._2
376	376	let pmtDecimalsB = $t01288512962._3
377	377	let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
378	378	let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
379	379	let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
380	380	let shareInitialSupply = 0
381	381	let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
382	382	let shareIssueId = calculateAssetId(shareIssue)
383	383	let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceInitA, amtAssetA), IntegerEntry(kBalanceInitB, amtAssetB), IntegerEntry(kBalanceA, 0), IntegerEntry(kBalanceB, 0), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply)]
384	384	if (firstHarvest)
385	385	then $Tuple2(nil, $Tuple2((baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))]), nil))
386	386	else $Tuple2(nil, $Tuple2(baseEntry, nil))
387	387	}
388	388	}
389	389
390	390
391	391
392	392	@Callable(i)
393	393	func keepLimitForFirstHarvest (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.originCallerPublicKey)))
394	394	then throw("Only admin can call this function")
395	395	else if ((size(args) != 1))
396	396	then throw("Wrong args size")
397	397	else {
398	398	let shareLimit = parseIntValue(args[0])
399	399	$Tuple2(nil, $Tuple2([IntegerEntry(kShareLimit, shareLimit)], nil))
400	400	}))
401	401
402	402
403	403
404	404	@Callable(i)
405	405	func exchange (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
406	406	let caller = Address(callerBytes)
407	407	let $t01534815424 = $Tuple2(pAmounts[0], parsePaymentAsset(pAssetIds[0]))
408	408	let pmtAmount = $t01534815424._1
409	409	let pmtAssetId = $t01534815424._2
410	410	let minAmountToReceive = parseIntValue(args[0])
411	411	let $t01549715573 = getPoolAssets(i.caller)
412	412	let strAssetIdA = $t01549715573._1
413	413	let strAssetIdB = $t01549715573._2
414	414	let assetIdA = $t01549715573._3
415	415	let assetIdB = $t01549715573._4
416	416	let $t01558615692 = getPoolBalances(i.caller, assetIdA, assetIdB)
417	417	let balanceA = $t01558615692._1
418	418	let balanceB = $t01558615692._2
419	419	let accountBalanceA = $t01558615692._3
420	420	let accountBalanceB = $t01558615692._4
421	421	if ((size(args) != 1))
422	422	then throw("Wrong args size")
423	423	else if (if ((balanceA == 0))
424	424	then true
425	425	else (balanceB == 0))
426	426	then throw("Can't exchange with zero balance")
427	427	else if ((0 >= minAmountToReceive))
428	428	then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
429	429	else if ((size(pAmounts) != 1))
430	430	then throw("One attached payment expected")
431	431	else if (!(containsElement([assetIdA, assetIdB], pmtAssetId)))
432	432	then throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
433	433	else if (if ((balanceA > accountBalanceA))
434	434	then true
435	435	else (balanceB > accountBalanceB))
436	436	then $Tuple2(nil, ([ScriptTransfer(caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious(accountBalanceA, accountBalanceB, balanceA, balanceB, strAssetIdA, strAssetIdB)))
437	437	else {
438	438	let $t01666016718 = getFeeParams(i.caller, i.originCaller)
439	439	let fee = $t01666016718._1
440	440	let govFee = $t01666016718._2
441	441	let $t01673517072 = if ((pmtAssetId == assetIdA))
442	442	then calculateFees(pmtAmount, minAmountToReceive, balanceA, balanceB, fee, govFee)
443	443	else calculateFees(pmtAmount, minAmountToReceive, balanceB, balanceA, fee, govFee)
444	444	let amountWithoutFee = $t01673517072._1
445	445	let amountWithFee = $t01673517072._2
446	446	let governanceReward = $t01673517072._3
447	447	let $t01709017415 = if ((pmtAssetId == assetIdA))
448	448	then $Tuple3((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward), assetIdB)
449	449	else $Tuple3(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount), assetIdA)
450	450	let newBalanceA = $t01709017415._1
451	451	let newBalanceB = $t01709017415._2
452	452	let assetIdSend = $t01709017415._3
453	453	let $t01743317683 = if ((pmtAssetId == assetIdA))
454	454	then $Tuple2(pmtAmount, (amountWithFee + governanceReward))
455	455	else $Tuple2((amountWithFee + governanceReward), pmtAmount)
456	456	let stakeAmountA = $t01743317683._1
457	457	let stakeAmountB = $t01743317683._2
458	458	let stake1 = if (contains(stakingAssets, strAssetIdA))
459	459	then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdA), stakeAmountA, strAssetIdA], nil)
460	460	else 0
461	461	if ((stake1 == stake1))
462	462	then {
463	463	let stake2 = if (contains(stakingAssets, strAssetIdB))
464	464	then invoke(i.caller, "stakeUnstake", [(pmtAssetId == assetIdB), stakeAmountB, strAssetIdB], nil)
465	465	else 0
466	466	if ((stake2 == stake2))
467	467	then $Tuple2(nil, $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), ScriptTransfer(caller, amountWithFee, assetIdSend), ScriptTransfer(moneyBoxAddress, governanceReward, assetIdSend)], [amountWithFee, assetIdSend]))
468	468	else throw("Strict value is not equal to itself.")
469	469	}
470	470	else throw("Strict value is not equal to itself.")
471	471	}
472	472	}))
473	473
474	474
475	475
476	476	@Callable(i)
477	477	func replenishWithTwoTokens (callerBytes,args,pAmounts,pAssetIds) = valueOrElse(isOraclePool(toString(i.caller)), valueOrElse(isActive(), {
478	478	let caller = Address(callerBytes)
479	479	let pmtAssetIdA = parsePaymentAsset(pAssetIds[0])
480	480	let pmtAssetIdB = parsePaymentAsset(pAssetIds[1])
481	481	let stakeFarming = (args[0] == "true")
482	482	let lockType = parseIntValue(args[1])
483	483	let $t01894619036 = getPoolAssets(i.caller)
484	484	let strAssetIdA = $t01894619036._1
485	485	let strAssetIdB = $t01894619036._2
486	486	let assetIdA = $t01894619036._3
487	487	let assetIdB = $t01894619036._4
488	488	let shareAssetId = $t01894619036._5
489	489	let $t01904919173 = getPoolBalances(i.caller, assetIdA, assetIdB)
490	490	let balanceA = $t01904919173._1
491	491	let balanceB = $t01904919173._2
492	492	let accountBalanceA = $t01904919173._3
493	493	let accountBalanceB = $t01904919173._4
494	494	let shareAssetSupply = $t01904919173._5
495	495	if ((size(args) != 2))
496	496	then throw("Wrong args size")
497	497	else if (if ((size(pAmounts) != 2))
498	498	then (size(pAmounts) != 3)
499	499	else false)
500	500	then throw("Two or three payments expected")

github/deemru/w8io/873ac7e 
104.17 ms ◑