English Русский فارسی العربية Türkçe Español

QuickLotteryTON

Smart Contract for a simple random lottery on TON Blockchain

Contract Address: EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 Copied!

Tonviewer | Verifier

Summary

QuickLotteryTON is a simple smart contract on the TON blockchain. Participants enter the lottery via the enter call, send 1 or more TONs (exact amounts, no fractions) and enter the draw.

Once 10+ participants have entered and 24 hours has passed, any participant issues the draw call, which randomly picks ~10% as winners and distributes the lottery pool among them.

That's it!

You can see the source code below (jump to source code) for details.

How to Enter

To enter the lottery, simply send 1 TON (or 2, 3, 4, etc. TONs) to the contract address EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 Copied! with comment enter (Use exact word, not uppercase, no spaces).

Responses

If you send any value containing fractions (e.g., 1.002 TON) you will get your money back with a response saying Can only enter with 1 TON or multiples of 1 TON.

If you have already participated in this lottery round, you will get your money back with the message You have already entered this draw.

If you successfully enter the draw, you get the message Successfully entered the lottery draw with 1 TON!

Draw

Only one participant needs to do a draw per lottery round. You usually do not need to do this, it will happen automatically by one of the participants. You just need to enter and wait for the draw results in 24 hours!

If you want to make a draw, send 0.05 TON or more (depending on the number of participants, has to be enough for the computation gas) to the contract address EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 Copied! with the exact comment draw.

If the previous draw was less than 24 hours ago, you will get your money back with the message Cannot draw yet, X seconds remaining until next draw.

If less than 10 people have entered this round, you will get money back with message Not enough participants for draw.

Otherwise the code will randomly select about 10% of participants and distribute the bet pool to them! 1% gas fee will be retained by the contract.

Anyone who wins a draw gets their money along with a message Congratulations! You won 10000000000 nanoTON in the lottery draw!

Methods

On the Verifier link or the TonViewer link you can also call the contract getter methods. The available methods are:

Note that results are in hex, need to convert them to decimal first.

Source Code

