w8 · tx · yCF···WZg

tx · yCF76BJoP4mm32Qo72RAvd1v1b3Eg8iqe1WKcL4HWZg

3N4revPn12feiSAyC78tAZEJfsyprVYPzsL:  -0.05000000 Waves

2022.02.10 11:21 [1917282] smart account 3N4revPn12feiSAyC78tAZEJfsyprVYPzsL > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "yCF76BJoP4mm32Qo72RAvd1v1b3Eg8iqe1WKcL4HWZg",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1644481328165,
    "version": 2,
    "chainId": 84,
    "sender": "3N4revPn12feiSAyC78tAZEJfsyprVYPzsL",
    "senderPublicKey": "5smGxL7bfeRokaN53Z31Y72dF2Lkr5Cg1kuWRV3gniNe",
    "proofs": [
        "VkmHEK7hYtq3TSmBGxrhCUwdcztGHXXhzLMBMeJafWb6LDm6oYHbLzH5uSH1yCEANyaR6GAm9S9MUxxPyaGdDtZ"
    ],
    "script": "base64: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",
    "height": 1917282,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CRADEVKw3TwcL7KE6fXyQFgLCnRDAmuAX2s38vjFCNi2
Next: GvkGdywtQqPmjxF2o3ji34u5RT16ejy6bS72yRLYbL6q

Diff: 
Old New Differences
44 44  let alphaDigits = 2
45 45  
46 46  let beta = 46000000
47 + 
48 + let betaBigInt = 460000000000
47 49  
48 50  func skewness (x,y) = (((fraction(scale12, x, y) + fraction(scale12, y, x)) / 2) / 10000)
49 51  
118 120  @Callable(i)
119 121  func invariantCalccBigInt (x,y) = {
120 122      let sk = skewness(x, y)
121 -     let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - beta)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
123 +     let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - betaBigInt)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
122 124  [IntegerEntry("invariant", invariant)]
123 125      }
124 126  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 5 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let strAssetIdA = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
5 5  
6 6  let strAssetIdB = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
7 7  
8 8  let assetIdA = if ((strAssetIdA == "WAVES"))
9 9      then unit
10 10      else fromBase58String(strAssetIdA)
11 11  
12 12  let assetIdB = if ((strAssetIdB == "WAVES"))
13 13      then unit
14 14      else fromBase58String(strAssetIdB)
15 15  
16 16  let fee = 500
17 17  
18 18  let feeGovernance = 200
19 19  
20 20  let feeScale6 = 1000000
21 21  
22 22  let scale3 = 1000
23 23  
24 24  let scale8 = 100000000
25 25  
26 26  let scale12 = 1000000000000
27 27  
28 28  let slippageScale3 = 1000
29 29  
30 30  let digits8 = 8
31 31  
32 32  let digits12 = 12
33 33  
34 34  let dAppThreshold = 50
35 35  
36 36  let dAppThresholdScale2 = 100
37 37  
38 38  let exchangeRatioLimitMin = 90000000
39 39  
40 40  let exchangeRatioLimitMax = 110000000
41 41  
42 42  let alpha = 50
43 43  
44 44  let alphaDigits = 2
45 45  
46 46  let beta = 46000000
47 + 
48 + let betaBigInt = 460000000000
47 49  
48 50  func skewness (x,y) = (((fraction(scale12, x, y) + fraction(scale12, y, x)) / 2) / 10000)
49 51  
50 52  
51 53  func invariantCalc (x,y) = {
52 54      let sk = skewness(x, y)
53 55      let xy = (x + y)
54 56      let firstpow = pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)
55 57      let secondpow = pow(fraction(x, y, scale8), 0, 5, 1, (digits8 / 2), DOWN)
56 58      let thirdpow = pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN)
57 59      (fraction(xy, scale8, firstpow) + (2 * fraction(secondpow, thirdpow, scale8)))
58 60      }
59 61  
60 62  
61 63  func calculateSendAmount (balanceA,balanceB,amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId) = {
62 64      let slippageValue = (scale8 - ((scale8 * 1) / 10000000))
63 65      let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
64 66      let x = (balanceA + tokenReceiveAmount)
65 67      let y = (balanceB + tokenReceiveAmount)
66 68      let invariant = invariantCalc(balanceA, balanceB)
67 69      let invariantNew = if ((tokenId == strAssetIdA))
68 70          then invariantCalc(x, (balanceB - amountToSendEstimated))
69 71          else if ((tokenId == strAssetIdB))
70 72              then invariantCalc((balanceA - amountToSendEstimated), y)
71 73              else throw("Wrong asset in payment")
72 74      let invariantEstimatedRatio = fraction(scale8, invariant, invariantNew)
73 75      func getStepAmount (acc,step) =     if ((acc == -1))
74 76          then {
75 77              let amountToSend = (amountToSendEstimated - ((step * deltaBetweenMaxAndMinSendValue) / 5))
76 78              let stepInvariant = if ((tokenId == strAssetIdA))
77 79                  then invariantCalc(x, (balanceB - amountToSend))
78 80                  else invariantCalc((balanceA - amountToSend), y)
79 81              if ((stepInvariant > invariant))
80 82                  then amountToSend
81 83                  else -1
82 84              }
83 85          else acc
84 86  
85 87      let stepAmount = {
86 88          let $l = [1, 2, 3, 4, 5]
87 89          let $s = size($l)
88 90          let $acc0 = -1
89 91          func $f0_1 ($a,$i) =         if (($i >= $s))
90 92              then $a
91 93              else getStepAmount($a, $l[$i])
92 94  
93 95          func $f0_2 ($a,$i) =         if (($i >= $s))
94 96              then $a
95 97              else throw("List size exceeds 5")
96 98  
97 99          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
98 100          }
99 101      if ((0 > stepAmount))
100 102          then throw("something went wrong while working with amountToSend")
101 103          else if (if ((invariantEstimatedRatio > slippageValue))
102 104              then (invariantNew > invariant)
103 105              else false)
104 106              then amountToSendEstimated
105 107              else stepAmount
106 108      }
107 109  
108 110  
109 111  @Callable(i)
110 112  func invariantCalcc (x,y) = {
111 113      let sk = skewness(x, y)
112 114      let invariant = (fraction((x + y), scale8, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(pow(fraction(x, y, scale8), 0, 5, 1, (digits8 / 2), DOWN), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
113 115  [IntegerEntry("invariant", invariant)]
114 116      }
115 117  
116 118  
117 119  
118 120  @Callable(i)
119 121  func invariantCalccBigInt (x,y) = {
120 122      let sk = skewness(x, y)
121 -     let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - beta)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
123 +     let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - betaBigInt)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
122 124  [IntegerEntry("invariant", invariant)]
123 125      }
124 126  
125 127  
126 128  
127 129  @Callable(i)
128 130  func exchange (balanceA,balanceB,pmtAmount,pmtAssetId,estimatedAmountToReceive,minAmountToReceive) = {
129 131      let amount = calculateSendAmount(balanceA, balanceB, estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId)
130 132      let governanceReward = fraction(amount, feeGovernance, feeScale6)
131 133      let amountMinusFee = fraction(amount, (feeScale6 - fee), feeScale6)
132 134  [IntegerEntry("sendAmount", amount), IntegerEntry("sendAmountWithComission", amountMinusFee)]
133 135      }
134 136  
135 137  
136 138  @Verifier(tx)
137 139  func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
138 140

Old	New		Differences
44	44		let alphaDigits = 2
45	45
46	46		let beta = 46000000
	47	+
	48	+	let betaBigInt = 460000000000
47	49
48	50		func skewness (x,y) = (((fraction(scale12, x, y) + fraction(scale12, y, x)) / 2) / 10000)
49	51

118	120		@Callable(i)
119	121		func invariantCalccBigInt (x,y) = {
120	122		let sk = skewness(x, y)
121		-	let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - ~~beta~~)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
	123	+	let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - betaBigInt)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
