tx · AidDSdTaQpnve98VSxJd3jVnTDLyuJoTwJyUyFdnPRaP 3GgTgarB4mvEUWB2VaZZR2eAuCccpK9f1FZ: -0.07000000 Gic 2025.06.12 04:55 [5826] smart account 3GgTgarB4mvEUWB2VaZZR2eAuCccpK9f1FZ > SELF 0.00000000 Gic
{ "type": 13, "id": "AidDSdTaQpnve98VSxJd3jVnTDLyuJoTwJyUyFdnPRaP", "fee": 7000000, "feeAssetId": null, "timestamp": 1749693414350, "version": 2, "chainId": 71, "sender": "3GgTgarB4mvEUWB2VaZZR2eAuCccpK9f1FZ", "senderPublicKey": "8dNEACURBe9HFX8kgDH2MVb1mxkFC7Txoqvi4ymdPiNd", "proofs": [ "2y9oXZub1HAQkquNYhoyZJXo9NT9iBzQrKiMDQujtjShMpq7aNZTgxViQZLXwKzfqjyYqPjNfUXxzcGUkgHps6wH" ], "script": "base64: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", "height": 5826, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: F8cEEMDw68p1DyxitiPZARKcGvcZPnqyQP1yuH3HGQQx Next: E31Z43H8J6QmXybShK9N8ZHfdptLSW3bev97TSEuc4U3 Diff:
| Old | New | Differences | |
|---|---|---|---|
| 175 | 175 | else if (if ((0 > feeBps)) | |
| 176 | 176 | then true | |
| 177 | 177 | else (feeBps > 1000)) | |
| 178 | - | then throw("Fee must be between 0 and 1000 basis points | |
| 178 | + | then throw("Fee must be between 0 and 1000 basis points") | |
| 179 | 179 | else [IntegerEntry(swapFee, feeBps)] | |
| 180 | 180 | } | |
| 181 | 181 | ||
| 489 | 489 | else ((amountInAdjusted * poolAmount2) / poolAmount1) | |
| 490 | 490 | let fee = ((amountOut * feeBps) / toBigInt(10000)) | |
| 491 | 491 | let amountOutAfterFee = (amountOut - fee) | |
| 492 | + | let feeToSend = ((amountInAdjusted * feeBps) / toBigInt(10000)) | |
| 492 | 493 | let minAmountOut = ((amountOutAfterFee * toBigInt((10000 - maxSlippage))) / toBigInt(10000)) | |
| 493 | 494 | if ((minAmountOut > amountOutAfterFee)) | |
| 494 | 495 | then throw("Slippage exceeded") | |
| 500 | 501 | let assetOutBytes = if ((assetOut == "GIC")) | |
| 501 | 502 | then unit | |
| 502 | 503 | else fromBase58String(assetOut) | |
| 503 | - | [IntegerEntry(((key + "_") + poolAsset1), toInt(newPoolAmount1)), IntegerEntry(((key + "_") + poolAsset2), toInt(newPoolAmount2)), ScriptTransfer(i.caller, toInt(amountOutAfterFee), assetOutBytes), ScriptTransfer(adminAddr, toInt( | |
| 504 | + | [IntegerEntry(((key + "_") + poolAsset1), toInt(newPoolAmount1)), IntegerEntry(((key + "_") + poolAsset2), toInt(newPoolAmount2)), ScriptTransfer(i.caller, toInt(amountOutAfterFee), assetOutBytes), ScriptTransfer(adminAddr, toInt(feeToSend), assetOutBytes)] | |
| 504 | 505 | } | |
| 505 | 506 | } | |
| 506 | 507 | } | |
| Old | New | Differences | |
|---|---|---|---|
| 1 | 1 | {-# STDLIB_VERSION 5 #-} | |
| 2 | 2 | {-# SCRIPT_TYPE ACCOUNT #-} | |
| 3 | 3 | {-# CONTENT_TYPE DAPP #-} | |
| 4 | 4 | let main = "main_asset" | |
| 5 | 5 | ||
| 6 | 6 | let adminAddress = "admin_address" | |
| 7 | 7 | ||
| 8 | 8 | let lp = "lp_asset_" | |
| 9 | 9 | ||
| 10 | 10 | let pool = "pool__" | |
| 11 | 11 | ||
| 12 | 12 | let farm = "farm__" | |
| 13 | 13 | ||
| 14 | 14 | let staked = "staked_" | |
| 15 | 15 | ||
| 16 | 16 | let rewardClaimed = "reward_claimed_" | |
| 17 | 17 | ||
| 18 | 18 | let depositHeight = "deposit_height_" | |
| 19 | 19 | ||
| 20 | 20 | let farmHeight = "farm_height_" | |
| 21 | 21 | ||
| 22 | 22 | let totalLocked = "total_locked_" | |
| 23 | 23 | ||
| 24 | 24 | let swapFee = "swap_fee" | |
| 25 | 25 | ||
| 26 | 26 | let farmRewardPool = "farm_reward_pool_" | |
| 27 | 27 | ||
| 28 | 28 | let farmApr = "farm_apr_" | |
| 29 | 29 | ||
| 30 | 30 | let farmLockBlocks = "farm_lock_blocks_" | |
| 31 | 31 | ||
| 32 | 32 | let farmTotalStaked = "farm_total_staked_" | |
| 33 | 33 | ||
| 34 | 34 | let blacklistedTokens = "blacklisted_" | |
| 35 | 35 | ||
| 36 | 36 | let totalUsersFarm = "total_users_farm_" | |
| 37 | 37 | ||
| 38 | 38 | let D8 = 100000000 | |
| 39 | 39 | ||
| 40 | 40 | let contractAddress = Address(this.bytes) | |
| 41 | 41 | ||
| 42 | 42 | let ac = "activate" | |
| 43 | 43 | ||
| 44 | 44 | let poolAc = "activate_pools" | |
| 45 | 45 | ||
| 46 | 46 | let swapAc = "activate_swap" | |
| 47 | 47 | ||
| 48 | 48 | let liquidityAc = "activate_liquidity" | |
| 49 | 49 | ||
| 50 | 50 | let farmAc = "activate_farms" | |
| 51 | 51 | ||
| 52 | 52 | func kp (asset1,asset2) = (((pool + asset1) + "_") + asset2) | |
| 53 | 53 | ||
| 54 | 54 | ||
| 55 | 55 | func fk (asset1,asset2) = (((farm + asset1) + "_") + asset2) | |
| 56 | 56 | ||
| 57 | 57 | ||
| 58 | 58 | func sk (asset1,asset2,address) = (((staked + kp(asset1, asset2)) + "_") + address) | |
| 59 | 59 | ||
| 60 | 60 | ||
| 61 | 61 | func rk (asset1,asset2,address) = (((rewardClaimed + kp(asset1, asset2)) + "_") + address) | |
| 62 | 62 | ||
| 63 | 63 | ||
| 64 | 64 | func dh (asset1,asset2,address) = (((depositHeight + kp(asset1, asset2)) + "_") + address) | |
| 65 | 65 | ||
| 66 | 66 | ||
| 67 | 67 | func fh (asset1,asset2,address) = (((farmHeight + kp(asset1, asset2)) + "_") + address) | |
| 68 | 68 | ||
| 69 | 69 | ||
| 70 | 70 | func isValidAsset (assetId) = if ((assetId == "GIC")) | |
| 71 | 71 | then true | |
| 72 | 72 | else match assetInfo(fromBase58String(assetId)) { | |
| 73 | 73 | case a: Asset => | |
| 74 | 74 | true | |
| 75 | 75 | case _ => | |
| 76 | 76 | false | |
| 77 | 77 | } | |
| 78 | 78 | ||
| 79 | 79 | ||
| 80 | 80 | func isBlacklisted (assetId) = valueOrElse(getBoolean(this, (blacklistedTokens + assetId)), false) | |
| 81 | 81 | ||
| 82 | 82 | ||
| 83 | 83 | func getAssetDecimals (assetId) = if ((assetId == "GIC")) | |
| 84 | 84 | then 8 | |
| 85 | 85 | else match assetInfo(fromBase58String(assetId)) { | |
| 86 | 86 | case a: Asset => | |
| 87 | 87 | a.decimals | |
| 88 | 88 | case _ => | |
| 89 | 89 | 8 | |
| 90 | 90 | } | |
| 91 | 91 | ||
| 92 | 92 | ||
| 93 | 93 | func getAddressIfValid (address) = toString(valueOrErrorMessage(addressFromString(address), (("Can't parse " + address) + " as address"))) | |
| 94 | 94 | ||
| 95 | 95 | ||
| 96 | 96 | func validPoolK (key) = match getInteger(this, key) { | |
| 97 | 97 | case t: Int => | |
| 98 | 98 | t | |
| 99 | 99 | case _ => | |
| 100 | 100 | 0 | |
| 101 | 101 | } | |
| 102 | 102 | ||
| 103 | 103 | ||
| 104 | 104 | func poolAA (key,asset) = match getInteger(this, ((key + "_") + asset)) { | |
| 105 | 105 | case t: Int => | |
| 106 | 106 | t | |
| 107 | 107 | case _ => | |
| 108 | 108 | 0 | |
| 109 | 109 | } | |
| 110 | 110 | ||
| 111 | 111 | ||
| 112 | 112 | func userLiquidity (address,key,asset) = match getInteger(this, ((((key + "_") + address) + "_") + asset)) { | |
| 113 | 113 | case t: Int => | |
| 114 | 114 | t | |
| 115 | 115 | case _ => | |
| 116 | 116 | 0 | |
| 117 | 117 | } | |
| 118 | 118 | ||
| 119 | 119 | ||
| 120 | 120 | func getAdminAddress () = if ((valueOrElse(getStringValue(adminAddress), "") == "")) | |
| 121 | 121 | then throw("Constructor has not been initialized yet!") | |
| 122 | 122 | else getStringValue(adminAddress) | |
| 123 | 123 | ||
| 124 | 124 | ||
| 125 | 125 | @Callable(i) | |
| 126 | 126 | func constructor (MainAssetId,AdminAddress,SwapFeeBps,acceptGic) = if ((i.caller != this)) | |
| 127 | 127 | then throw("Only the contract itself can invoke this function") | |
| 128 | 128 | else if (!(isValidAsset(MainAssetId))) | |
| 129 | 129 | then throw("Invalid MainAssetId") | |
| 130 | 130 | else if ((AdminAddress == "")) | |
| 131 | 131 | then throw("Invalid AdminAddress") | |
| 132 | 132 | else if (if ((0 > SwapFeeBps)) | |
| 133 | 133 | then true | |
| 134 | 134 | else (SwapFeeBps > 1000)) | |
| 135 | 135 | then throw("SwapFeeBps must be between 0 and 1000") | |
| 136 | 136 | else [StringEntry(main, MainAssetId), StringEntry(adminAddress, AdminAddress), IntegerEntry(swapFee, SwapFeeBps), BooleanEntry(ac, true), BooleanEntry(poolAc, false), BooleanEntry(swapAc, false), BooleanEntry(liquidityAc, false), BooleanEntry(farmAc, false), BooleanEntry("accept_gic", acceptGic)] | |
| 137 | 137 | ||
| 138 | 138 | ||
| 139 | 139 | ||
| 140 | 140 | @Callable(i) | |
| 141 | 141 | func changeAdmin (address) = { | |
| 142 | 142 | let admin = getAdminAddress() | |
| 143 | 143 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 144 | 144 | then throw("Only the Admin itself can invoke this function.") | |
| 145 | 145 | else [StringEntry(adminAddress, address)] | |
| 146 | 146 | } | |
| 147 | 147 | ||
| 148 | 148 | ||
| 149 | 149 | ||
| 150 | 150 | @Callable(i) | |
| 151 | 151 | func activate (v) = { | |
| 152 | 152 | let admin = getAdminAddress() | |
| 153 | 153 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 154 | 154 | then throw("Only the Admin itself can invoke this function") | |
| 155 | 155 | else [BooleanEntry(ac, v)] | |
| 156 | 156 | } | |
| 157 | 157 | ||
| 158 | 158 | ||
| 159 | 159 | ||
| 160 | 160 | @Callable(i) | |
| 161 | 161 | func maintenance (pools,swap,stake,farms) = { | |
| 162 | 162 | let admin = getAdminAddress() | |
| 163 | 163 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 164 | 164 | then throw("Only the Admin itself can invoke this function") | |
| 165 | 165 | else [BooleanEntry(poolAc, pools), BooleanEntry(swapAc, swap), BooleanEntry(liquidityAc, stake), BooleanEntry(farmAc, farms)] | |
| 166 | 166 | } | |
| 167 | 167 | ||
| 168 | 168 | ||
| 169 | 169 | ||
| 170 | 170 | @Callable(i) | |
| 171 | 171 | func setSwapFee (feeBps) = { | |
| 172 | 172 | let admin = getAdminAddress() | |
| 173 | 173 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 174 | 174 | then throw("Only the Admin itself can invoke this function") | |
| 175 | 175 | else if (if ((0 > feeBps)) | |
| 176 | 176 | then true | |
| 177 | 177 | else (feeBps > 1000)) | |
| 178 | - | then throw("Fee must be between 0 and 1000 basis points | |
| 178 | + | then throw("Fee must be between 0 and 1000 basis points") | |
| 179 | 179 | else [IntegerEntry(swapFee, feeBps)] | |
| 180 | 180 | } | |
| 181 | 181 | ||
| 182 | 182 | ||
| 183 | 183 | ||
| 184 | 184 | @Callable(i) | |
| 185 | 185 | func blacklistToken (assetId,blacklist) = { | |
| 186 | 186 | let admin = getAdminAddress() | |
| 187 | 187 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 188 | 188 | then throw("Only the Admin itself can invoke this function") | |
| 189 | 189 | else if (if (!(isValidAsset(assetId))) | |
| 190 | 190 | then (assetId != "GIC") | |
| 191 | 191 | else false) | |
| 192 | 192 | then throw("Invalid assetId") | |
| 193 | 193 | else [BooleanEntry((blacklistedTokens + assetId), blacklist)] | |
| 194 | 194 | } | |
| 195 | 195 | ||
| 196 | 196 | ||
| 197 | 197 | ||
| 198 | 198 | @Callable(i) | |
| 199 | 199 | func createFarm (asset1,asset2,apr,lockBlocks,rewardAmount) = { | |
| 200 | 200 | let admin = getAdminAddress() | |
| 201 | 201 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 202 | 202 | then throw("Only the Admin itself can invoke this function") | |
| 203 | 203 | else if (!(isValidAsset(asset1))) | |
| 204 | 204 | then throw("Invalid asset1") | |
| 205 | 205 | else if (!(isValidAsset(asset2))) | |
| 206 | 206 | then throw("Invalid asset2") | |
| 207 | 207 | else if ((asset1 == asset2)) | |
| 208 | 208 | then throw("Asset1 cannot be equal to Asset2") | |
| 209 | 209 | else if ((0 >= apr)) | |
| 210 | 210 | then throw("APR must be positive") | |
| 211 | 211 | else if ((0 >= lockBlocks)) | |
| 212 | 212 | then throw("Lock blocks must be positive") | |
| 213 | 213 | else if ((0 >= rewardAmount)) | |
| 214 | 214 | then throw("Reward amount must be positive") | |
| 215 | 215 | else { | |
| 216 | 216 | let poolKey = kp(asset1, asset2) | |
| 217 | 217 | if ((validPoolK(poolKey) == 0)) | |
| 218 | 218 | then throw("Pool does not exist") | |
| 219 | 219 | else { | |
| 220 | 220 | let farmKey = fk(asset1, asset2) | |
| 221 | 221 | [IntegerEntry(farmKey, 1), IntegerEntry((farmApr + poolKey), apr), IntegerEntry((farmLockBlocks + poolKey), lockBlocks), IntegerEntry((farmRewardPool + poolKey), rewardAmount), IntegerEntry((farmTotalStaked + poolKey), 0), IntegerEntry((totalUsersFarm + poolKey), 0)] | |
| 222 | 222 | } | |
| 223 | 223 | } | |
| 224 | 224 | } | |
| 225 | 225 | ||
| 226 | 226 | ||
| 227 | 227 | ||
| 228 | 228 | @Callable(i) | |
| 229 | 229 | func fundFarm (asset1,asset2) = { | |
| 230 | 230 | let admin = getAdminAddress() | |
| 231 | 231 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 232 | 232 | then throw("Only the Admin itself can invoke this function") | |
| 233 | 233 | else { | |
| 234 | 234 | let pmt = i.payments[0] | |
| 235 | 235 | let pmtAssetId = match pmt.assetId { | |
| 236 | 236 | case a: ByteVector => | |
| 237 | 237 | toBase58String(a) | |
| 238 | 238 | case _ => | |
| 239 | 239 | "GIC" | |
| 240 | 240 | } | |
| 241 | 241 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 242 | 242 | then throw("Only the Admin itself can invoke this function") | |
| 243 | 243 | else if ((pmtAssetId != "GIC")) | |
| 244 | 244 | then throw("Rewards must be in GIC") | |
| 245 | 245 | else { | |
| 246 | 246 | let poolKey = kp(asset1, asset2) | |
| 247 | 247 | let farmKey = fk(asset1, asset2) | |
| 248 | 248 | if ((valueOrElse(getInteger(this, farmKey), 0) == 0)) | |
| 249 | 249 | then throw("Farm does not exist") | |
| 250 | 250 | else { | |
| 251 | 251 | let currentRewardPool = valueOrElse(getInteger(this, (farmRewardPool + poolKey)), 0) | |
| 252 | 252 | let newRewardPool = (currentRewardPool + pmt.amount) | |
| 253 | 253 | [IntegerEntry((farmRewardPool + poolKey), newRewardPool)] | |
| 254 | 254 | } | |
| 255 | 255 | } | |
| 256 | 256 | } | |
| 257 | 257 | } | |
| 258 | 258 | ||
| 259 | 259 | ||
| 260 | 260 | ||
| 261 | 261 | @Callable(i) | |
| 262 | 262 | func createPool (asset1,asset2,nameLp) = { | |
| 263 | 263 | let poolKey = kp(asset1, asset2) | |
| 264 | 264 | let admin = getAdminAddress() | |
| 265 | 265 | if ((toBase58String(i.caller.bytes) != admin)) | |
| 266 | 266 | then throw("Only the Admin itself can invoke this function") | |
| 267 | 267 | else if (!(isValidAsset(asset1))) | |
| 268 | 268 | then throw("Invalid asset1") | |
| 269 | 269 | else if (!(isValidAsset(asset2))) | |
| 270 | 270 | then throw("Invalid asset2") | |
| 271 | 271 | else if ((asset1 == asset2)) | |
| 272 | 272 | then throw("Asset1 cannot be equal to Asset2") | |
| 273 | 273 | else if (if (isBlacklisted(asset1)) | |
| 274 | 274 | then true | |
| 275 | 275 | else isBlacklisted(asset2)) | |
| 276 | 276 | then throw("One or both assets are blacklisted") | |
| 277 | 277 | else if ((validPoolK(poolKey) != 0)) | |
| 278 | 278 | then throw("Pool already exists") | |
| 279 | 279 | else { | |
| 280 | 280 | let assetLpCreate = Issue(nameLp, ((("LP asset for pool " + asset1) + "_") + asset2), 1, 8, true) | |
| 281 | 281 | let idAssetLp = calculateAssetId(assetLpCreate) | |
| 282 | 282 | [assetLpCreate, StringEntry((lp + poolKey), toBase58String(idAssetLp)), IntegerEntry(poolKey, 1)] | |
| 283 | 283 | } | |
| 284 | 284 | } | |
| 285 | 285 | ||
| 286 | 286 | ||
| 287 | 287 | ||
| 288 | 288 | @Callable(i) | |
| 289 | 289 | func addLiquidity (asset1,asset2) = { | |
| 290 | 290 | let power = getBooleanValue(this, ac) | |
| 291 | 291 | let liquidityPower = getBooleanValue(this, liquidityAc) | |
| 292 | 292 | let acGic = getBooleanValue(this, "accept_gic") | |
| 293 | 293 | let poolKey = kp(asset1, asset2) | |
| 294 | 294 | let pmt1 = i.payments[0] | |
| 295 | 295 | let pmt2 = i.payments[1] | |
| 296 | 296 | let asset1Id = match pmt1.assetId { | |
| 297 | 297 | case a: ByteVector => | |
| 298 | 298 | toBase58String(a) | |
| 299 | 299 | case _ => | |
| 300 | 300 | "GIC" | |
| 301 | 301 | } | |
| 302 | 302 | let asset2Id = match pmt2.assetId { | |
| 303 | 303 | case a: ByteVector => | |
| 304 | 304 | toBase58String(a) | |
| 305 | 305 | case _ => | |
| 306 | 306 | "GIC" | |
| 307 | 307 | } | |
| 308 | 308 | let decimals1 = getAssetDecimals(asset1Id) | |
| 309 | 309 | let decimals2 = getAssetDecimals(asset2Id) | |
| 310 | 310 | if (!(power)) | |
| 311 | 311 | then throw("dApp is currently under maintenance") | |
| 312 | 312 | else if (liquidityPower) | |
| 313 | 313 | then throw("Liquidity is currently under maintenance") | |
| 314 | 314 | else if (if ((asset1Id != asset1)) | |
| 315 | 315 | then true | |
| 316 | 316 | else (asset2Id != asset2)) | |
| 317 | 317 | then throw("Payment assets do not match specified assets") | |
| 318 | 318 | else if ((asset1 == asset2)) | |
| 319 | 319 | then throw("Asset1 cannot be equal to Asset2") | |
| 320 | 320 | else if (!(isValidAsset(asset1))) | |
| 321 | 321 | then throw("Invalid asset1") | |
| 322 | 322 | else if (!(isValidAsset(asset2))) | |
| 323 | 323 | then throw("Invalid asset2") | |
| 324 | 324 | else if (if (isBlacklisted(asset1)) | |
| 325 | 325 | then true | |
| 326 | 326 | else isBlacklisted(asset2)) | |
| 327 | 327 | then throw("One or both assets are blacklisted") | |
| 328 | 328 | else if (if (if ((asset1 == "GIC")) | |
| 329 | 329 | then true | |
| 330 | 330 | else (asset2 == "GIC")) | |
| 331 | 331 | then !(acGic) | |
| 332 | 332 | else false) | |
| 333 | 333 | then throw("GIC not allowed") | |
| 334 | 334 | else if ((validPoolK(poolKey) == 0)) | |
| 335 | 335 | then throw("Pool does not exist. Create it first") | |
| 336 | 336 | else { | |
| 337 | 337 | let poolAmount1 = poolAA(poolKey, asset1) | |
| 338 | 338 | let poolAmount2 = poolAA(poolKey, asset2) | |
| 339 | 339 | let amount1 = pmt1.amount | |
| 340 | 340 | let amount2 = pmt2.amount | |
| 341 | 341 | let lpAmount = if (if ((poolAmount1 == 0)) | |
| 342 | 342 | then true | |
| 343 | 343 | else (poolAmount2 == 0)) | |
| 344 | 344 | then toBigInt(amount1) | |
| 345 | 345 | else ((toBigInt(amount1) * toBigInt(poolAmount2)) / toBigInt(poolAmount1)) | |
| 346 | 346 | let currentKey = toBase58String(i.caller.bytes) | |
| 347 | 347 | let currentAmountAsset1 = userLiquidity(currentKey, poolKey, asset1) | |
| 348 | 348 | let currentAmountAsset2 = userLiquidity(currentKey, poolKey, asset2) | |
| 349 | 349 | let newAmountAsset1 = (toBigInt(currentAmountAsset1) + toBigInt(amount1)) | |
| 350 | 350 | let newAmountAsset2 = (toBigInt(currentAmountAsset2) + toBigInt(amount2)) | |
| 351 | 351 | let newPoolAmount1 = (toBigInt(poolAmount1) + toBigInt(amount1)) | |
| 352 | 352 | let newPoolAmount2 = (toBigInt(poolAmount2) + toBigInt(amount2)) | |
| 353 | 353 | let lpAssetId = getStringValue(this, (lp + poolKey)) | |
| 354 | 354 | let oldAssetLpTotal = valueOrElse(getIntegerValue(poolKey), 0) | |
| 355 | 355 | let lpAsset = if ((lpAssetId == "")) | |
| 356 | 356 | then throw("Pool does not have a liquidity pair, contact admin") | |
| 357 | 357 | else fromBase58String(lpAssetId) | |
| 358 | 358 | [IntegerEntry(((((poolKey + "_") + currentKey) + "_") + asset1), toInt(newAmountAsset1)), IntegerEntry(((((poolKey + "_") + currentKey) + "_") + asset2), toInt(newAmountAsset2)), IntegerEntry(((poolKey + "_") + asset1), toInt(newPoolAmount1)), IntegerEntry(((poolKey + "_") + asset2), toInt(newPoolAmount2)), IntegerEntry((((depositHeight + poolKey) + "_") + currentKey), height), IntegerEntry(poolKey, (oldAssetLpTotal + toInt(lpAmount))), Reissue(lpAsset, toInt(lpAmount), true), ScriptTransfer(i.caller, toInt(lpAmount), lpAsset)] | |
| 359 | 359 | } | |
| 360 | 360 | } | |
| 361 | 361 | ||
| 362 | 362 | ||
| 363 | 363 | ||
| 364 | 364 | @Callable(i) | |
| 365 | 365 | func removeLiquidity (asset1,asset2,lpAmount) = { | |
| 366 | 366 | let power = getBooleanValue(this, ac) | |
| 367 | 367 | let liquidityPower = getBooleanValue(this, liquidityAc) | |
| 368 | 368 | let poolKey = kp(asset1, asset2) | |
| 369 | 369 | let lpAssetId = getStringValue(this, (lp + poolKey)) | |
| 370 | 370 | let lpAsset = fromBase58String(lpAssetId) | |
| 371 | 371 | let pmt = i.payments[0] | |
| 372 | 372 | let pmtAssetId = match pmt.assetId { | |
| 373 | 373 | case a: ByteVector => | |
| 374 | 374 | toBase58String(a) | |
| 375 | 375 | case _ => | |
| 376 | 376 | "GIC" | |
| 377 | 377 | } | |
| 378 | 378 | let decimals1 = getAssetDecimals(asset1) | |
| 379 | 379 | let decimals2 = getAssetDecimals(asset2) | |
| 380 | 380 | if (!(power)) | |
| 381 | 381 | then throw("dApp is currently under maintenance") | |
| 382 | 382 | else if (liquidityPower) | |
| 383 | 383 | then throw("Liquidity is currently under maintenance") | |
| 384 | 384 | else if ((lpAssetId == "")) | |
| 385 | 385 | then throw("Invalid LP asset") | |
| 386 | 386 | else if ((pmtAssetId != lpAssetId)) | |
| 387 | 387 | then throw("Invalid LP token") | |
| 388 | 388 | else if ((validPoolK(poolKey) == 0)) | |
| 389 | 389 | then throw("Pool does not exist") | |
| 390 | 390 | else if ((0 >= lpAmount)) | |
| 391 | 391 | then throw("LP amount must be positive") | |
| 392 | 392 | else { | |
| 393 | 393 | let poolAmount1 = poolAA(poolKey, asset1) | |
| 394 | 394 | let poolAmount2 = poolAA(poolKey, asset2) | |
| 395 | 395 | let totalLpSupply = match assetInfo(fromBase58String(lpAssetId)) { | |
| 396 | 396 | case a: Asset => | |
| 397 | 397 | a.quantity | |
| 398 | 398 | case _ => | |
| 399 | 399 | 0 | |
| 400 | 400 | } | |
| 401 | 401 | let amount1 = ((lpAmount * poolAmount1) / totalLpSupply) | |
| 402 | 402 | let amount2 = ((lpAmount * poolAmount2) / totalLpSupply) | |
| 403 | 403 | let currentKey = toBase58String(i.caller.bytes) | |
| 404 | 404 | let currentAmountAsset1 = userLiquidity(currentKey, poolKey, asset1) | |
| 405 | 405 | let currentAmountAsset2 = userLiquidity(currentKey, poolKey, asset2) | |
| 406 | 406 | let newAmountAsset1 = (currentAmountAsset1 - amount1) | |
| 407 | 407 | let newAmountAsset2 = (currentAmountAsset2 - amount2) | |
| 408 | 408 | if (if ((0 > newAmountAsset1)) | |
| 409 | 409 | then true | |
| 410 | 410 | else (0 > newAmountAsset2)) | |
| 411 | 411 | then throw("Insufficient liquidity balance") | |
| 412 | 412 | else { | |
| 413 | 413 | let newPoolAmount1 = (poolAmount1 - amount1) | |
| 414 | 414 | let newPoolAmount2 = (poolAmount2 - amount2) | |
| 415 | 415 | let asset1Bytes = if ((asset1 == "GIC")) | |
| 416 | 416 | then unit | |
| 417 | 417 | else fromBase58String(asset1) | |
| 418 | 418 | let asset2Bytes = if ((asset2 == "GIC")) | |
| 419 | 419 | then unit | |
| 420 | 420 | else fromBase58String(asset2) | |
| 421 | 421 | let oldAssetLpTotal = getIntegerValue(poolKey) | |
| 422 | 422 | [IntegerEntry(((((poolKey + "_") + currentKey) + "_") + asset1), newAmountAsset1), IntegerEntry(((((poolKey + "_") + currentKey) + "_") + asset2), newAmountAsset2), IntegerEntry(((poolKey + "_") + asset1), newPoolAmount1), IntegerEntry(((poolKey + "_") + asset2), newPoolAmount2), IntegerEntry(poolKey, (oldAssetLpTotal - lpAmount)), Burn(lpAsset, lpAmount), ScriptTransfer(i.caller, amount1, asset1Bytes), ScriptTransfer(i.caller, amount2, asset2Bytes)] | |
| 423 | 423 | } | |
| 424 | 424 | } | |
| 425 | 425 | } | |
| 426 | 426 | ||
| 427 | 427 | ||
| 428 | 428 | ||
| 429 | 429 | @Callable(i) | |
| 430 | 430 | func swap (assetIn,assetOut,maxSlippage) = { | |
| 431 | 431 | let power = getBooleanValue(this, ac) | |
| 432 | 432 | let swapActivate = getBooleanValue(this, swapAc) | |
| 433 | 433 | let acGic = getBooleanValue(this, "accept_gic") | |
| 434 | 434 | let poolKey = kp(assetIn, assetOut) | |
| 435 | 435 | let reversePoolKey = kp(assetOut, assetIn) | |
| 436 | 436 | let key = if ((validPoolK(poolKey) != 0)) | |
| 437 | 437 | then poolKey | |
| 438 | 438 | else if ((validPoolK(reversePoolKey) != 0)) | |
| 439 | 439 | then reversePoolKey | |
| 440 | 440 | else "" | |
| 441 | 441 | let pmt = i.payments[0] | |
| 442 | 442 | let pmtAssetId = match pmt.assetId { | |
| 443 | 443 | case a: ByteVector => | |
| 444 | 444 | toBase58String(a) | |
| 445 | 445 | case _ => | |
| 446 | 446 | "GIC" | |
| 447 | 447 | } | |
| 448 | 448 | let decimalsIn = getAssetDecimals(assetIn) | |
| 449 | 449 | let decimalsOut = getAssetDecimals(assetOut) | |
| 450 | 450 | let feeBps = toBigInt(getIntegerValue(this, swapFee)) | |
| 451 | 451 | let adminAddr = addressFromStringValue(getStringValue(this, adminAddress)) | |
| 452 | 452 | if (!(power)) | |
| 453 | 453 | then throw("dApp is currently under maintenance") | |
| 454 | 454 | else if (swapActivate) | |
| 455 | 455 | then throw("Swap is currently under maintenance") | |
| 456 | 456 | else if ((pmtAssetId != assetIn)) | |
| 457 | 457 | then throw("Payment asset does not match assetIn") | |
| 458 | 458 | else if (!(isValidAsset(assetIn))) | |
| 459 | 459 | then throw("Invalid assetIn") | |
| 460 | 460 | else if (!(isValidAsset(assetOut))) | |
| 461 | 461 | then throw("Invalid assetOut") | |
| 462 | 462 | else if (if (isBlacklisted(assetIn)) | |
| 463 | 463 | then true | |
| 464 | 464 | else isBlacklisted(assetOut)) | |
| 465 | 465 | then throw("One or both assets are blacklisted") | |
| 466 | 466 | else if ((assetIn == assetOut)) | |
| 467 | 467 | then throw("assetIn cannot be equal to assetOut") | |
| 468 | 468 | else if (if (if ((assetIn == "GIC")) | |
| 469 | 469 | then true | |
| 470 | 470 | else (assetOut == "GIC")) | |
| 471 | 471 | then !(acGic) | |
| 472 | 472 | else false) | |
| 473 | 473 | then throw("GIC not allowed") | |
| 474 | 474 | else if ((key == "")) | |
| 475 | 475 | then throw("Pool does not exist") | |
| 476 | 476 | else { | |
| 477 | 477 | let isReverse = (key == reversePoolKey) | |
| 478 | 478 | let poolAsset1 = if (isReverse) | |
| 479 | 479 | then assetOut | |
| 480 | 480 | else assetIn | |
| 481 | 481 | let poolAsset2 = if (isReverse) | |
| 482 | 482 | then assetIn | |
| 483 | 483 | else assetOut | |
| 484 | 484 | let poolAmount1 = toBigInt(poolAA(key, poolAsset1)) | |
| 485 | 485 | let poolAmount2 = toBigInt(poolAA(key, poolAsset2)) | |
| 486 | 486 | let amountInAdjusted = toBigInt(pmt.amount) | |
| 487 | 487 | let amountOut = if (isReverse) | |
| 488 | 488 | then ((amountInAdjusted * poolAmount2) / (poolAmount1 + amountInAdjusted)) | |
| 489 | 489 | else ((amountInAdjusted * poolAmount2) / poolAmount1) | |
| 490 | 490 | let fee = ((amountOut * feeBps) / toBigInt(10000)) | |
| 491 | 491 | let amountOutAfterFee = (amountOut - fee) | |
| 492 | + | let feeToSend = ((amountInAdjusted * feeBps) / toBigInt(10000)) | |
| 492 | 493 | let minAmountOut = ((amountOutAfterFee * toBigInt((10000 - maxSlippage))) / toBigInt(10000)) | |
| 493 | 494 | if ((minAmountOut > amountOutAfterFee)) | |
| 494 | 495 | then throw("Slippage exceeded") | |
| 495 | 496 | else { | |
| 496 | 497 | let newPoolAmount1 = (poolAmount1 + (if (isReverse) | |
| 497 | 498 | then toBigInt(0) | |
| 498 | 499 | else amountInAdjusted)) | |
| 499 | 500 | let newPoolAmount2 = (poolAmount2 - amountOut) | |
| 500 | 501 | let assetOutBytes = if ((assetOut == "GIC")) | |
| 501 | 502 | then unit | |
| 502 | 503 | else fromBase58String(assetOut) | |
| 503 | - | [IntegerEntry(((key + "_") + poolAsset1), toInt(newPoolAmount1)), IntegerEntry(((key + "_") + poolAsset2), toInt(newPoolAmount2)), ScriptTransfer(i.caller, toInt(amountOutAfterFee), assetOutBytes), ScriptTransfer(adminAddr, toInt( | |
| 504 | + | [IntegerEntry(((key + "_") + poolAsset1), toInt(newPoolAmount1)), IntegerEntry(((key + "_") + poolAsset2), toInt(newPoolAmount2)), ScriptTransfer(i.caller, toInt(amountOutAfterFee), assetOutBytes), ScriptTransfer(adminAddr, toInt(feeToSend), assetOutBytes)] | |
| 504 | 505 | } | |
| 505 | 506 | } | |
| 506 | 507 | } | |
| 507 | 508 | ||
| 508 | 509 | ||
| 509 | 510 | ||
| 510 | 511 | @Callable(i) | |
| 511 | 512 | func farmsAddLP (asset1,asset2) = { | |
| 512 | 513 | let power = getBooleanValue(this, ac) | |
| 513 | 514 | let farmPower = getBooleanValue(this, farmAc) | |
| 514 | 515 | let poolKey = kp(asset1, asset2) | |
| 515 | 516 | let farmKey = fk(asset1, asset2) | |
| 516 | 517 | let pmt = i.payments[0] | |
| 517 | 518 | let lpAssetId = getStringValue(this, (lp + poolKey)) | |
| 518 | 519 | let pmtAssetId = match pmt.assetId { | |
| 519 | 520 | case a: ByteVector => | |
| 520 | 521 | toBase58String(a) | |
| 521 | 522 | case _ => | |
| 522 | 523 | "GIC" | |
| 523 | 524 | } | |
| 524 | 525 | if (!(power)) | |
| 525 | 526 | then throw("dApp is currently under maintenance") | |
| 526 | 527 | else if (farmPower) | |
| 527 | 528 | then throw("Farms are currently under maintenance") | |
| 528 | 529 | else if ((pmtAssetId != lpAssetId)) | |
| 529 | 530 | then throw("Invalid LP token") | |
| 530 | 531 | else if ((validPoolK(poolKey) == 0)) | |
| 531 | 532 | then throw("Pool does not exist") | |
| 532 | 533 | else if ((valueOrElse(getInteger(this, farmKey), 0) == 0)) | |
| 533 | 534 | then throw("Farm does not exist") | |
| 534 | 535 | else { | |
| 535 | 536 | let currentKey = toBase58String(i.caller.bytes) | |
| 536 | 537 | let stakedKey = sk(asset1, asset2, currentKey) | |
| 537 | 538 | let currentStaked = valueOrElse(getInteger(this, stakedKey), 0) | |
| 538 | 539 | let newStaked = (currentStaked + pmt.amount) | |
| 539 | 540 | let totalStakedKey = (farmTotalStaked + poolKey) | |
| 540 | 541 | let previousTotalStaked = valueOrElse(getInteger(this, totalStakedKey), 0) | |
| 541 | 542 | let newTotalStaked = (previousTotalStaked + pmt.amount) | |
| 542 | 543 | let totalUsers = valueOrElse(getInteger(this, (totalUsersFarm + poolKey)), 0) | |
| 543 | 544 | let newTotalUsers = if ((currentStaked == 0)) | |
| 544 | 545 | then (totalUsers + 1) | |
| 545 | 546 | else totalUsers | |
| 546 | 547 | [IntegerEntry(stakedKey, newStaked), IntegerEntry(totalStakedKey, newTotalStaked), IntegerEntry((totalUsersFarm + poolKey), newTotalUsers), IntegerEntry(fh(asset1, asset2, currentKey), height)] | |
| 547 | 548 | } | |
| 548 | 549 | } | |
| 549 | 550 | ||
| 550 | 551 | ||
| 551 | 552 | ||
| 552 | 553 | @Callable(i) | |
| 553 | 554 | func farmsClaimLP (asset1,asset2) = { | |
| 554 | 555 | let power = getBooleanValue(this, ac) | |
| 555 | 556 | let farmPower = getBooleanValue(this, farmAc) | |
| 556 | 557 | let poolKey = kp(asset1, asset2) | |
| 557 | 558 | let farmKey = fk(asset1, asset2) | |
| 558 | 559 | let currentKey = toBase58String(i.caller.bytes) | |
| 559 | 560 | let stakedKey = sk(asset1, asset2, currentKey) | |
| 560 | 561 | let heightKey = fh(asset1, asset2, currentKey) | |
| 561 | 562 | let rewardKey = rk(asset1, asset2, currentKey) | |
| 562 | 563 | if (!(power)) | |
| 563 | 564 | then throw("dApp is currently under maintenance") | |
| 564 | 565 | else if (farmPower) | |
| 565 | 566 | then throw("Farms are currently under maintenance") | |
| 566 | 567 | else if ((validPoolK(poolKey) == 0)) | |
| 567 | 568 | then throw("Pool does not exist") | |
| 568 | 569 | else if ((valueOrElse(getInteger(this, farmKey), 0) == 0)) | |
| 569 | 570 | then throw("Farm does not exist") | |
| 570 | 571 | else { | |
| 571 | 572 | let currentStaked = valueOrElse(getInteger(this, stakedKey), 0) | |
| 572 | 573 | if ((0 >= currentStaked)) | |
| 573 | 574 | then throw("No staked LP tokens") | |
| 574 | 575 | else { | |
| 575 | 576 | let rewardPool = valueOrElse(getInteger(this, (farmRewardPool + poolKey)), 0) | |
| 576 | 577 | let totalUsers = valueOrElse(getInteger(this, (totalUsersFarm + poolKey)), 1) | |
| 577 | 578 | let lockBlocks = getIntegerValue(this, (farmLockBlocks + poolKey)) | |
| 578 | 579 | let apr = getIntegerValue(this, (farmApr + poolKey)) | |
| 579 | 580 | let lastClaimHeight = valueOrElse(getInteger(this, heightKey), height) | |
| 580 | 581 | let blocksSinceLastClaim = (height - lastClaimHeight) | |
| 581 | 582 | if ((1 > blocksSinceLastClaim)) | |
| 582 | 583 | then throw("Must wait at least 1 block since last claim") | |
| 583 | 584 | else { | |
| 584 | 585 | let rewardPerBlock = ((rewardPool * apr) / ((10000 * lockBlocks) * totalUsers)) | |
| 585 | 586 | let reward = (((rewardPerBlock * blocksSinceLastClaim) * currentStaked) / D8) | |
| 586 | 587 | if ((reward > rewardPool)) | |
| 587 | 588 | then throw("Insufficient reward pool") | |
| 588 | 589 | else { | |
| 589 | 590 | let newRewardPool = (rewardPool - reward) | |
| 590 | 591 | [IntegerEntry(rewardKey, 0), IntegerEntry((farmRewardPool + poolKey), newRewardPool), IntegerEntry(heightKey, height), ScriptTransfer(i.caller, reward, unit)] | |
| 591 | 592 | } | |
| 592 | 593 | } | |
| 593 | 594 | } | |
| 594 | 595 | } | |
| 595 | 596 | } | |
| 596 | 597 | ||
| 597 | 598 | ||
| 598 | 599 | ||
| 599 | 600 | @Callable(i) | |
| 600 | 601 | func farmsRemoveLP (asset1,asset2,amount) = { | |
| 601 | 602 | let power = getBooleanValue(this, ac) | |
| 602 | 603 | let farmPower = getBooleanValue(this, farmAc) | |
| 603 | 604 | let poolKey = kp(asset1, asset2) | |
| 604 | 605 | let farmKey = fk(asset1, asset2) | |
| 605 | 606 | let lpAssetId = getStringValue(this, (lp + poolKey)) | |
| 606 | 607 | let lpAsset = if ((lpAssetId == "")) | |
| 607 | 608 | then unit | |
| 608 | 609 | else fromBase58String(lpAssetId) | |
| 609 | 610 | let currentKey = toBase58String(i.caller.bytes) | |
| 610 | 611 | let stakedKey = sk(asset1, asset2, currentKey) | |
| 611 | 612 | let heightKey = fh(asset1, asset2, currentKey) | |
| 612 | 613 | let rewardKey = rk(asset1, asset2, currentKey) | |
| 613 | 614 | if (!(power)) | |
| 614 | 615 | then throw("dApp is currently under maintenance") | |
| 615 | 616 | else if (farmPower) | |
| 616 | 617 | then throw("Farms are currently under maintenance") | |
| 617 | 618 | else if ((validPoolK(poolKey) == 0)) | |
| 618 | 619 | then throw("Pool does not exist") | |
| 619 | 620 | else if ((valueOrElse(getInteger(this, farmKey), 0) == 0)) | |
| 620 | 621 | then throw("Farm does not exist") | |
| 621 | 622 | else { | |
| 622 | 623 | let currentStaked = valueOrElse(getInteger(this, stakedKey), 0) | |
| 623 | 624 | if ((0 >= amount)) | |
| 624 | 625 | then throw("Amount must be positive") | |
| 625 | 626 | else if ((amount > currentStaked)) | |
| 626 | 627 | then throw("Insufficient staked LP tokens") | |
| 627 | 628 | else { | |
| 628 | 629 | let rewardPool = valueOrElse(getInteger(this, (farmRewardPool + poolKey)), 0) | |
| 629 | 630 | let totalUsers = valueOrElse(getInteger(this, (totalUsersFarm + poolKey)), 1) | |
| 630 | 631 | let lockBlocks = getIntegerValue(this, (farmLockBlocks + poolKey)) | |
| 631 | 632 | let apr = getIntegerValue(this, (farmApr + poolKey)) | |
| 632 | 633 | let lastClaimHeight = valueOrElse(getInteger(this, heightKey), height) | |
| 633 | 634 | let blocksSinceLastClaim = (height - lastClaimHeight) | |
| 634 | 635 | let rewardPerBlock = ((rewardPool * apr) / ((10000 * lockBlocks) * totalUsers)) | |
| 635 | 636 | let reward = if ((blocksSinceLastClaim >= 1)) | |
| 636 | 637 | then (((rewardPerBlock * blocksSinceLastClaim) * currentStaked) / D8) | |
| 637 | 638 | else 0 | |
| 638 | 639 | let newRewardPool = (rewardPool - reward) | |
| 639 | 640 | let newStaked = (currentStaked - amount) | |
| 640 | 641 | let totalStakedKey = (farmTotalStaked + poolKey) | |
| 641 | 642 | let previousTotalStaked = valueOrElse(getInteger(this, totalStakedKey), 0) | |
| 642 | 643 | let newTotalStaked = (previousTotalStaked - amount) | |
| 643 | 644 | let newTotalUsers = if ((newStaked == 0)) | |
| 644 | 645 | then (totalUsers - 1) | |
| 645 | 646 | else totalUsers | |
| 646 | 647 | [IntegerEntry(stakedKey, newStaked), IntegerEntry(totalStakedKey, newTotalStaked), IntegerEntry((totalUsersFarm + poolKey), newTotalUsers), IntegerEntry(rewardKey, 0), IntegerEntry((farmRewardPool + poolKey), newRewardPool), IntegerEntry(heightKey, height), ScriptTransfer(i.caller, amount, lpAsset), ScriptTransfer(i.caller, reward, unit)] | |
| 647 | 648 | } | |
| 648 | 649 | } | |
| 649 | 650 | } | |
| 650 | 651 | ||
| 651 | 652 | ||
| 652 | 653 | @Verifier(tx) | |
| 653 | 654 | func verify () = match tx { | |
| 654 | 655 | case _ => | |
| 655 | 656 | sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey) | |
| 656 | 657 | } | |
| 657 | 658 |
github/gicsportsofficial/g8-explorer 98.21 ms ◑