tx · 2pLgVHNrZDhAhy5kCdGGoGxnHdefFfNSHC1WDTidvFcY

3MsQ1V8D72MYH7oj111mWP6t7D5w2CPh89f:  -0.01500000 Waves

2021.05.30 15:46 [1548432] smart account 3MsQ1V8D72MYH7oj111mWP6t7D5w2CPh89f > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2pLgVHNrZDhAhy5kCdGGoGxnHdefFfNSHC1WDTidvFcY",
    "fee": 1500000,
    "feeAssetId": null,
    "timestamp": 1622378822073,
    "version": 2,
    "chainId": 84,
    "sender": "3MsQ1V8D72MYH7oj111mWP6t7D5w2CPh89f",
    "senderPublicKey": "HQzyH2v9BLg11nuKp8jggmDPN12pKJiC5V5Rp3n2AhPQ",
    "proofs": [
        "KH9fcQQBFrXmpXpdPE9tATk6qRVMxS3YYSdUVv6twbe38eB7qGQQq2KfVDuJg5xav95uAWnyzojCULLjPkVqjeW"
    ],
    "script": "base64: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",
    "height": 1548432,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let gameMasterPublicKey = base58'ALG9JVGNn9aCL68dbg1AmW6yDQv1b8EDLq99pQS8L1k6'