122	124		[IntegerEntry("invariant", invariant)]
123	125		}
124	126

Old	New		Differences
1	1		{-# STDLIB_VERSION 5 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let strAssetIdA = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
5	5
6	6		let strAssetIdB = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
7	7
8	8		let assetIdA = if ((strAssetIdA == "WAVES"))
9	9		then unit
10	10		else fromBase58String(strAssetIdA)
11	11
12	12		let assetIdB = if ((strAssetIdB == "WAVES"))
13	13		then unit
14	14		else fromBase58String(strAssetIdB)
15	15
16	16		let fee = 500
17	17
18	18		let feeGovernance = 200
19	19
20	20		let feeScale6 = 1000000
21	21
22	22		let scale3 = 1000
23	23
24	24		let scale8 = 100000000
25	25
26	26		let scale12 = 1000000000000
27	27
28	28		let slippageScale3 = 1000
29	29
30	30		let digits8 = 8
31	31
32	32		let digits12 = 12
33	33
34	34		let dAppThreshold = 50
35	35
36	36		let dAppThresholdScale2 = 100
37	37
38	38		let exchangeRatioLimitMin = 90000000
39	39
40	40		let exchangeRatioLimitMax = 110000000
41	41
42	42		let alpha = 50
43	43
44	44		let alphaDigits = 2
45	45
46	46		let beta = 46000000
	47	+
	48	+	let betaBigInt = 460000000000
47	49
48	50		func skewness (x,y) = (((fraction(scale12, x, y) + fraction(scale12, y, x)) / 2) / 10000)
49	51
50	52
51	53		func invariantCalc (x,y) = {
52	54		let sk = skewness(x, y)
53	55		let xy = (x + y)
54	56		let firstpow = pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)
55	57		let secondpow = pow(fraction(x, y, scale8), 0, 5, 1, (digits8 / 2), DOWN)
56	58		let thirdpow = pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN)
57	59		(fraction(xy, scale8, firstpow) + (2 * fraction(secondpow, thirdpow, scale8)))
58	60		}
59	61
60	62
61	63		func calculateSendAmount (balanceA,balanceB,amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId) = {
62	64		let slippageValue = (scale8 - ((scale8 * 1) / 10000000))
63	65		let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
64	66		let x = (balanceA + tokenReceiveAmount)
65	67		let y = (balanceB + tokenReceiveAmount)
66	68		let invariant = invariantCalc(balanceA, balanceB)
67	69		let invariantNew = if ((tokenId == strAssetIdA))
68	70		then invariantCalc(x, (balanceB - amountToSendEstimated))
69	71		else if ((tokenId == strAssetIdB))
70	72		then invariantCalc((balanceA - amountToSendEstimated), y)
71	73		else throw("Wrong asset in payment")
72	74		let invariantEstimatedRatio = fraction(scale8, invariant, invariantNew)
73	75		func getStepAmount (acc,step) = if ((acc == -1))
74	76		then {
75	77		let amountToSend = (amountToSendEstimated - ((step * deltaBetweenMaxAndMinSendValue) / 5))
76	78		let stepInvariant = if ((tokenId == strAssetIdA))
77	79		then invariantCalc(x, (balanceB - amountToSend))
78	80		else invariantCalc((balanceA - amountToSend), y)
79	81		if ((stepInvariant > invariant))
80	82		then amountToSend
81	83		else -1
82	84		}
83	85		else acc
84	86
85	87		let stepAmount = {
86	88		let $l = [1, 2, 3, 4, 5]
87	89		let $s = size($l)
88	90		let $acc0 = -1
89	91		func $f0_1 ($a,$i) = if (($i >= $s))
90	92		then $a
91	93		else getStepAmount($a, $l[$i])
92	94
93	95		func $f0_2 ($a,$i) = if (($i >= $s))
94	96		then $a
95	97		else throw("List size exceeds 5")
96	98
97	99		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
98	100		}
99	101		if ((0 > stepAmount))
100	102		then throw("something went wrong while working with amountToSend")
101	103		else if (if ((invariantEstimatedRatio > slippageValue))
102	104		then (invariantNew > invariant)
103	105		else false)
104	106		then amountToSendEstimated
105	107		else stepAmount
106	108		}
107	109
108	110
109	111		@Callable(i)
110	112		func invariantCalcc (x,y) = {
111	113		let sk = skewness(x, y)
112	114		let invariant = (fraction((x + y), scale8, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(pow(fraction(x, y, scale8), 0, 5, 1, (digits8 / 2), DOWN), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
113	115		[IntegerEntry("invariant", invariant)]
114	116		}
115	117
116	118
117	119
118	120		@Callable(i)
119	121		func invariantCalccBigInt (x,y) = {
120	122		let sk = skewness(x, y)
121		-	let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - ~~beta~~)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
	123	+	let invariant = (toInt(fraction(toBigInt((x + y)), toBigInt(scale12), pow(toBigInt(sk), digits12, toBigInt(alpha), alphaDigits, digits12, CEILING))) + (2 * toInt(fraction(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN), pow(toBigInt((sk - betaBigInt)), digits12, toBigInt(alpha), alphaDigits, digits12, DOWN), toBigInt(scale12)))))
122	124		[IntegerEntry("invariant", invariant)]
123	125		}
124	126
125	127
126	128
127	129		@Callable(i)
128	130		func exchange (balanceA,balanceB,pmtAmount,pmtAssetId,estimatedAmountToReceive,minAmountToReceive) = {
129	131		let amount = calculateSendAmount(balanceA, balanceB, estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId)
130	132		let governanceReward = fraction(amount, feeGovernance, feeScale6)
131	133		let amountMinusFee = fraction(amount, (feeScale6 - fee), feeScale6)
132	134		[IntegerEntry("sendAmount", amount), IntegerEntry("sendAmountWithComission", amountMinusFee)]
133	135		}
134	136
135	137
136	138		@Verifier(tx)
137	139		func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
138	140

github/deemru/w8io/169f3d6 
32.26 ms ◑