This source code can be verified on the TON Verifier too:

  1. /**
  2. QuickLotteryTON contract
  4. Explorers:
  5. - Tonviewer: https://tonviewer.com/EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6
  6. - Verifier: https://verifier.ton.org/EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6
  8. Usage:
  9. - Enter lottery:
  10. • Send ≥ 1 TON (multiples of 1 TON) with comment "enter".
  11. • Each address may enter once per draw.
  13. - Getters:
  14. • balance() → current contract balance (nanoTON).
  15. • betPool() → total TON in the current lottery pool (nanoTON).
  16. • participantCount() → number of unique participants.
  18. - Draw:
  19. • Anyone can trigger via sending any amount of TON with comment "draw".
  20. • At most once every 24h.
  21. • Requires ≥ 10 participants before allowing draw.
  23. - Payout:
  24. • 1% fee to deployer for transaction fees.
  25. • Remaining pool distributed proportionally among ~10% of participants, chosen randomly.
  26. */
  28. import "@stdlib/deploy";
  30. const NANO_COUNT: Int = 1_000_000_000;
  32. message TransferEvent {
  33. amount: Int as int64;
  34. recipient: Address;
  35. }
  37. message EntryEvent {
  38. sender: Address;
  39. amount: Int as int64;
  40. }
  42. contract QuickLotteryTON with Deployable {
  43. const DRAW_EVERY: Int = 24 * 60 * 60; // Once every day at most.
  44. const MIN_PARTICIPANTS: Int = 10;
  46. lastDrawTime: Int;
  47. participants: map<Address, Int>;
  48. participantCount: Int;
  49. betPool: Int;
  50. deployer: Address;
  52. init() {
  53. nativeReserve(ton("1.0"), ReserveAtMost | ReserveBounceIfActionFail);
  55. self.deployer = sender();
  56. self.participantCount = 0;
  57. self.betPool = 0;
  58. self.participants = emptyMap();
  59. self.lastDrawTime = now();
  60. }
  62. receive("enter") {
  63. let amount: Int = context().value;
  64. if (amount < NANO_COUNT || amount % NANO_COUNT != 0) {
  65. self.reply("Can only enter with 1 TON or multiples of 1 TON.".asComment());
  66. return;
  67. }
  69. let sender: Address = sender();
  70. if (self.participants.exists(sender)) {
  71. self.reply("You have already entered this draw.".asComment());
  72. return;
  73. }
  75. self.participants.set(sender, amount);
  76. self.participantCount += 1;
  77. self.betPool += amount;
  79. // Emit entry event
  80. emit(EntryEvent{sender: sender, amount: amount}.toCell());
  82. // Send confirmation message to participant with bet amount
  83. let sb: StringBuilder = beginString();
  84. sb.append("Successfully entered the lottery draw with ");
  85. sb.append((amount / NANO_COUNT).toString());
  86. sb.append(" TON!");
  88. send(SendParameters{
  89. to: sender,
  90. bounce: false,
  91. value: 0, // No TON refunded
  92. mode: SendIgnoreErrors | SendPayFwdFeesSeparately,
  93. body: sb.toString().asComment()
  94. });
  95. }
  97. receive("draw") {
  98. // Check time since last draw
  99. let remaining: Int = self.DRAW_EVERY - (now() - self.lastDrawTime);
  100. if (remaining > 0) {
  101. let sb: StringBuilder = beginString();
  102. sb.append("Cannot draw yet, ");
  103. sb.append(remaining.toString());
  104. sb.append(" seconds remaining until next draw.");
  105. self.reply(sb.toString().asComment());
  106. return;
  107. }
  108. if (self.participantCount < self.MIN_PARTICIPANTS) {
  109. self.reply("Not enough participants for draw.".asComment());
  110. return;
  111. }
  113. // Send 1% fee to owner
  114. let ownerFee: Int = self.betPool / 100;
  115. if (ownerFee > 0) {
  116. emit(TransferEvent{amount: ownerFee, recipient: self.deployer}.toCell());
  117. send(SendParameters{
  118. to: self.deployer,
  119. bounce: true,
  120. value: ownerFee,
  121. mode: SendIgnoreErrors
  122. });
  123. }
  125. // Determine prize pool and winner count
  126. let pool: Int = self.betPool - ownerFee;
  127. let targetWinners: Int = self.participantCount / 10; // 10% winners
  129. // Select winners
  130. let winners: map<Address, Int> = emptyMap();
  131. let winnerCount: Int = 0;
  132. let totalWinnerWeight: Int = 0;
  134. // First pass: try to select winners with 10% chance
  135. while (winnerCount == 0) {
  136. foreach (adr, winnerWeight in self.participants) {
  137. if (random(1, 100) <= 10 && winnerCount < targetWinners) {
  138. winners.set(adr, winnerWeight);
  139. totalWinnerWeight += winnerWeight;
  140. winnerCount += 1;
  141. }
  142. }
  143. }
  145. // Distribute prizes proportionally to bet amounts
  146. foreach (winnerAddress, winnerWeight in winners) {
  147. let prize: Int = pool * winnerWeight / totalWinnerWeight;
  148. if (prize > 0) {
  149. // Create notification message with prize amount
  150. let sb: StringBuilder = beginString();
  151. sb.append("Congratulations! You won ");
  152. sb.append((prize).toString());
  153. sb.append(" nanoTON in the lottery draw!");
  155. // Emit transfer event
  156. emit(TransferEvent{amount: prize, recipient: winnerAddress}.toCell());
  158. // Send prize with notification message in a single transaction
  159. send(SendParameters{
  160. to: winnerAddress,
  161. bounce: true,
  162. value: prize,
  163. mode: SendIgnoreErrors,
  164. body: sb.toString().asComment()
  165. });
  166. }
  167. }
  169. // Reset lottery
  170. self.participantCount = 0;
  171. self.betPool = 0;
  172. self.participants = emptyMap();
  173. self.lastDrawTime = now();
  174. }
  177. get fun participantCount(): Int {
  178. return self.participantCount;
  179. }
  181. get fun betPool(): Int {
  182. return self.betPool;
  183. }
  185. get fun balance(): Int {
  186. return myBalance();
  187. }
  188. }