5+
6+let diceNumber = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
7+
8+let gameToken = base58'Co7gTLr7ZJvVKwToLpuZJqmkVecy5uwupYH6qCkKuhc8'
9+
10+let RSAPUBLIC = fromBase64String("base64:MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjnt2PdN1Pdj7rsXzbapgucn9e1XffUx1o7grAlw8C6NFuv1PPj7KnQ6RtN9xhniLF4xKlc7//TYXd1uHWmx9vu9hjciYX9UMRJnhlZO2q34mxPdcgLDKhJHDN726KI0wHpFQ5dHMyzoMLdWsahFc1Wx/XxroK2Kc1y2JBWN2akRlkxSDcluqbbUcWMyrwG6iWuVlhej5xfcuerg/psK35WGn7SLF29tWuR2x+24nM+BJUsuRG7yBZUhGrYzJk2gvpucRLea6AFRvow7RdyMYAwKFrr6mgQ0VcUw2T750e1oGanY0UdU3NPsKIgvU4Ft4uibMlMMBJvcrsEbDQHfDlwIDAQAB")
11+
12+let GAMESTART = 0
13+
14+let GAMEINPROGRESS = 1
15+
16+let GAMEFINISHED = 2
17+
18+let BLOCKTOPROCESSFORTHROW = 1
19+
20+let PASSLINEBET = "PASSLINEBET"
21+
22+let DONTPASSLINEBET = "DONTPASSLINEBET"
23+
24+let COMEBET = "COMEBET"
25+
26+let DONTCOMEBET = "DONTCOMEBET"
27+
28+let FIELDBET = "FIELDBET"
29+
30+let ODDSBET = "ODDSBET"
31+
32+let BIG6OR8BET = "BIG6OR8BET"
33+
34+let PLACEBETBUY = "PLACEBETBUY"
35+
36+let PLACEBETLOSE = "PLACEBETLOSE"
37+
38+let PLACEBETLAY = "PLACEBETLAY"
39+
40+let PLACEBETWIN = "PLACEBETWIN"
41+
42+let gameCounterLabel = "G_GAMECOUNTER"
43+
44+let gameTotalBetsLabel = "G_TOTALBETS"
45+
46+let gameTotalProccedBetsLabel = "G_PROCESSEDBETS"
47+
48+let gameTotalFieldBetsLabel = "G_TOTALFIELD_ODDS_BETS"
49+
50+let gameTotalProccedFieldOrOddsBetsLabel = "G_PROCESSEDFIEL_ODDS_BETS"
51+
52+func gameStartHeightLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_STARTHEIGHT")
53+
54+
55+func gameEndHeightLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_ENDHEIGHT")
56+
57+
58+func getStartHeight (gameCounter) = getInteger(this, gameStartHeightLabel(gameCounter))
59+
60+
61+func getEndHeight (gameCounter) = getInteger(this, gameEndHeightLabel(gameCounter))
62+
63+
64+func gameBetLineLabel (betNumber) = (("B_" + toString(betNumber)) + "_BETDETAILS")
65+
66+
67+func gameFieldOrOddsBetLineLabel (betNumber) = (("B_" + toString(betNumber)) + "_BETFIELODDSDDETAILS")
68+
69+
70+func getBetDetailsResult (betNumber) = getString(this, gameBetLineLabel(betNumber))
71+
72+
73+func getFieldBetDetailsResult (betNumber) = getString(this, gameFieldOrOddsBetLineLabel(betNumber))
74+
75+
76+func authorizePermission (callerPublicKey) = (callerPublicKey != gameMasterPublicKey)
77+
78+
79+func gameCurrentPointDiceLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_LASTPOINT")
80+
81+
82+func gameFirstPointDiceLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_FIRSTPOINT")
83+
84+
85+func gameWinningNumberBetLabel (gameCounter,betNumber,betType) = ((((((("W_" + "BET_TYPE_") + betType) + "_") + toString(betNumber)) + "_WINNING_BET_") + toString(gameCounter)) + "_GAME_NUMBER")
86+
87+
88+func gameStateLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_STATE")
89+
90+
91+func gameSumShaLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_SUMSHA")
92+
93+
94+func gameRandomHashLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_RANDOMHASH")
95+
96+
97+func getGameTotalBets () = getInteger(this, gameTotalBetsLabel)
98+
99+
100+func getGameProcessedBets () = getInteger(this, gameTotalProccedBetsLabel)
101+
102+
103+func getGameTotalFieldOrOddsBets () = getInteger(this, gameTotalFieldBetsLabel)
104+
105+
106+func getGameProcessedFieldOrOddsBets () = getInteger(this, gameTotalProccedFieldOrOddsBetsLabel)
107+
108+
109+func getGameState (gameCounter) = getInteger(this, gameStateLabel(gameCounter))
110+
111+
112+func getGameSumSha (gameCounter) = getString(this, gameSumShaLabel(gameCounter))
113+
114+
115+func getRandomHash (gameCounter) = getString(this, gameRandomHashLabel(gameCounter))
116+
117+
118+func gameRollsCountBetLabel (gameCounter) = (("G_" + toString(gameCounter)) + "_ROLLSCOUNT")
119+
120+
121+func gameRollDiceWithGameNumberLabel (gameCounter,rollDice) = (((("G_" + toString(gameCounter)) + "_") + toString(rollDice)) + "_GAMENUMBER_ROLLDICE")
122+
123+
124+func gameFieldOrOddsBetForNextThrowLabel (betNumber) = (("B_" + toString(betNumber)) + "_FIELD_ODDS_BET_ROLLDICE")
125+
126+
127+func getGameRollsCount (gameCounter) = getInteger(this, gameRollsCountBetLabel(gameCounter))
128+
129+
130+func getGameRollDiceWithGameNumber (gameCounter,rollDice) = getInteger(this, gameRollDiceWithGameNumberLabel(gameCounter, rollDice))
131+
132+
133+func getFieldOddsBetForNextDice (betNumber) = getInteger(this, gameFieldOrOddsBetForNextThrowLabel(betNumber))
134+
135+
136+func gameBetCounterLabel (gameNumber) = (("B_" + toString(gameNumber)) + "_BET_GAMENUMBER")
137+
138+
139+func gameFieldOrOddsBetGameCounterLabel (gameNumber) = (("B_" + toString(gameNumber)) + "_FIELD_ODDS_BET_GAMENUMBER")
140+
141+
142+func getGameBetCounter (gameNumber) = getInteger(this, gameBetCounterLabel(gameNumber))
143+
144+
145+func getGameFieldOrOddsBetCounter (gameNumber) = getInteger(this, gameFieldOrOddsBetGameCounterLabel(gameNumber))
146+
147+
148+func getGameCounter () = getInteger(this, gameCounterLabel)
149+
150+
151+func getFirstPointDice (gameCounter) = getInteger(this, gameFirstPointDiceLabel(gameCounter))
152+
153+
154+func getCurrentPointDice (gameCounter) = match getInteger(this, gameCurrentPointDiceLabel(gameCounter)) {
155+    case val: Int => 
156+        val
157+    case _ => 
158+        0
159+}
160+
161+
162+func validateBetName (betName) = if ((betName == PASSLINEBET))
163+    then true
164+    else if ((betName == DONTPASSLINEBET))
165+        then true
166+        else false
167+
168+
169+func validateRoundBet (betName) = if ((betName == FIELDBET))
170+    then true
171+    else if ((betName == ODDSBET))
172+        then true
173+        else if ((betName == BIG6OR8BET))
174+            then true
175+            else if ((betName == PLACEBETBUY))
176+                then true
177+                else if ((betName == PLACEBETLAY))
178+                    then true
179+                    else if ((betName == COMEBET))
180+                        then true
181+                        else if ((betName == DONTCOMEBET))
182+                            then true
183+                            else if ((betName == PLACEBETLOSE))
184+                                then true
185+                                else if ((betName == PLACEBETWIN))
186+                                    then true
187+                                    else false
188+
189+
190+func getWinningAmountForOdds (amount,odd,resultOfRound) = if (if ((odd == 4))
191+    then true
192+    else (odd == 10))
193+    then {
194+        let winningAmount = (amount * 7)
195+        winningAmount
196+        }
197+    else if (if ((odd == 5))
198+        then true
199+        else (odd == 8))
200+        then {
201+            let winningAmount = (amount * 9)
202+            winningAmount
203+            }
204+        else if (if ((odd == 3))
205+            then true
206+            else (odd == 11))
207+            then {
208+                let winningAmount = (amount * 15)
209+                winningAmount
210+                }
211+            else if (if ((odd == 2))
212+                then true
213+                else (odd == 12))
214+                then {
215+                    let winningAmount = (amount * 30)
216+                    winningAmount
217+                    }
218+                else if (if ((odd == 10))
219+                    then true
220+                    else (odd == 4))
221+                    then {
222+                        let winningAmount = (amount * 30)
223+                        winningAmount
224+                        }
225+                    else if ((odd == 7))
226+                        then {
227+                            let winningAmount = (amount * 4)
228+                            winningAmount
229+                            }
230+                        else if (if ((odd == 100))
231+                            then if (if ((resultOfRound == 3))
232+                                then true
233+                                else (resultOfRound == 12))
234+                                then true
235+                                else (resultOfRound == 2)
236+                            else false)
237+                            then {
238+                                let winningAmount = (amount * 7)
239+                                winningAmount
240+                                }
241+                            else 0
242+
243+
244+func getWinningAmountForField (amount,resultOfRound) = if ((resultOfRound == 12))
245+    then {
246+        let winningAmount = (amount * 4)
247+        winningAmount
248+        }
249+    else if ((resultOfRound == 2))
250+        then {
251+            let winningAmount = (amount * 3)
252+            winningAmount
253+            }
254+        else if (if (if (if ((resultOfRound == 5))
255+            then true
256+            else (resultOfRound == 6))
257+            then true
258+            else (resultOfRound == 7))
259+            then true
260+            else (resultOfRound == 8))
261+            then 0
262+            else {
263+                let winningAmount = (amount * 2)
264+                winningAmount
265+                }
266+
267+
268+func storeOneRoundBetTypes (gameCounter,amount,typeBet,caller,odd) = match getGameTotalFieldOrOddsBets() {
269+    case betCount: Int => 
270+        match getGameRollsCount(gameCounter) {
271+            case rollCount: Int => 
272+                let newTotalBetCount = (betCount + 1)
273+                let newRollCountForGame = (rollCount + 1)
274+                if (if ((typeBet == COMEBET))
275+                    then true
276+                    else (typeBet == DONTCOMEBET))
277+                    then [IntegerEntry(gameFieldOrOddsBetGameCounterLabel(newTotalBetCount), gameCounter), StringEntry(gameFieldOrOddsBetLineLabel(newTotalBetCount), ((((((((caller + "_") + amount) + "_") + typeBet) + "_active_pending_") + toString(gameCounter)) + "_") + toString(newRollCountForGame))), IntegerEntry(gameTotalFieldBetsLabel, newTotalBetCount), IntegerEntry(gameFieldOrOddsBetForNextThrowLabel(newTotalBetCount), newRollCountForGame)]
278+                    else [IntegerEntry(gameFieldOrOddsBetGameCounterLabel(newTotalBetCount), gameCounter), StringEntry(gameFieldOrOddsBetLineLabel(newTotalBetCount), ((((((caller + "_") + amount) + "_") + typeBet) + "_active_pending_") + toString(odd))), IntegerEntry(gameTotalFieldBetsLabel, newTotalBetCount), IntegerEntry(gameFieldOrOddsBetForNextThrowLabel(newTotalBetCount), newRollCountForGame)]
279+            case _ => 
280+                throw("Game doesn't exist")
281+        }
282+    case _ => 
283+        throw("Game has not bee initialized")
284+}
285+
286+
287+func rollPlaceBetIntoAnotherRoundBet (totalBets,lastFieldProcessBet,betOnRoll,gameCounter,amount,typeBet,caller,odd) = [IntegerEntry(gameFieldOrOddsBetGameCounterLabel(totalBets), gameCounter), StringEntry(gameFieldOrOddsBetLineLabel(totalBets), ((((((caller + "_") + amount) + "_") + typeBet) + "_active_pending_") + toString(odd))), StringEntry(gameFieldOrOddsBetLineLabel(lastFieldProcessBet), ((((((caller + "_") + amount) + "_") + typeBet) + "_inactive_rolled_") + toString(odd))), IntegerEntry(gameTotalProccedFieldOrOddsBetsLabel, lastFieldProcessBet), IntegerEntry(gameTotalFieldBetsLabel, totalBets), IntegerEntry(gameFieldOrOddsBetForNextThrowLabel(totalBets), betOnRoll)]
288+
289+
290+func storeNextRoll (gameState,amount,totalFieldBets,lastFieldProcessBet,betOnRoll,gameNumber,betType,betPlacer,odd) = if ((gameState == GAMEFINISHED))
291+    then rollPlaceBetIntoAnotherRoundBet((totalFieldBets + 1), (lastFieldProcessBet + 1), 1, (gameNumber + 1), toString(amount), betType, betPlacer, odd)
292+    else rollPlaceBetIntoAnotherRoundBet((totalFieldBets + 1), (lastFieldProcessBet + 1), (betOnRoll + 1), gameNumber, toString(amount), betType, betPlacer, odd)
293+
294+
295+func storeComeDontComeBet (gameState,betDetails,resultOfRound,amount,totalFieldBets,lastFieldProcessBet,betOnRoll,gameNumber,betType,betPlacer,odd) = {
296+    let comeBetGameNumber = value(parseInt(split(betDetails, "_")[5]))
297+    let comeBetRollNumber = value(parseInt(split(betDetails, "_")[6]))
298+    let resultOfGame = value(getGameRollDiceWithGameNumber(comeBetGameNumber, comeBetRollNumber))
299+    if ((resultOfRound == 7))
300+        then if ((betDetails == COMEBET))
301+            then throw("Only Field Type of Bet can be proceed")
302+            else throw("Only Field Type of Bet can be proceed")
303+        else if ((resultOfRound == resultOfGame))
304+            then throw("Only Field Type of Bet can be proceed")
305+            else if ((gameState == GAMEFINISHED))
306+                then storeNextRoll(gameState, amount, (totalFieldBets + 1), (lastFieldProcessBet + 1), 1, (gameNumber + 1), betType, betPlacer, odd)
307+                else storeNextRoll(gameState, amount, (totalFieldBets + 1), (lastFieldProcessBet + 1), (betOnRoll + 1), gameNumber, betType, betPlacer, odd)
308+    }
309+
310+
311+func storePassOrComeBet (gameCounter,amount,typeBet,caller) = match getGameTotalBets() {
312+    case number: Int => 
313+        let newTotalBets = (number + 1)
314+[IntegerEntry(gameBetCounterLabel(newTotalBets), gameCounter), StringEntry(gameBetLineLabel(newTotalBets), (((((caller + "_") + amount) + "_") + typeBet) + "_active_pending")), IntegerEntry(gameTotalBetsLabel, newTotalBets)]
315+    case _ => 
316+        throw("Game has not bee initialized")
317+}
318+
319+
320+func udpateBetDetailsWithLost (updateBetDetials,gameNumber,lastProceedBet,betIndex,betProceedIndex) = {
321+    let updateInfoBet = (updateBetDetials + "_lost")
322+[StringEntry(betIndex, updateInfoBet), IntegerEntry(betProceedIndex, lastProceedBet)]
323+    }
324+
325+
326+func udpateBetDetailsWithLostWithOdd (updateBetDetials,gameNumber,lastProceedBet,betIndex,betProceedIndex,oddNumber) = {
327+    let updateInfoBet = ((updateBetDetials + "_lost_") + toString(oddNumber))
328+[StringEntry(betIndex, updateInfoBet), IntegerEntry(betProceedIndex, lastProceedBet)]
329+    }
330+
331+
332+func updateBetDetailsWithWinning (updateBetDetials,gameNumber,currentProceedBet,betPlacer,winningAmount,betType,betIndex,betProceedIndex) = {
333+    let updateInfoBet = (updateBetDetials + "_won_")
334+[StringEntry(gameWinningNumberBetLabel(gameNumber, currentProceedBet, betType), ((betPlacer + "_amount_") + toString(winningAmount))), StringEntry(betIndex, updateBetDetials), IntegerEntry(betProceedIndex, currentProceedBet), ScriptTransfer(value(addressFromString(betPlacer)), winningAmount, unit)]
335+    }
336+
337+
338+func storeGameProgressPointState (storeIndex,gameNumber,number,rollCount,currentHeight,randomHash,state) = [IntegerEntry(gameStateLabel(gameNumber), state), IntegerEntry(storeIndex, number), IntegerEntry(gameRollsCountBetLabel(gameNumber), rollCount), IntegerEntry(gameEndHeightLabel(gameNumber), (currentHeight + BLOCKTOPROCESSFORTHROW)), StringEntry(gameRandomHashLabel(gameNumber), toBase64String(randomHash)), IntegerEntry(gameRollDiceWithGameNumberLabel(gameNumber, rollCount), number)]
339+
340+
341+@Callable(i)
342+func processNextBet () = if (authorizePermission(i.callerPublicKey))
343+    then throw("processFieldBet_FORBIDDEN")
344+    else     match getGameTotalBets() {
345+        case totalBets: Int => 
346+            match getGameProcessedBets() {
347+                case lastProcessBet: Int => 
348+                    let nextBet = (lastProcessBet + 1)
349+                    if ((nextBet > totalBets))
350+                        then throw("Next bet has not been places.")
351+                        else                         match getGameBetCounter(nextBet) {
352+                            case gameNumber: Int => 
353+                                match getGameState(gameNumber) {
354+                                    case gameState: Int => 
355+                                        if (if ((gameState == GAMESTART))
356+                                            then true
357+                                            else (gameState == GAMEINPROGRESS))
358+                                            then throw("Game has to finished in order to process NON-FIELD bets")
359+                                            else {
360+                                                let betDetails = value(getBetDetailsResult(nextBet))
361+                                                let betType = split(betDetails, "_")[2]
362+                                                let betPlacer = split(betDetails, "_")[0]
363+                                                let amount = value(parseInt(split(betDetails, "_")[1]))
364+                                                let address = value(addressFromString(betPlacer))
365+                                                let currentPoint = getCurrentPointDice(nextBet)
366+                                                let firstPoint = getFirstPointDice(nextBet)
367+                                                let updateBetDetials = (((((betPlacer + "_") + split(betDetails, "_")[1]) + "_") + split(betDetails, "_")[2]) + "_inactive_")
368+                                                if ((betType == PASSLINEBET))
369+                                                    then if ((currentPoint == 0))
370+                                                        then if (if ((firstPoint == 7))
371+                                                            then true
372+                                                            else (firstPoint == 11))
373+                                                            then {
374+                                                                let winningAmount = (amount * 2)
375+                                                                updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
376+                                                                }
377+                                                            else udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
378+                                                        else if ((firstPoint == currentPoint))
379+                                                            then {
380+                                                                let winningAmount = (amount * 2)
381+                                                                updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
382+                                                                }
383+                                                            else if ((currentPoint == 7))
384+                                                                then udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
385+                                                                else udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
386+                                                    else if ((betType == DONTPASSLINEBET))
387+                                                        then if ((currentPoint == 0))
388+                                                            then if (if ((firstPoint == 2))
389+                                                                then true
390+                                                                else (firstPoint == 3))
391+                                                                then {
392+                                                                    let winningAmount = (amount * 2)
393+                                                                    updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
394+                                                                    }
395+                                                                else if (if ((currentPoint == 7))
396+                                                                    then true
397+                                                                    else (currentPoint == 11))
398+                                                                    then udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
399+                                                                    else udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
400+                                                            else if (if ((currentPoint == 2))
401+                                                                then true
402+                                                                else (currentPoint == 3))
403+                                                                then {
404+                                                                    let winningAmount = (amount * 2)
405+                                                                    updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
406+                                                                    }
407+                                                                else if ((currentPoint == 7))
408+                                                                    then udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
409+                                                                    else udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameBetLineLabel(nextBet), gameTotalProccedBetsLabel)
410+                                                        else throw((((((("Only " + PASSLINEBET) + ", ") + DONTPASSLINEBET) + " allowed in processNextBet()") + " currentBetType ") + betType))
411+                                                }
412+                                    case _ => 
413+                                        throw("Game does not exist or has already ended.")
414+                                }
415+                            case _ => 
416+                                throw("Error")
417+                        }
418+                case _ => 
419+                    throw("Game has not been initialized, next bets not found")
420+            }
421+        case _ => 
422+            throw("Game has not been initialized, next bets not found")
423+    }
424+
425+
426+
427+@Callable(i)
428+func processOneRoundBet () = if (authorizePermission(i.callerPublicKey))
429+    then throw("processFieldBet_FORBIDDEN")
430+    else     match getGameTotalFieldOrOddsBets() {
431+        case totalFieldBets: Int => 
432+            match getGameProcessedFieldOrOddsBets() {
433+                case lastFieldProcessBet: Int => 
434+                    let nextBet = (lastFieldProcessBet + 1)
435+                    if ((nextBet > totalFieldBets))
436+                        then throw("Next Field Bet has not been places.")
437+                        else                         match getGameFieldOrOddsBetCounter(nextBet) {
438+                            case gameNumber: Int => 
439+                                match getGameState(gameNumber) {
440+                                    case gameState: Int => 
441+                                        if ((gameState == GAMESTART))
442+                                            then throw("Game has not started yet")
443+                                            else {
444+                                                let betDetails = value(getFieldBetDetailsResult(nextBet))
445+                                                let betType = split(betDetails, "_")[2]
446+                                                let betPlacer = split(betDetails, "_")[0]
447+                                                let amount = value(parseInt(split(betDetails, "_")[1]))
448+                                                let odd = value(parseInt(split(betDetails, "_")[5]))
449+                                                let address = value(addressFromString(betPlacer))
450+                                                let betOnRoll = value(getFieldOddsBetForNextDice(nextBet))
451+                                                match getGameRollDiceWithGameNumber(gameNumber, betOnRoll) {
452+                                                    case resultOfRound: Int => 
453+                                                        let updateBetDetials = (((((betPlacer + "_") + split(betDetails, "_")[1]) + "_") + split(betDetails, "_")[2]) + "_inactive_")
454+                                                        if ((betType == FIELDBET))
455+                                                            then {
456+                                                                let winningAmount = getWinningAmountForField(amount, resultOfRound)
457+                                                                if ((winningAmount == 0))
458+                                                                    then udpateBetDetailsWithLost(updateBetDetials, gameNumber, nextBet, gameFieldOrOddsBetLineLabel(gameNumber), gameTotalProccedFieldOrOddsBetsLabel)
459+                                                                    else updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel)
460+                                                                }
461+                                                            else if ((betType == ODDSBET))
462+                                                                then {
463+                                                                    let winningAmount = getWinningAmountForOdds(amount, odd, resultOfRound)
464+                                                                    if ((winningAmount == 0))
465+                                                                        then updateBetDetailsWithWinning((updateBetDetials + "_won_"), gameNumber, nextBet, betPlacer, winningAmount, betType, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel)
466+                                                                        else udpateBetDetailsWithLostWithOdd(updateBetDetials, gameNumber, nextBet, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel, odd)
467+                                                                    }
468+                                                                else if ((betType == BIG6OR8BET))
469+                                                                    then if (if ((resultOfRound == 6))
470+                                                                        then true
471+                                                                        else (resultOfRound == 8))
472+                                                                        then {
473+                                                                            let winningAmount = (2 * amount)
474+                                                                            updateBetDetailsWithWinning((updateBetDetials + "_won_"), gameNumber, nextBet, betPlacer, winningAmount, betType, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel)
475+                                                                            }
476+                                                                        else udpateBetDetailsWithLostWithOdd(updateBetDetials, gameNumber, nextBet, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel, odd)
477+                                                                    else if (if ((betType == PLACEBETBUY))
478+                                                                        then true
479+                                                                        else (betType == PLACEBETWIN))
480+                                                                        then if ((resultOfRound == 7))
481+                                                                            then udpateBetDetailsWithLostWithOdd(updateBetDetials, gameNumber, nextBet, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel, odd)
482+                                                                            else if ((resultOfRound == odd))
483+                                                                                then {
484+                                                                                    let winningAmount = (amount * 2)
485+                                                                                    updateBetDetailsWithWinning((updateBetDetials + "_won_"), gameNumber, nextBet, betPlacer, winningAmount, betType, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel)
486+                                                                                    }
487+                                                                                else storeNextRoll(gameState, amount, (totalFieldBets + 1), (lastFieldProcessBet + 1), 1, (gameNumber + 1), betType, betPlacer, odd)
488+                                                                        else if (if ((betType == PLACEBETLAY))
489+                                                                            then true
490+                                                                            else (betType == PLACEBETLOSE))
491+                                                                            then if ((resultOfRound == 7))
492+                                                                                then {
493+                                                                                    let winningAmount = (amount * 2)
494+                                                                                    updateBetDetailsWithWinning(updateBetDetials, gameNumber, nextBet, betPlacer, winningAmount, betType, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel)
495+                                                                                    }
496+                                                                                else if ((resultOfRound == odd))
497+                                                                                    then udpateBetDetailsWithLostWithOdd(updateBetDetials, gameNumber, nextBet, gameFieldOrOddsBetLineLabel(nextBet), gameTotalProccedFieldOrOddsBetsLabel, odd)
498+                                                                                    else storeNextRoll(gameState, amount, (totalFieldBets + 1), (lastFieldProcessBet + 1), 1, (gameNumber + 1), betType, betPlacer, odd)
499+                                                                            else if (if ((betType == COMEBET))
500+                                                                                then true
501+                                                                                else (betType == DONTCOMEBET))
502+                                                                                then storeComeDontComeBet(gameState, betDetails, resultOfRound, amount, totalFieldBets, lastFieldProcessBet, betOnRoll, gameNumber, betType, betPlacer, odd)
503+                                                                                else throw("Only Field Type of Bet can be proceed")
504+                                                    case _ => 
505+                                                        throw("There is no result for this round yet")
506+                                                }
507+                                                }
508+                                    case _ => 
509+                                        throw("Game does not exist or has already ended")
510+                                }
511+                            case _ => 
512+                                throw("Error")
513+                        }
514+                case _ => 
515+                    throw("Game has not been initialized, next bets not found")
516+            }
517+        case _ => 
518+            throw("Game has not been initialized, next bets not found")
519+    }
520+
521+
522+
523+@Callable(i)
524+func initGame () = if (authorizePermission(i.callerPublicKey))
525+    then throw("initGame_FORBIDDEN")
526+    else     match getGameCounter() {
527+        case counter: Int => 
528+            throw("INIT_ALREADY_DONE")
529+        case _ => 
530+[IntegerEntry(gameCounterLabel, 0), IntegerEntry(gameTotalBetsLabel, 0), IntegerEntry(gameTotalProccedBetsLabel, 0), IntegerEntry(gameTotalFieldBetsLabel, 0), IntegerEntry(gameTotalProccedFieldOrOddsBetsLabel, 0)]
531+    }
532+
533+
534+
535+@Callable(i)
536+func startGame (randomHash) = if (authorizePermission(i.callerPublicKey))
537+    then throw("startGame_FORBIDDEN")
538+    else     match getGameCounter() {
539+        case number: Int => 
540+            if ((number == 0))
541+                then {
542+                    let newNumber = (number + 1)
543+[IntegerEntry(gameCounterLabel, newNumber), IntegerEntry(gameStateLabel(newNumber), GAMESTART), IntegerEntry(gameStartHeightLabel(newNumber), lastBlock.height), IntegerEntry(gameEndHeightLabel(newNumber), (lastBlock.height + BLOCKTOPROCESSFORTHROW)), IntegerEntry(gameRollsCountBetLabel(newNumber), 0), StringEntry(gameSumShaLabel(newNumber), toBase58String(sha256(fromBase64String(randomHash))))]
544+                    }
545+                else                 match getGameState(number) {
546+                    case state: Int => 
547+                        if (if ((state == GAMEINPROGRESS))
548+                            then true
549+                            else (state == GAMESTART))
550+                            then throw("The previous game is still in progress")
551+                            else {
552+                                let newNumber = (number + 1)
553+[IntegerEntry(gameCounterLabel, newNumber), IntegerEntry(gameStateLabel(newNumber), GAMESTART), IntegerEntry(gameStartHeightLabel(newNumber), lastBlock.height), IntegerEntry(gameEndHeightLabel(newNumber), (lastBlock.height + BLOCKTOPROCESSFORTHROW)), IntegerEntry(gameRollsCountBetLabel(newNumber), 0), StringEntry(gameSumShaLabel(newNumber), toBase58String(sha256(fromBase64String(randomHash))))]
554+                                }
555+                    case _ => 
556+                        throw("Error")
557+                }
558+        case _ => 
559+            throw("INIT_NEED")
560+    }
561+
562+
563+
564+@Callable(i)
565+func placeBet (typeBet) = if (validateBetName(typeBet))
566+    then if ((size(i.payments) == 0))
567+        then throw("Payment not attached")
568+        else         match getGameCounter() {
569+            case GAMENUMBER: Int => 
570+                let p = i.payments[0]
571+                match getGameState(GAMENUMBER) {
572+                    case state: Int => 
573+                        if ((state == GAMESTART))
574+                            then if (if ((typeBet == PASSLINEBET))
575+                                then true
576+                                else (typeBet == DONTPASSLINEBET))
577+                                then storePassOrComeBet(GAMENUMBER, toString(p.amount), typeBet, toBase58String(i.caller.bytes))
578+                                else throw((((((("Only " + PASSLINEBET) + ", ") + DONTPASSLINEBET) + " and ") + FIELDBET) + " are allowed in the Beginning of Game"))
579+                            else if ((state == GAMEINPROGRESS))
580+                                then throw((((((("Only " + COMEBET) + ", ") + DONTCOMEBET) + " and ") + FIELDBET) + " ARE ALLOWED at Start."))
581+                                else if ((state == GAMEFINISHED))
582+                                    then throw("Game already ended.")
583+                                    else throw("Unknown Game State.")
584+                    case _ => 
585+                        throw("Game does not exist or has already ended.")
586+                }
587+            case _ => 
588+                throw("Game has not been initialized.")
589+        }
590+    else throw(((((((((("Unsupported Type of Bet for Crap. Please Select one of " + PASSLINEBET) + ", ") + DONTPASSLINEBET) + ", ") + COMEBET) + ", ") + DONTCOMEBET) + ", ") + FIELDBET))
591+
592+
593+
594+@Callable(i)
595+func placeRoundBet (typeBet,oddNumber) = if (validateRoundBet(typeBet))
596+    then if ((size(i.payments) == 0))
597+        then throw("Payment not attached")
598+        else         match getGameCounter() {
599+            case GAMENUMBER: Int => 
600+                let p = i.payments[0]
601+                match getGameState(GAMENUMBER) {
602+                    case state: Int => 
603+                        if ((state == GAMEFINISHED))
604+                            then throw("Game already ended.")
605+                            else if (if ((typeBet == COMEBET))
606+                                then true
607+                                else (typeBet == DONTCOMEBET))
608+                                then if ((state == GAMESTART))
609+                                    then throw("Cannot place COME OR DONTCOME BET IF GAME HAS NOT STARTED")
610+                                    else storeOneRoundBetTypes(GAMENUMBER, toString(p.amount), typeBet, toBase58String(i.caller.bytes), 0)
611+                                else storeOneRoundBetTypes(GAMENUMBER, toString(p.amount), typeBet, toBase58String(i.caller.bytes), oddNumber)
612+                    case _ => 
613+                        throw("Game does not exist or has already ended.")
614+                }
615+            case _ => 
616+                throw("Game has not been initialized.")
617+        }
618+    else throw(((((((((("Unsupported Type of Bet for Crap. Please Select one of " + ODDSBET) + ", ") + DONTPASSLINEBET) + ", ") + COMEBET) + ", ") + DONTCOMEBET) + ", ") + FIELDBET))
619+
620+
621+
622+@Callable(i)
623+func throwDices (rsaSign,gameNumber) = if (authorizePermission(i.callerPublicKey))
624+    then throw("throwDices_FORBIDDEN")
625+    else     match getGameState(gameNumber) {
626+        case state: Int => 
627+            if ((state == GAMEFINISHED))
628+                then throw("Game is finished")
629+                else {
630+                    let currentHeight = lastBlock.height
631+                    let lastHeightAllowed = value(getEndHeight(gameNumber))
632+                    if ((currentHeight >= lastHeightAllowed))
633+                        then                         match getGameSumSha(gameNumber) {
634+                            case sumSha: String => 
635+                                let sig = fromBase64String(rsaSign)
636+                                let rsaSigValid = rsaVerify(SHA256, fromBase58String(sumSha), sig, RSAPUBLIC)
637+                                match blockInfoByHeight((lastBlock.height - 1)) {
638+                                    case previousBlock: BlockInfo => 
639+                                        let randomHash = sha256((take(sig, 4) + take(previousBlock.generationSignature, 8)))
640+                                        if (!(rsaSigValid))
641+                                            then throw("INVALID_RSA_SIGN")
642+                                            else {
643+                                                let randNumber = (toInt(randomHash) % 11)
644+                                                let number = diceNumber[randNumber]
645+                                                match getGameRollsCount(gameNumber) {
646+                                                    case rollCountNumber: Int => 
647+                                                        let newRollCountNumber = (rollCountNumber + 1)
648+                                                        if ((state == GAMESTART))
649+                                                            then if (if (if (if (if ((number == 7))
650+                                                                then true
651+                                                                else (number == 11))
652+                                                                then true
653+                                                                else (number == 2))
654+                                                                then true
655+                                                                else (number == 3))
656+                                                                then true
657+                                                                else (number == 12))
658+                                                                then storeGameProgressPointState(gameFirstPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEFINISHED)
659+                                                                else storeGameProgressPointState(gameFirstPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEINPROGRESS)
660+                                                            else {
661+                                                                let currentPoint = value(getCurrentPointDice(gameNumber))
662+                                                                let firstPoint = value(getFirstPointDice(gameNumber))
663+                                                                if ((currentPoint == 0))
664+                                                                    then if (if ((number == 7))
665+                                                                        then true
666+                                                                        else (firstPoint == number))
667+                                                                        then storeGameProgressPointState(gameCurrentPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEFINISHED)
668+                                                                        else storeGameProgressPointState(gameCurrentPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEINPROGRESS)
669+                                                                    else if (if ((number == 7))
670+                                                                        then true
671+                                                                        else (firstPoint == number))
672+                                                                        then storeGameProgressPointState(gameCurrentPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEFINISHED)
673+                                                                        else storeGameProgressPointState(gameCurrentPointDiceLabel(gameNumber), gameNumber, number, newRollCountNumber, currentHeight, randomHash, GAMEINPROGRESS)
674+                                                                }
675+                                                    case _ => 
676+                                                        throw("No dices have been thrown")
677+                                                }
678+                                                }
679+                                    case _ => 
680+                                        throw("Last block doesn't exist.")
681+                                }
682+                            case _ => 
683+                                throw("SHA doesn't exist")
684+                        }
685+                        else throw("Throw dice not allow still waiting for block to process")
686+                    }
687+        case _ => 
688+            throw("Game does not exist or has already ended.")
689+    }
690+
691+
692+@Verifier(tx)
693+func verify () = match tx {
694+    case _ => 
695+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
696+}
697+
github/deemru/w8io/169f3d6 
46.38 ms ◑