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

QuickLotteryTON

Contrato inteligente para una lotería aleatoria simple en la blockchain TON

Dirección del contrato: EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 ¡Copiado!

Tonviewer | Verifier

Resumen

QuickLotteryTON es un contrato inteligente simple en la blockchain TON. Los participantes ingresan a la lotería mediante la llamada enter, enviando 1 o más TON (cantidades exactas, sin fracciones).

Una vez que 10+ participantes se hayan unido y hayan pasado 24 horas, cualquier participante puede ejecutar la llamada draw. Se selecciona aleatoriamente ~10% de los participantes y se distribuye el fondo entre ellos.

¡Eso es todo!

Puedes ver el código fuente abajo (ir al código).

Cómo participar

Para ingresar a la lotería, simplemente envía 1 TON (o 2, 3, 4, etc.) a la dirección del contrato EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 ¡Copiado! con el comentario enter (usa exactamente esa palabra, sin espacios y en minúsculas).

Respuestas

Si envías un valor con decimales (ej. 1.002 TON), recibirás tu dinero de vuelta con el mensaje Can only enter with 1 TON or multiples of 1 TON.

Si ya has participado en esta ronda, recibirás tu dinero de vuelta con el mensaje You have already entered this draw.

Si tu entrada es correcta, recibirás el mensaje Successfully entered the lottery draw with 1 TON!

Sorteo

Sólo un participante necesita ejecutar el sorteo por ronda. Normalmente no hace falta, otro lo hará automáticamente. Sólo entra y espera los resultados en 24 horas.

Si quieres hacer el sorteo, envía 0.05 TON o más (según el número de participantes, suficiente para el gas) a la dirección del contrato EQCsihC1Z6fHRsFbz9N3sCHC6sUfvnlz4RbelethC-6Q34y6 ¡Copiado! con el comentario exacto draw.

Si el sorteo anterior fue hace menos de 24 horas, recibirás tu dinero con el mensaje Cannot draw yet, X seconds remaining until next draw.

Si han entrado menos de 10 personas en esta ronda, recibirás tu dinero con el mensaje Not enough participants for draw.

En otro caso, el código seleccionará aleatoriamente ~10% de los participantes y repartirá el fondo entre ellos. 1% se retiene como comisión de gas.

Los ganadores recibirán su premio con el mensaje Congratulations! You won 10000000000 nanoTON in the lottery draw!

Métodos

En el enlace de Verifier o TonViewer también puedes llamar a los métodos getter del contrato. Los métodos disponibles son:

Los resultados están en formato hex, debes convertirlos a decimal.

Código fuente

Este código fuente también se puede verificar en TON Verifier:

  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. }