tx · 65uA4Nc74G56WHxPxVruuEmrgfVY66iwiJsncugkob8c

3N3NqauKXq2QjcxWi2SVu4nQagiiDp1VT6v:  -0.01300000 Waves

2023.03.01 11:05 [2470739] smart account 3N3NqauKXq2QjcxWi2SVu4nQagiiDp1VT6v > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "65uA4Nc74G56WHxPxVruuEmrgfVY66iwiJsncugkob8c",
    "fee": 1300000,
    "feeAssetId": null,
    "timestamp": 1677657937118,
    "version": 1,
    "sender": "3N3NqauKXq2QjcxWi2SVu4nQagiiDp1VT6v",
    "senderPublicKey": "GXatwSE4biXGp1Mr2emAUQxFGNZU6T5tZhsWDVnysdXq",
    "proofs": [
        "4GVozxTCSYKpZi23jSF2TjjqWPJ2zSYEVHjjn1jAHbnsCh7saJhYvq7vspccnzU1mK3ud1pFyYYTkurFmvVWTtQ2"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2470739,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: DU3JdKws4YREFNKfQbiCfF5VyS52B2fWdJQruwmM1KG

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let scale8 = 100000000
7+
8+let poolStatsPriceKey = 4
9+
10+let idxPoolAddress = 1
11+
12+let idxPoolStatus = 2
13+
14+let idxPoolLPAssetId = 3
15+
16+let idxAmtAssetId = 4
17+
18+let idxPriceAssetId = 5
19+
20+let idxAmtAssetDcm = 6
21+
22+let idxPriceAssetDcm = 7
23+
24+let idxIAmtAssetId = 8
25+
26+let idxIPriceAssetId = 9
27+
28+let idxLPAssetDcm = 10
29+
30+let idxMatcherPublicKey = 11
31+
32+func keyRegisterPut (poolAddress,txId) = ((("%s%s%s__P__" + poolAddress) + "__") + txId)
33+
34+
35+func keyRegisterInvest (poolAddress,txId) = ((("%s%s%s__invest__" + poolAddress) + "__") + txId)
36+
37+
38+func keyPoolTotalAmtByAsset (poolAddress,assetId) = ((("%s%s%s__total__" + poolAddress) + "__") + assetId)
39+
40+
41+func keyFactoryContract () = "%s__factoryContract"
42+
43+
44+func keySlippageAmtPerAssetCumulative (poolAddress,assetId) = (((("%s%s%s__" + poolAddress) + "__") + assetId) + "__slippageCumulative")
45+
46+
47+func keyFactoryConfig () = "%s__factoryConfig"
48+
49+
50+func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
51+
52+
53+func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
54+
55+
56+func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
57+
58+
59+func keyAllPoolsShutdown () = "%s__shutdown"
60+
61+
62+func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
63+
64+
65+func keyManagerPublicKey () = "%s__managerPublicKey"
66+
67+
68+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
69+
70+
71+let factoryContract = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactoryContract()), "No Factory Acc found."))
72+
73+func convertAssetId (assetId) = if (!(isDefined(assetId)))
74+    then "WAVES"
75+    else assetId
76+
77+
78+func dataPutActionInfo (inAssetId,inAssetAmt,txHeight,txTimestamp) = makeString(["%s%d%d%d", inAssetId, toString(inAssetAmt), toString(txHeight), toString(txTimestamp)], SEP)
79+
80+
81+func dataInvestActionInfo (outAmountAssetAmt,outPriceAssetAmt,txHeight,txTimestamp) = makeString(["%d%d%d%d", toString(outAmountAssetAmt), toString(outPriceAssetAmt), toString(txHeight), toString(txTimestamp)], SEP)
82+
83+
84+func asString (val) = match val {
85+    case valStr: String => 
86+        valStr
87+    case _ => 
88+        throw("fail to cast into String")
89+}
90+
91+
92+func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
93+
94+
95+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
96+    case s: String => 
97+        fromBase58String(s)
98+    case _: Unit => 
99+        unit
100+    case _ => 
101+        throw("Match error")
102+}
103+
104+
105+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
106+    case s: String => 
107+        fromBase58String(s)
108+    case _: Unit => 
109+        unit
110+    case _ => 
111+        throw("Match error")
112+}
113+
114+
115+func mustManager (i) = {
116+    let pd = throw("Permission denied")
117+    match managerPublicKeyOrUnit() {
118+        case pk: ByteVector => 
119+            if ((i.callerPublicKey == pk))
120+                then true
121+                else pd
122+        case _: Unit => 
123+            if ((i.caller == this))
124+                then true
125+                else pd
126+        case _ => 
127+            throw("Match error")
128+    }
129+    }
130+
131+
132+@Callable(i)
133+func constructor (factoryContract) = {
134+    let checkCaller = mustManager(i)
135+    if ((checkCaller == checkCaller))
136+        then [StringEntry(keyFactoryContract(), factoryContract)]
137+        else throw("Strict value is not equal to itself.")
138+    }
139+
140+
141+
142+@Callable(i)
143+func put () = {
144+    let pool = toString(i.caller)
145+    let pmtAmtAsset = value(i.payments[0])
146+    let pmtAssetId = if (!(isDefined(pmtAmtAsset.assetId)))
147+        then "WAVES"
148+        else toBase58String(value(pmtAmtAsset.assetId))
149+    let pmtAssetAmt = pmtAmtAsset.amount
150+    let poolAssets = split(valueOrErrorMessage(getString(factoryContract, keyMappingPoolContractAddressToPoolAssets(pool)), "Invalid caller"), SEP)
151+    let amountAssetId = parseIntValue(poolAssets[1])
152+    let priceAssetId = parseIntValue(poolAssets[2])
153+    let amountAsset = valueOrErrorMessage(getString(factoryContract, keyMappingsInternal2baseAssetId(amountAssetId)), "Cannot find asset")
154+    let priceAsset = valueOrErrorMessage(getString(factoryContract, keyMappingsInternal2baseAssetId(priceAssetId)), "Cannot find asset")
155+    let totalAmt = valueOrElse(getInteger(this, keyPoolTotalAmtByAsset(pool, pmtAssetId)), 0)
156+    let cumulativeSlippageAmt = valueOrElse(getInteger(this, keySlippageAmtPerAssetCumulative(pool, pmtAssetId)), 0)
157+[StringEntry(keyRegisterPut(pool, toBase58String(i.transactionId)), dataPutActionInfo(pmtAssetId, pmtAssetAmt, height, lastBlock.timestamp)), IntegerEntry(keyPoolTotalAmtByAsset(pool, pmtAssetId), (totalAmt + pmtAssetAmt)), IntegerEntry(keySlippageAmtPerAssetCumulative(pool, pmtAssetId), (cumulativeSlippageAmt + pmtAssetAmt))]
158+    }
159+
160+
161+
162+@Callable(i)
163+func invest (poolAddressStr) = {
164+    let poolAddress = valueOrErrorMessage(addressFromString(poolAddressStr), "invalid pool address")
165+    let poolAssets = split(valueOrErrorMessage(getString(factoryContract, keyMappingPoolContractAddressToPoolAssets(poolAddressStr)), "Invalid pool passed."), SEP)
166+    let amId = valueOrErrorMessage(getString(factoryContract, keyMappingsInternal2baseAssetId(parseIntValue(poolAssets[1]))), "No asset mapping found")
167+    let prId = valueOrErrorMessage(getString(factoryContract, keyMappingsInternal2baseAssetId(parseIntValue(poolAssets[2]))), "No asset mapping found")
168+    let amBalance = valueOrElse(getInteger(this, keyPoolTotalAmtByAsset(poolAddressStr, amId)), 0)
169+    let prBalance = valueOrElse(getInteger(this, keyPoolTotalAmtByAsset(poolAddressStr, prId)), 0)
170+    let estByPrResult = invoke(poolAddress, "evaluatePutByPriceAssetREADONLY", [prBalance], nil)
171+    let estByAmResult = invoke(poolAddress, "evaluatePutByAmountAssetREADONLY", [amBalance], nil)
172+    let IdxEstAmAmount = 7
173+    let IdxEstPrAmount = 8
174+    let estAmAmt = valueOrErrorMessage(parseIntValue(split(asString(estByPrResult), SEP)[IdxEstAmAmount]), "fail to parse estimated amAsset amount")
175+    let estPrAmt = valueOrErrorMessage(parseIntValue(split(asString(estByAmResult), SEP)[IdxEstPrAmount]), "fail to parse estimated prAsset amount")
176+    let $t067836884 = if ((amBalance >= estAmAmt))
177+        then $Tuple2(estAmAmt, prBalance)
178+        else $Tuple2(amBalance, estPrAmt)
179+    let amAmt = $t067836884._1
180+    let prAmt = $t067836884._2
181+    let amAssetId = if ((amId == "WAVES"))
182+        then unit
183+        else fromBase58String(amId)
184+    let prAssetId = if ((prId == "WAVES"))
185+        then unit
186+        else fromBase58String(prId)
187+    let lpPut = invoke(poolAddress, "putForFree", [1000], [AttachedPayment(amAssetId, amAmt), AttachedPayment(prAssetId, prAmt)])
188+    if ((lpPut == lpPut))
189+        then [StringEntry(keyRegisterInvest(poolAddressStr, toBase58String(i.transactionId)), dataInvestActionInfo(amAmt, prAmt, height, lastBlock.timestamp)), IntegerEntry(keyPoolTotalAmtByAsset(poolAddressStr, amId), (amBalance - amAmt)), IntegerEntry(keyPoolTotalAmtByAsset(poolAddressStr, prId), (prBalance - prAmt))]
190+        else throw("Strict value is not equal to itself.")
191+    }
192+
193+
194+
195+@Callable(i)
196+func setManager (pendingManagerPublicKey) = {
197+    let checkCaller = mustManager(i)
198+    if ((checkCaller == checkCaller))
199+        then {
200+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
201+            if ((checkManagerPublicKey == checkManagerPublicKey))
202+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
203+                else throw("Strict value is not equal to itself.")
204+            }
205+        else throw("Strict value is not equal to itself.")
206+    }
207+
208+
209+
210+@Callable(i)
211+func confirmManager () = {
212+    let pm = pendingManagerPublicKeyOrUnit()
213+    let hasPM = if (isDefined(pm))
214+        then true
215+        else throw("No pending manager")
216+    if ((hasPM == hasPM))
217+        then {
218+            let checkPM = if ((i.callerPublicKey == value(pm)))
219+                then true
220+                else throw("You are not pending manager")
221+            if ((checkPM == checkPM))
222+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
223+                else throw("Strict value is not equal to itself.")
224+            }
225+        else throw("Strict value is not equal to itself.")
226+    }
227+
228+
229+@Verifier(tx)
230+func verify () = {
231+    let targetPublicKey =     match managerPublicKeyOrUnit() {
232+        case pk: ByteVector => 
233+            pk
234+        case _: Unit => 
235+            tx.senderPublicKey
236+        case _ => 
237+            throw("Match error")
238+    }
239+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
240+    }
241+
github/deemru/w8io/169f3d6 
22.78 ms ◑