solotto 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 Stratton Pelfmont
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,476 @@
+# Solotto
+
+A JavaScript SDK for interacting with the Solotto on-chain lottery program on Solana. Solotto provides a complete interface for creating lotteries, buying tickets, drawing winners, claiming prizes, and querying lottery state — all backed by a Solana smart contract.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Architecture](#architecture)
+- [Classes](#classes)
+  - [LotteryManager](#lotterymanager)
+  - [Lottery](#lottery)
+  - [LotteryNetwork](#lotterynetwork)
+- [API Reference](#api-reference)
+  - [LotteryManager](#lotterymanager-api)
+    - [Initialize](#initialize)
+    - [RandomDraw](#randomdraw)
+    - [LockLottery](#locklottery)
+  - [Lottery](#lottery-api)
+    - [BuyTickets](#buytickets)
+    - [ClaimTicket](#claimticket)
+    - [GetLottery](#getlottery)
+    - [GetTicket](#getticket)
+    - [GetTickets](#gettickets)
+    - [WatchDraw](#watchdraw)
+  - [LotteryNetwork](#lotterynetwork-api)
+    - [Tx](#tx)
+    - [Send](#send)
+    - [Status](#status)
+- [Transaction Modes](#transaction-modes)
+- [Dependencies](#dependencies)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+npm install solotto
+```
+
+---
+
+## Quick Start
+
+```js
+import { Connection, PublicKey, Keypair } from "@solana/web3.js";
+import { LotteryManager, Lottery } from "solotto";
+
+const connection = new Connection("https://api.mainnet-beta.solana.com");
+const programId = new PublicKey("YOUR_PROGRAM_ID");
+
+// --- Authority creates a lottery ---
+const authority = Keypair.generate(); // or load from file/wallet
+
+const manager = new LotteryManager(connection, programId);
+const result = await manager.Initialize(authority, 100000000, 1);
+// Creates lottery #1 with a ticket price of 0.1 SOL (in lamports)
+console.log(result); // "finalized"
+```
+
+---
+
+## Architecture
+
+Solotto is organized into three exported classes, each handling a different layer of responsibility:
+
+| Class | Role |
+|---|---|
+| **`LotteryManager`** | Admin operations — initialize lotteries, trigger draws, lock/unlock ticket sales. |
+| **`Lottery`** | Player & read operations — buy tickets, claim prizes, query lottery/ticket state, watch draws via WebSocket. |
+| **`LotteryNetwork`** | Low-level transaction utilities — build, simulate, send, and confirm transactions with automatic compute budget and priority fee estimation. |
+
+---
+
+## Classes
+
+### LotteryManager
+
+Used by the **lottery authority** (admin) to manage lotteries.
+
+```js
+import { LotteryManager } from "solotto";
+
+const manager = new LotteryManager(connection, programId);
+```
+
+**Constructor Parameters:**
+
+| Parameter | Type | Description |
+|---|---|---|
+| `connection` | `Connection` | A `@solana/web3.js` Connection instance. |
+| `program` | `PublicKey` | The Solotto on-chain program ID. |
+
+---
+
+### Lottery
+
+Used by **players** to buy tickets and claim prizes, and by anyone to read lottery state.
+
+```js
+import { Lottery } from "solotto";
+
+const lottery = new Lottery(connection, "wss://your-rpc.com", programId);
+```
+
+**Constructor Parameters:**
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `connection` | `Connection` | — | A `@solana/web3.js` Connection instance. |
+| `wss` | `String \| false` | `false` | WebSocket URL for real-time draw monitoring. Only required if using `WatchDraw()`. |
+| `program` | `PublicKey` | — | The Solotto on-chain program ID. |
+
+---
+
+### LotteryNetwork
+
+Low-level transaction builder and sender. Used internally by `LotteryManager` and `Lottery`, but can also be used directly for custom transaction flows.
+
+```js
+import { LotteryNetwork } from "solotto";
+
+const network = new LotteryNetwork(connection);
+```
+
+**Constructor Parameters:**
+
+| Parameter | Type | Description |
+|---|---|---|
+| `connection` | `Connection` | A `@solana/web3.js` Connection instance. |
+
+---
+
+## API Reference
+
+### LotteryManager API
+
+#### Initialize
+
+Creates a new on-chain lottery.
+
+```js
+const result = await manager.Initialize(authority, ticketPrice, lotteryId, encoded);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `Keypair` | — | The keypair that will own and control the lottery. |
+| `ticketPrice` | `Number` | — | Price per ticket in **lamports** (1 SOL = 1,000,000,000 lamports). |
+| `lotteryId` | `String` | — | A unique numeric identifier for this lottery. |
+| `encoded` | `Boolean` | `false` | If `true`, returns a base64-encoded transaction instead of signing and sending. |
+
+**Returns:** `"finalized"` on success when `encoded` is `false`, or a transaction object when `encoded` is `true`.
+
+---
+
+#### RandomDraw
+
+Triggers the on-chain random draw to select a winning ticket. Only callable by the lottery authority.
+
+```js
+const result = await manager.RandomDraw(authority, lotteryId, encoded);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `Keypair` | — | The lottery authority keypair. |
+| `lotteryId` | `String` | — | The lottery ID to draw. |
+| `encoded` | `Boolean` | `false` | If `true`, returns encoded transaction. |
+
+**Returns:** When `encoded` is `false` and the transaction finalizes, returns the updated lottery state object (see [GetLottery](#getlottery)). Otherwise returns the transaction object.
+
+---
+
+#### LockLottery
+
+Locks or unlocks ticket sales for a lottery. Only callable by the lottery authority.
+
+```js
+// Lock ticket sales
+await manager.LockLottery(authority, lotteryId, 0);
+
+// Unlock ticket sales
+await manager.LockLottery(authority, lotteryId, 1);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `Keypair` | — | The lottery authority keypair. |
+| `lotteryId` | `String` | — | The lottery ID. |
+| `lockState` | `Number` | — | `0` to lock (stop sales), `1` to unlock (resume sales). |
+| `encoded` | `Boolean` | `false` | If `true`, returns encoded transaction. |
+
+**Returns:** Updated lottery state object on finalization, or the transaction object when encoded.
+
+---
+
+### Lottery API
+
+#### BuyTickets
+
+Purchases one or more tickets for a lottery. Supports buying up to 4 tickets in a single transaction.
+
+```js
+const lottery = new Lottery(connection, false, programId);
+
+const result = await lottery.BuyTickets(buyer, authority, lotteryId, amount, encoded);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `buyer` | `Keypair` | — | The keypair of the ticket buyer. |
+| `authority` | `Keypair \| {publicKey}` | — | The lottery authority (only `publicKey` is needed). |
+| `lotteryId` | `Number` | — | The lottery ID to buy tickets for. |
+| `amount` | `Number` | `1` | Number of tickets to purchase (1–4). |
+| `encoded` | `Boolean` | `false` | If `true`, returns encoded transaction. |
+
+**Returns:** `"finalized"` on success, or the transaction object when encoded.
+
+**Example:**
+
+```js
+import { Connection, PublicKey, Keypair } from "@solana/web3.js";
+import { Lottery } from "solotto";
+
+const connection = new Connection("https://api.mainnet-beta.solana.com");
+const programId = new PublicKey("YOUR_PROGRAM_ID");
+const lottery = new Lottery(connection, false, programId);
+
+const buyer = Keypair.generate();
+const authority = { publicKey: new PublicKey("LOTTERY_AUTHORITY_PUBKEY") };
+
+// Buy 2 tickets for lottery #1
+const result = await lottery.BuyTickets(buyer, authority, 1, 2);
+console.log(result); // "finalized"
+```
+
+---
+
+#### ClaimTicket
+
+Claims the prize for the winning ticket. Must be called by the ticket owner.
+
+```js
+const result = await lottery.ClaimTicket(authority, lotteryId, winner, encoded);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `{publicKey}` | — | The lottery authority (only `publicKey` is needed). |
+| `lotteryId` | `Number` | — | The lottery ID. |
+| `winner` | `Keypair` | — | The keypair of the winning ticket's owner. |
+| `encoded` | `Boolean` | `false` | If `true`, returns encoded transaction. |
+
+**Returns:** `"finalized"` on success, or the transaction object when encoded.
+
+---
+
+#### GetLottery
+
+Fetches the full on-chain state of a lottery.
+
+```js
+const state = await lottery.GetLottery(authority, lotteryId, fees);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `{publicKey}` | — | The lottery authority (only `publicKey` is needed). |
+| `lotteryId` | `Number` | — | The lottery ID. |
+| `fees` | `Boolean` | `true` | If `true`, `prizePoolBalance` reflects the pool minus the 10% protocol fee. Set to `false` for the raw balance. |
+
+**Returns:**
+
+```js
+{
+  authority: "Pubkey...",         // Lottery authority public key
+  lotteryId: 1,                  // Lottery ID
+  ticketPrice: 100000000,        // Ticket price in lamports
+  totalTickets: 42,              // Total tickets sold
+  winnerTicketNumber: 17,        // Winning ticket number (0/null if not drawn)
+  winnerAddress: "Pubkey...",    // Winner's public key (null if not drawn)
+  isActive: true,                // Whether the lottery is active
+  prizePoolBalance: 3780000000,  // Prize pool in lamports (after fees if fees=true)
+  drawInitiated: false,          // Whether a draw has been initiated
+  prizePoolAddress: "Pubkey...", // Prize pool PDA
+  lotteryAddress: "Pubkey...",   // Lottery PDA
+}
+```
+
+---
+
+#### GetTicket
+
+Fetches a single ticket by its ticket number.
+
+```js
+const ticket = await lottery.GetTicket(authority, lotteryId, ticketNumber);
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `authority` | `{publicKey}` | The lottery authority (only `publicKey` is needed). |
+| `lotteryId` | `Number` | The lottery ID. |
+| `ticketNumber` | `Number` | The ticket number to look up. |
+
+**Returns:**
+
+```js
+{
+  ticketOwner: "Pubkey...",     // Owner of the ticket
+  ticketReceipt: "Pubkey...",   // Receipt account public key
+  ticketNumber: 17,             // The ticket number
+  ticketPda: "Pubkey...",       // Ticket PDA
+  lotteryId: 1,                 // Lottery ID
+  lotteryAddress: "Pubkey...",  // Lottery PDA
+  lotteryAuth: "Pubkey...",     // Lottery authority
+}
+```
+
+---
+
+#### GetTickets
+
+Fetches all tickets for a lottery, optionally filtered by buyer.
+
+```js
+// Get all tickets
+const allTickets = await lottery.GetTickets(authority, lotteryId);
+
+// Get tickets for a specific buyer
+const myTickets = await lottery.GetTickets(authority, lotteryId, buyer);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `authority` | `{publicKey}` | — | The lottery authority. |
+| `lotteryId` | `Number` | — | The lottery ID. |
+| `buyer` | `{publicKey} \| false` | `false` | Optional buyer to filter by. |
+
+**Returns:**
+
+```js
+{
+  lotteryId: 1,
+  lotteryAddress: "Pubkey...",
+  lotteryAuth: "Pubkey...",
+  buyer: "All",                // or the buyer's public key
+  tickets: [
+    {
+      owner: "Pubkey...",
+      lottery: "Pubkey...",
+      ticketReceipt: "Pubkey...",
+      ticketNumber: 42,
+      ticketPda: "Pubkey...",
+    },
+    // ... sorted descending by ticket number
+  ],
+}
+```
+
+---
+
+#### WatchDraw
+
+Opens a WebSocket subscription to listen for draw events in real time. Requires the `wss` parameter to be set in the `Lottery` constructor. Automatically reconnects on connection failure.
+
+```js
+const lottery = new Lottery(connection, "wss://your-rpc.com", programId);
+await lottery.WatchDraw();
+```
+
+> **Note:** This method is designed for browser environments and interacts with DOM elements (`spin-btn`, `stop-ticket`, `copy-signature-btn`) to trigger UI updates when a draw occurs.
+
+---
+
+### LotteryNetwork API
+
+The `LotteryNetwork` class handles low-level transaction construction, simulation, and sending. It is used internally but can also be used directly.
+
+#### Tx
+
+Builds a versioned transaction with automatic compute budget optimization and priority fee estimation.
+
+```js
+const network = new LotteryNetwork(connection);
+
+const result = await network.Tx({
+  account: "PublicKeyString",   // (required) Payer public key as string
+  instructions: [ix1, ix2],     // (required) Array of TransactionInstruction
+  signers: false,               // Array of Keypairs to pre-sign, or false
+  priority: "Low",              // "Low" | "Medium" | "High" | "VeryHigh" | "Extreme"
+  tolerance: 1.1,               // Compute unit multiplier for safety margin
+  serialize: false,             // If true, serializes the transaction
+  encode: false,                // If true, base64-encodes the serialized transaction
+  compute: true,                // If true, simulates and optimizes compute units
+  fees: true,                   // If true, estimates and sets priority fees
+  table: false,                 // Address Lookup Table account, or false
+  memo: false,                  // Optional memo string, or false
+});
+
+// result.status  → "ok" | "error"
+// result.message → "success" | error description
+// result.transaction → VersionedTransaction (or serialized/encoded form)
+```
+
+---
+
+#### Send
+
+Sends a signed transaction to the network.
+
+```js
+const signature = await network.Send(signedTransaction);
+```
+
+**Returns:** A transaction signature string, or an error object `{ status: "error", message: ... }`.
+
+---
+
+#### Status
+
+Polls for transaction confirmation until finalized or timeout.
+
+```js
+const status = await network.Status(signature, maxRetries, intervalSeconds);
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `signature` | `String` | — | The transaction signature. |
+| `maxRetries` | `Number` | `10` | Maximum number of polling attempts. |
+| `intervalSeconds` | `Number` | `3` | Seconds between each poll. |
+
+**Returns:** `"finalized"`, `"program error!"`, or a timeout message string.
+
+---
+
+## Transaction Modes
+
+Every write method (`Initialize`, `RandomDraw`, `LockLottery`, `BuyTickets`, `ClaimTicket`) supports two modes controlled by the `encoded` parameter:
+
+**Direct Mode** (`encoded = false`, default) — The SDK signs, sends, and confirms the transaction. Requires the keypair to have a `secretKey`. Returns the final status or lottery state.
+
+```js
+const result = await manager.Initialize(authority, 100000000, 1);
+// result → "finalized"
+```
+
+**Encoded Mode** (`encoded = true`) — The SDK builds the transaction and returns it as a base64-encoded string. Useful for wallet adapters or server-side signing flows where the private key is not directly available.
+
+```js
+const result = await manager.Initialize(authority, 100000000, 1, true);
+// result.transaction → base64-encoded transaction string
+// Sign and send with your wallet adapter
+```
+
+---
+
+## Dependencies
+
+- `@solana/web3.js` — Solana JavaScript SDK
+- `@solana/spl-memo` — Memo program instruction helper
+- `@solana/kit` — WebSocket subscriptions (for `WatchDraw`)
+- `bn.js` — Big number library
+- `bs58` — Base58 encoding/decoding
+- `buffer-layout` — Buffer struct layout parsing
+
+---
+
+## License
+
+See [LICENSE](./LICENSE) for details.

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "solotto",
+  "version": "1.0.0",
+  "description": "Solana lottery client",
+  "type": "module",
+  "main": "solotto.js",
+  "scripts": {
+    "start": "node test.js"
+  },
+  "keywords": [
+    "solana",
+    "lottery"
+  ],
+  "author": "@SolDapper",
+  "license": "MIT",
+  "dependencies": {
+    "@solana/kit": "^6.0.1",
+    "@solana/spl-memo": "^0.2.5",
+    "@solana/web3.js": "^1.98.4",
+    "bn.js": "^5.2.2",
+    "bs58": "^6.0.0",
+    "buffer-layout": "^1.2.2",
+    "events": "^3.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0"
+  }
+}

package/solotto.js

@@ -0,0 +1,749 @@
+import {Connection, PublicKey, TransactionMessage, TransactionInstruction, VersionedTransaction, ComputeBudgetProgram, SystemProgram, Keypair, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_CLOCK_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY} from '@solana/web3.js';
+import bs58 from 'bs58';
+import BN from 'bn.js';
+import {createMemoInstruction} from '@solana/spl-memo';
+import BufferLayout from "buffer-layout";
+const publicKey=(property="publicKey")=>{return BufferLayout.blob(32,property);};const uint64=(property="uint64")=>{return BufferLayout.blob(8,property);}
+import {createSolanaRpcSubscriptions} from "@solana/kit";
+import {EventEmitter} from 'events';
+
+const INSTRUCTIONS = {
+    INITIALIZE_LOTTERY: 0,
+    BUY_TICKET: 1,
+    ENTROPY: 2,
+    CLAIM_PRIZE: 3,
+    LOCK_LOTTERY: 4,
+};
+
+class LotteryNetwork {
+    /*** @param {Connection} connection - Solana connection */
+    constructor(connection){this.connection=connection;}
+    async Tx(_data_){
+        let _obj_={};let _account_;let _instructions_;let _signers_;let _priority_;let _tolerance_;let _serialize_;let _encode_;let _table_;let _compute_;let _fees_;let _memo_;
+        if(typeof _data_.account=="undefined"){_obj_.message="missing account";return _obj_;}else{_account_=_data_.account;}
+        if(typeof _data_.instructions=="undefined"){_obj_.message="missing instructions";return _obj_;}else{_instructions_=_data_.instructions;}
+        if(typeof _data_.signers=="undefined" || _data_.signers==false){_signers_=false;}else{_signers_=_data_.signers;}
+        if(typeof _data_.priority=="undefined"){_priority_="Low";}else{_priority_=_data_.priority;}
+        if(typeof _data_.tolerance=="undefined" || _data_.tolerance==false){_tolerance_=1.1;}else{_tolerance_=_data_.tolerance;}
+        if(typeof _data_.serialize=="undefined"){_serialize_=false;}else{_serialize_=_data_.serialize;}
+        if(typeof _data_.encode=="undefined"){_encode_=false;}else{_encode_=_data_.encode;}
+        if(typeof _data_.compute=="undefined"){_compute_=true;}else{_compute_=_data_.compute;}
+        if(typeof _data_.fees=="undefined"){_fees_=true;}else{_fees_=_data_.fees;}
+        if(typeof _data_.table=="undefined" || _data_.table==false){_table_=[];}else{_table_=[_data_.table];}
+        if(typeof _data_.memo!="undefined" && _data_.memo!=false){_memo_=_data_.memo;}else{_memo_=false;}
+        const _wallet_ = new PublicKey(_account_);
+        const _blockhash_ = (await this.connection.getLatestBlockhash('confirmed')).blockhash;
+        if(_priority_=="Extreme"){_priority_="VeryHigh";}
+        let _payer_ = { publicKey : _wallet_ }
+        if(_memo_ != false){const memoIx = createMemoInstruction(_memo_,[new PublicKey(_account_)]);_instructions_.push(memoIx);}
+        if(_compute_ != false){
+            let _cu_ = null;
+            _cu_= await this.Compute(_wallet_,_instructions_,_tolerance_,_blockhash_,_table_);
+            if(typeof _cu_.logs != "undefined"){
+                _obj_.status="error";
+                _cu_.message="there was an error when simulating the transaction";
+                return _cu_;
+            }
+            else if(_cu_==null){
+                _obj_.status="error";
+                _obj_.message="there was an error when optimizing compute limit";
+                return _obj_;
+            }
+            _instructions_.unshift(ComputeBudgetProgram.setComputeUnitLimit({units:_cu_}));
+        }
+        if(_fees_ != false){
+            const get_priority = await this.Estimate(_payer_,_priority_,_instructions_,_blockhash_,_table_);
+            _instructions_.unshift(ComputeBudgetProgram.setComputeUnitPrice({microLamports:get_priority}));
+        }
+        let _message_ = new TransactionMessage({payerKey:_wallet_,recentBlockhash:_blockhash_,instructions:_instructions_,}).compileToV0Message(_table_);
+        let _tx_ = new VersionedTransaction(_message_);
+        if(_signers_!=false){
+            _tx_.sign(_signers_);
+        }
+        if(_serialize_ === true){
+            _tx_=_tx_.serialize();
+        }
+        if(_encode_ === true){
+            _tx_= Buffer.from(_tx_).toString("base64");
+        }
+        _obj_.status="ok";
+        _obj_.message="success";
+        _obj_.transaction=_tx_;
+        return _obj_;
+    }
+    async Send(tx){
+        try{
+            const signature = await this.connection.sendRawTransaction(tx.serialize(),{skipPreflight:true,maxRetries:0});
+            return signature;
+        }
+        catch(err){
+            const _error_ = {}
+            _error_.status="error";
+            _error_.message=err;
+            return _error_;
+        }
+    }
+    async Status(sig,max=10,int=3){
+        return await new Promise(resolve=>{
+            let start = 1;          
+            let intervalID = setInterval(async()=>{
+            let tx_status = null;
+            tx_status = await this.connection.getSignatureStatuses([sig], {searchTransactionHistory: true,});
+            if (tx_status == null || 
+            typeof tx_status.value == "undefined" || 
+            tx_status.value == null || 
+            tx_status.value[0] == null || 
+            typeof tx_status.value[0] == "undefined" || 
+            typeof tx_status.value[0].confirmationStatus == "undefined"){
+                // console.log("trying again...");
+            } 
+            else if(tx_status.value[0].confirmationStatus == "processed"){
+                start = 1;
+            }
+            else if(tx_status.value[0].confirmationStatus == "confirmed"){
+                // console.log("confirming...");
+                start = 1;
+            }
+            else if (tx_status.value[0].confirmationStatus == "finalized"){
+                if(tx_status.value[0].err != null){
+                resolve('program error!');
+                clearInterval(intervalID);
+                }
+                resolve('finalized');
+                clearInterval(intervalID);
+            }
+            start++;
+            if(start == max + 1){
+                resolve((max * int)+' seconds max wait reached');
+                clearInterval(intervalID);
+            }
+            },(int * 1000));
+        });  
+    }
+    async Compute(payer,ix,tolerance,blockhash,table=false){
+        const sim_limit = ComputeBudgetProgram.setComputeUnitLimit({units:1400000});
+        const fee_limit = ComputeBudgetProgram.setComputeUnitPrice({microLamports:10000});
+        let re = []; for (let o in ix) {re.push(ix[o]);}
+        ix = re; ix.unshift(sim_limit); ix.unshift(fee_limit);
+        const msg = new TransactionMessage({payerKey:payer,recentBlockhash:blockhash,instructions:ix,}).compileToV0Message(table);
+        const tx = new VersionedTransaction(msg);
+        const res = await this.connection.simulateTransaction(tx,{replaceRecentBlockhash:true,sigVerify:false,});
+        // console.log(res);
+        if(res.value.err != null){return {"status":"error","message":"simulation error","details":res.value.err,"logs":res.value.logs};}
+        const consumed = res.value.unitsConsumed;
+        return Math.ceil(consumed * tolerance);
+    }
+    async Estimate(payer,priority_level,instructions,blockhash,table=false){
+        let re_ix = [];
+        for (let o in instructions) {re_ix.push(instructions[o]);}
+        instructions = re_ix;
+        const _msg = new TransactionMessage({payerKey:payer.publicKey,recentBlockhash:blockhash,instructions:instructions,}).compileToV0Message(table);
+        const tx = new VersionedTransaction(_msg);
+        const response = await fetch(this.connection.rpcEndpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: "1",
+            method: "getPriorityFeeEstimate",
+            params: [
+                {
+                transaction: bs58.encode(tx.serialize()), // Pass the serialized transaction in Base58
+                options: { priorityLevel: priority_level },
+                },
+            ],
+            }),
+        });
+        let data = await response.json();
+        data = parseInt(data.result.priorityFeeEstimate);
+        if(data == 1){data = 100000;}
+        if(data < 10000){data = 10000;}
+        return data;
+    }
+}
+
+class Lottery {
+
+    /*** 
+    * @param {Connection} connection - Solana connection
+    * @param {String} wss - Web Socket URL 
+    * @param {PublicKey} program - Lottery Program Id 
+    */
+    constructor(connection, wss = false, program){
+        this.connection=connection;
+        this.wss=wss;
+        this.program=program;
+        this.TICKET_STATE = BufferLayout.struct([
+            publicKey("owner"),
+            publicKey("lottery"),
+            publicKey("ticketReceipt"),
+            uint64("ticketNumber"),    
+        ]);
+    }
+
+    /*** 
+    */
+    async WatchDraw(){
+        const self = this;
+        const RECONNECT_DELAY = 5000; // 5 seconds
+        
+        async function connect() {
+            try{
+                console.log('WatchDraw: Connecting to websocket...');
+                new EventEmitter();
+                EventEmitter.defaultMaxListeners = 1;
+                const abortController = new AbortController();
+                const subscriptions = createSolanaRpcSubscriptions(self.wss, {intervalMs: 30000});
+                const allNotifications = await subscriptions.logsNotifications(
+                    {
+                        mentions: [self.program.toString()]
+                    },
+                    {
+                        commitment: "finalized"
+                    }
+                ).subscribe({abortSignal:abortController.signal});
+                
+                console.log('WatchDraw: Connected successfully');
+                
+                for await (const noti of allNotifications) {
+                    const signature = noti.value.signature;
+                    const logs = noti.value.logs;
+                    const pattern_1 = "Program log: Winning ticket number: ";
+                    const pattern_2 = "Program log: Fee amount: ";                
+                    let winningTicketNumber = 0;
+                    let isDraw = false;
+                    for await (const log of logs) {
+                        if(log.includes(pattern_1)){
+                            winningTicketNumber = parseInt(log.replace(pattern_1, ""));
+                        }
+                        if(log.includes(pattern_2)){
+                            isDraw = true;
+                        }
+                    }
+                    if(isDraw){
+                        const stopTicketInput = document.getElementById('stop-ticket');
+                        stopTicketInput.value = winningTicketNumber;
+                        const spinBtn = document.getElementById('spin-btn');
+                        const copySignatureBtn = document.getElementById('copy-signature-btn');
+                        copySignatureBtn.innerHTML = signature;
+                        spinBtn.click();
+                    }
+                }
+            }
+            catch(err){
+                console.log('WatchDraw: Connection error:', err);
+                console.log(`WatchDraw: Reconnecting in ${RECONNECT_DELAY/1000} seconds...`);
+                setTimeout(() => {
+                    connect();
+                }, RECONNECT_DELAY);
+            }
+        }
+        
+        // Start the connection
+        connect();
+    }
+    
+    /*** 
+     * @param {PublicKey} authority - Keypair with no secretKey
+     * @param {Number} lotteryId - Lottery Id Number
+     * @param {PublicKey} winner - Keypair with no secretKey
+     * @param {Boolean} encoded - true returns encoded transaction
+    */
+    async ClaimTicket(authority, lotteryId, winner, encoded = false){
+        async function claimData() {
+            const buffer = Buffer.alloc(1);
+            buffer.writeUInt8(INSTRUCTIONS.CLAIM_PRIZE, 0);
+            return buffer;
+        }
+        const network = new LotteryNetwork(this.connection);
+        const LOTTO = await this.GetLottery(authority, lotteryId);
+        const TICKET_NUMBER = LOTTO.winnerTicketNumber;
+        LOTTO.ticket = await this.GetTicket(authority, lotteryId, TICKET_NUMBER);
+        const keys = [
+            { pubkey: new PublicKey(LOTTO.ticket.ticketOwner), isSigner: true, isWritable: true },
+            { pubkey: new PublicKey(LOTTO.ticket.lotteryAddress), isSigner: false, isWritable: true },
+            { pubkey: new PublicKey(LOTTO.ticket.ticketReceipt), isSigner: false, isWritable: false },
+            { pubkey: new PublicKey(LOTTO.ticket.ticketPda), isSigner: false, isWritable: false },
+            { pubkey: new PublicKey(LOTTO.prizePoolAddress), isSigner: false, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ];
+        const ix = new TransactionInstruction({programId: this.program, keys, data: await claimData()});
+        const _tx_ = {};
+        _tx_.account = LOTTO.ticket.ticketOwner;       // string : required
+        _tx_.instructions = [ix];                      // array  : required
+        _tx_.signers = false;                          // array  : default false
+        _tx_.table = false;                            // array  : default false
+        _tx_.tolerance = 1.2;                          // int    : default 1.1    
+        _tx_.compute = true;                           // bool   : default true
+        _tx_.fees = true;                              // bool   : default true
+        _tx_.priority = "Low"; 
+        if(encoded){
+            _tx_.serialize = true;                        
+            _tx_.encode = true;  
+        }
+        else{
+            _tx_.serialize = false;                        
+            _tx_.encode = false;  
+        }
+        const tx = await network.Tx(_tx_);
+        if(winner.secretKey && !encoded){
+            tx.transaction.sign([winner]);
+            const sig = await network.Send(tx.transaction);
+            console.log("Signature:", sig);
+            return await network.Status(sig);
+        }
+        else{return tx;}
+    }
+    
+    /*** 
+     * @param {PublicKey} buyer - Keypair with no secretKey
+     * @param {PublicKey} authority - Keypair with no secretKey
+     * @param {Number} lotteryId - Lottery Id Number
+     * @param {Number} amount - Ticket Qty 1-4
+     * @param {Boolean} encoded - true returns encoded transaction
+    */
+    async BuyTickets(buyer, authority, lotteryId, amount = 1, encoded = false){
+        const network = new LotteryNetwork(this.connection);
+        const result = await this.BundleTickets(authority, buyer, lotteryId, amount);
+        const _tx_ = {};
+        _tx_.account = buyer.publicKey.toString();     // string : required
+        _tx_.instructions = result.ixs;                // array  : required
+        _tx_.signers = result.signers;                 // array  : default false
+        _tx_.table = false;                            // array  : default false
+        _tx_.tolerance = 1.2;                          // int    : default 1.1    
+        _tx_.compute = true;                           // bool   : default true
+        _tx_.fees = true;                              // bool   : default true
+        _tx_.priority = "Low"; 
+        if(encoded){
+            _tx_.serialize = true;                        
+            _tx_.encode = true;  
+        }
+        else{
+            _tx_.serialize = false;                        
+            _tx_.encode = false;  
+        }
+        const tx = await network.Tx(_tx_);
+        if(buyer.secretKey && !encoded){
+            tx.transaction.sign([buyer]);
+            const sig = await network.Send(tx.transaction);
+            console.log("Signature:", sig);
+            return await network.Status(sig);
+        }
+        else{return tx;}
+    }
+    async BundleTickets(authority, buyer, lotteryId, amount) {
+        async function ticketData() {
+            const buffer = Buffer.alloc(1);
+            buffer.writeUInt8(INSTRUCTIONS.BUY_TICKET, 0); // BuyTicket discriminator
+            return buffer;
+        }
+        const [lotteryPDA] = await this.DeriveLotteryPDA(authority.publicKey, lotteryId);
+        const [prizePoolPDA] = await this.DerivePrizePoolPDA(lotteryPDA);
+        const ixs = [];
+        const signers = [];
+        let i = 0;
+        while (i < amount) {
+            const ticketReceipt = new Keypair();
+            signers.push(ticketReceipt);
+            const rent = await this.connection.getMinimumBalanceForRentExemption(0);
+            const createReceiptAccountIx = SystemProgram.createAccount({
+                programId: this.program,
+                space: 0,
+                lamports: rent,
+                fromPubkey: buyer.publicKey,
+                newAccountPubkey: ticketReceipt.publicKey
+            });
+            ixs.push(createReceiptAccountIx);
+            const [ticketPDA] = await this.DeriveTicketPDA(lotteryPDA, buyer.publicKey, ticketReceipt.publicKey);
+            const ix = new TransactionInstruction({
+                keys: [
+                    { pubkey: buyer.publicKey, isSigner: true, isWritable: true },
+                    { pubkey: lotteryPDA, isSigner: false, isWritable: true },
+                    { pubkey: ticketPDA, isSigner: false, isWritable: true },
+                    { pubkey: prizePoolPDA, isSigner: false, isWritable: true },
+                    { pubkey: ticketReceipt.publicKey, isSigner: true, isWritable: true },
+                    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ],
+                programId: this.program,
+                data: await ticketData(),
+            });
+            ixs.push(ix);
+            i++;
+        }
+        return {
+            ixs,
+            signers
+        };
+    }
+
+    /*** 
+     * @param {PublicKey} authority - Keypair with no secretKey
+     * @param {Number} lotteryId - Lottery Id 
+     * @param {Number} ticket - Ticket Number 
+    */
+    async GetTicket(authority, lotteryId, ticket) {
+        async function numberToBase58(num, byteLength = 8) {
+            const buffer = Buffer.alloc(byteLength);
+            buffer.writeBigUInt64LE(BigInt(num), 0);
+            return bs58.encode(buffer);
+        }
+        const [lotteryPDA] = await this.DeriveLotteryPDA(authority.publicKey, lotteryId);
+        const data_ = await this.connection.getProgramAccounts(this.program, {
+            filters:[
+                {dataSize: 104},
+                {memcmp:{
+                    offset: 32,
+                    bytes: lotteryPDA.toString(),
+                },},
+                {memcmp:{
+                    offset: 96,
+                    bytes: await numberToBase58(ticket),
+                },},
+            ],
+        });
+        const data = data_[0];
+        const accountInfo = await this.connection.getAccountInfo(data.pubkey);
+        const decoded = this.TICKET_STATE.decode(accountInfo.data);
+        const owner_ = new PublicKey(decoded.owner).toString();
+        const lottery_ = new PublicKey(decoded.lottery).toString();
+        const ticketReceipt_ = new PublicKey(decoded.ticketReceipt).toString();
+        const ticketNumber_ = parseInt(new BN(decoded.ticketNumber, 10, "le"));
+        return {
+            ticketOwner: owner_,
+            ticketReceipt: ticketReceipt_,
+            ticketNumber: ticketNumber_,
+            ticketPda: data.pubkey.toString(),
+            lotteryId: lotteryId,
+            lotteryAddress: lottery_,
+            lotteryAuth: authority.publicKey.toString(),
+        };
+    }
+
+    /*** 
+     * @param {PublicKey} authority - Keypair with no secretKey
+     * @param {Number} lotteryId - Lottery Id 
+     * @param {PublicKey} buyer - Ticket Buyer Optional
+    */
+    async GetTickets(authority, lotteryId, buyer = false) {
+        async function numberToBase58(num, byteLength = 8) {
+            const buffer = Buffer.alloc(byteLength);
+            buffer.writeBigUInt64LE(BigInt(num), 0);
+            return bs58.encode(buffer);
+        }
+        const [lotteryPDA] = await this.DeriveLotteryPDA(authority.publicKey, lotteryId);
+        const filters = [];
+        filters.push({dataSize: 104});
+        if(buyer){filters.push({memcmp:{offset: 0, bytes: buyer.publicKey.toString(),},});}
+        filters.push({memcmp:{offset: 32,bytes: lotteryPDA.toString(),},});
+        const data_ = await this.connection.getProgramAccounts(this.program, {filters:filters,});
+        const tickets = [];
+        let i = 0;
+        while(i < data_.length){
+            const data = data_[i];
+            const newTicket = {};
+            const account = await this.connection.getAccountInfo(data.pubkey);
+            const decoded = this.TICKET_STATE.decode(account.data);
+            newTicket.owner = new PublicKey(decoded.owner).toString();
+            newTicket.lottery = new PublicKey(decoded.lottery).toString();
+            newTicket.ticketReceipt = new PublicKey(decoded.ticketReceipt).toString();
+            newTicket.ticketNumber = parseInt(new BN(decoded.ticketNumber, 10, "le"));
+            newTicket.ticketPda = data.pubkey.toString();
+            tickets.push(newTicket);
+            i++;
+        }
+        tickets.sort((a, b) => b.ticketNumber - a.ticketNumber);
+        let _buyer_ = "All";
+        if(buyer){_buyer_ = buyer.publicKey.toString();}
+        return {
+            lotteryId: lotteryId,
+            lotteryAddress: lotteryPDA.toString(),
+            lotteryAuth: authority.publicKey.toString(),
+            buyer: _buyer_,
+            tickets: tickets,
+        };
+    }
+
+    /*** 
+     * @param {PublicKey} authority - Keypair with no secretKey
+     * @param {Number} lotteryId - Lottery Id 
+     * @param {Boolean} fees - true = prize pool - 10% (for display before drawing)
+    */
+    async GetLottery(authority, lotteryId, fees = true) {
+        const [lotteryPDA] = await this.DeriveLotteryPDA(authority.publicKey, lotteryId);
+        const account = await this.connection.getAccountInfo(lotteryPDA);
+        return await this.DecodeLotteryState(account.data, fees);
+    }
+    async DecodeLotteryState(buffer, fees = true){
+        let offset = 0;
+        // Helper to handle the 1-byte Option flag
+        const readOption = (readFn) => {
+            const hasValue = buffer.readUInt8(offset) === 1;
+            offset += 1;
+            return hasValue ? readFn() : null;
+        };
+        // 1. authority: Pubkey (32 bytes)
+        const auth = new PublicKey(buffer.slice(offset, offset + 32)).toString();
+        offset += 32;
+        // 2. lottery_id: u64 (8 bytes)
+        const lotteryId = Number(buffer.readBigUInt64LE(offset));
+        offset += 8;
+        // 3. ticket_price: u64 (8 bytes)
+        const ticketPrice = Number(buffer.readBigUInt64LE(offset));
+        offset += 8;
+        // 4. total_tickets: u64 (8 bytes)
+        const totalTickets = Number(buffer.readBigUInt64LE(offset));
+        offset += 8;
+        // 5. winner_ticket_number: Option<u64> (1 + 8 bytes)
+        const winnerTicketNumber = readOption(() => {
+            const val = buffer.readBigUInt64LE(offset);
+            offset += 8;
+            return val;
+        });
+        // 6. winner_address: Option<Pubkey> (1 + 32 bytes)
+        const winnerAddress = readOption(() => {
+            const val = buffer.slice(offset, offset + 32);
+            offset += 32;
+            return val;
+        });
+        // 7. is_active: bool (1 byte)
+        const isActive = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        // 8. prize_pool: u64 (8 bytes)
+        const prizePool = Number(buffer.readBigUInt64LE(offset));
+        offset += 8;
+        const drawInitiated = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const prizePoolAddress = await this.DerivePrizePoolPDA();
+        const lotteryAddress = await this.DeriveLotteryPDA(new PublicKey(auth), lotteryId);
+        let prizePoolBalance = prizePool;
+        if(fees){prizePoolBalance = prizePool - (prizePool * 0.1);}
+        return {
+            authority: auth,
+            lotteryId,
+            ticketPrice,
+            totalTickets,
+            winnerTicketNumber: Number(winnerTicketNumber),
+            winnerAddress,
+            isActive,
+            prizePoolBalance,
+            drawInitiated,
+            prizePoolAddress: prizePoolAddress[0].toString(),
+            lotteryAddress: lotteryAddress[0].toString(),
+        };
+    };
+
+    /*** Derivation Helpers */
+    async DeriveLotteryPDA(authority, lotteryId) {
+        const idBuffer = Buffer.alloc(8);
+        idBuffer.writeBigUInt64LE(BigInt(lotteryId));
+        return PublicKey.findProgramAddressSync([Buffer.from("lottery"), authority.toBuffer(), idBuffer], this.program);
+    }
+    async DeriveTicketPDA(lotteryPDA, buyer, ticketReceipt) {
+        const programId = this.program;
+        return PublicKey.findProgramAddressSync(
+            [
+                Buffer.from("ticket"), 
+                lotteryPDA.toBuffer(), 
+                buyer.toBuffer(), 
+                ticketReceipt.toBuffer()
+            ],
+            programId
+        );
+    }
+    async DerivePrizePoolPDA() {
+      return PublicKey.findProgramAddressSync([Buffer.from("prize-pool")], this.program);
+    }
+
+}
+
+class LotteryManager {
+
+    /*** 
+    * @param {Connection} connection - Solana connection
+    * @param {PublicKey} program - Lottery Program Id 
+    */
+    constructor(connection, program){this.connection=connection;this.program=program;}
+    
+    /*** 
+     * @param {Keypair} authority - Keypair
+     * @param {Number} ticketPrice - Number
+     * @param {String} lotteryId - String 
+     * @param {Boolean} encoded - true returns encoded transaction
+    */
+    async Initialize(authority, ticketPrice, lotteryId, encoded = false){
+        const lottery = new Lottery(this.connection, false, this.program);
+        const network = new LotteryNetwork(this.connection);
+        async function initializeData(tketPrice, lotId) {
+            const buffer = Buffer.alloc(17); // 1 byte discriminator + 8 bytes price + 8 bytes id
+            buffer.writeUInt8(INSTRUCTIONS.INITIALIZE_LOTTERY, 0); // initializeLottery discriminator
+            buffer.writeBigUInt64LE(BigInt(tketPrice), 1);
+            buffer.writeBigUInt64LE(BigInt(lotId), 9);
+            return buffer;
+        }
+        const [lotteryPDA, bump] = await lottery.DeriveLotteryPDA(authority.publicKey, lotteryId);
+        console.log("Lottery PDA:", lotteryPDA.toString());
+        const ix = new TransactionInstruction({
+            keys: [
+                { pubkey: authority.publicKey, isSigner: true, isWritable: true },
+                { pubkey: lotteryPDA, isSigner: false, isWritable: true },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ],
+            programId: this.program,
+            data: await initializeData(ticketPrice, lotteryId),
+        });
+        const _tx_ = {};
+        _tx_.account = authority.publicKey.toString(); // string : required
+        _tx_.instructions = [ix];                      // array  : required
+        _tx_.signers = false;                          // array  : default false
+        _tx_.table = false;                            // array  : default false
+        _tx_.tolerance = 1.2;                          // int    : default 1.1    
+        _tx_.compute = true;                           // bool   : default true
+        _tx_.fees = true;                              // bool   : default true
+        _tx_.priority = "Low";                         // string : default Low
+        if(encoded){
+            _tx_.serialize = true;                        
+            _tx_.encode = true;  
+        }
+        else{
+            _tx_.serialize = false;                        
+            _tx_.encode = false;  
+        }
+        const tx = await network.Tx(_tx_);                
+        if(tx.status !== "ok"){return tx;}
+        if(authority.secretKey && !encoded){
+            tx.transaction.sign([authority]);
+            const sig = await network.Send(tx.transaction);
+            console.log("Signature:", sig);
+            return await network.Status(sig);
+        }
+        else{return tx;}
+    }
+
+    /**
+     * @param {Keypair} authority - Keypair
+     * @param {String} lotteryId - The lottery id
+     * @param {Boolean} encoded - true returns encoded transaction
+    */
+    async RandomDraw(authority, lotteryId, encoded = false) {
+        try{
+            async function randomnessData() {
+                const buffer = Buffer.alloc(1);
+                buffer.writeUInt8(INSTRUCTIONS.ENTROPY, 0);
+                return buffer;
+            }
+            const lottery = new Lottery(this.connection, false, this.program);
+            const network = new LotteryNetwork(this.connection);
+            const [lotteryPDA] = await lottery.DeriveLotteryPDA(authority.publicKey, lotteryId);
+            const [prizePoolPDA] = await lottery.DerivePrizePoolPDA();
+            const keys = [
+                { pubkey: authority.publicKey, isSigner: true, isWritable: false },
+                { pubkey: lotteryPDA, isSigner: false, isWritable: true },
+                { pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY, isSigner: false, isWritable: false },
+                { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+                { pubkey: prizePoolPDA, isSigner: false, isWritable: true },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            ];
+            const ix = new TransactionInstruction({programId: this.program, keys, data: await randomnessData()});
+            const _tx_ = {};
+            _tx_.account = authority.publicKey.toString(); // string : required
+            _tx_.instructions = [ix];                      // array  : required
+            _tx_.signers = false;                          // array  : default false
+            _tx_.table = false;                            // array  : default false
+            _tx_.tolerance = 1.2;                          // int    : default 1.1    
+            _tx_.compute = true;                           // bool   : default true
+            _tx_.fees = true;                              // bool   : default true
+            _tx_.priority = "Low";                         // string : default Low
+            _tx_.memo = "draw";
+            if(encoded){
+                _tx_.serialize = true;                        
+                _tx_.encode = true;  
+            }
+            else{
+                _tx_.serialize = false;                        
+                _tx_.encode = false;  
+            }
+            const tx = await network.Tx(_tx_);             // build the tx
+            if(tx.status !== "ok"){return tx;}
+            if(authority.secretKey && !encoded){
+                tx.transaction.sign([authority]);
+                const sig = await network.Send(tx.transaction);
+                console.log("Signature:", sig);
+                const status = await network.Status(sig);
+                if(status == "finalized"){
+                    return await lottery.GetLottery({publicKey: authority.publicKey}, lotteryId, false);
+                }
+                else{return status;}
+            }
+            else{return tx;}
+        } 
+        catch (error) {
+            console.log(error);
+        }
+    }
+
+    /**
+     * @param {Keypair} authority - Keypair
+     * @param {String} lotteryId - The lottery id
+     * @param {Number} lockState - 0 = lock ticket sales, 1 = unlock (requires authority)
+     * @param {Boolean} encoded - true returns encoded transaction
+    */
+    async LockLottery(authority, lotteryId, lockState, encoded = false) {
+        try{
+            async function lockData(lock) {
+                const buffer = Buffer.alloc(2); // 1 byte discriminator + 1 bytes lock status
+                buffer.writeUInt8(INSTRUCTIONS.LOCK_LOTTERY, 0); // lock discriminator
+                buffer.writeUInt8(lock, 1); // write the new lock status
+                return buffer;
+            }
+            const lottery = new Lottery(this.connection, false, this.program);
+            const network = new LotteryNetwork(this.connection);
+            const [lotteryPDA] = await lottery.DeriveLotteryPDA(authority.publicKey, lotteryId);
+            const keys = [
+                { pubkey: authority.publicKey, isSigner: true, isWritable: false },
+                { pubkey: lotteryPDA, isSigner: false, isWritable: true },
+            ];
+            const ix = new TransactionInstruction({programId: this.program, keys, data: await lockData(lockState)});
+            const _tx_ = {};
+            _tx_.account = authority.publicKey.toString(); // string : required
+            _tx_.instructions = [ix];                      // array  : required
+            _tx_.signers = false;                          // array  : default false
+            _tx_.table = false;                            // array  : default false
+            _tx_.tolerance = 1.2;                          // int    : default 1.1    
+            _tx_.compute = true;                           // bool   : default true
+            _tx_.fees = true;                              // bool   : default true
+            _tx_.priority = "Low";                         // string : default Low
+            _tx_.memo = false;
+            if(encoded){
+                _tx_.serialize = true;                        
+                _tx_.encode = true;  
+            }
+            else{
+                _tx_.serialize = false;                        
+                _tx_.encode = false;  
+            }
+            const tx = await network.Tx(_tx_);             // build the tx
+            if(tx.status !== "ok"){return tx;}
+            if(authority.secretKey && !encoded){
+                tx.transaction.sign([authority]);
+                const sig = await network.Send(tx.transaction);
+                console.log("Signature:", sig);
+                const status = await network.Status(sig);
+                if(status == "finalized"){
+                    return await lottery.GetLottery({publicKey: authority.publicKey}, lotteryId, false);
+                }
+                else{return status;}
+            }
+            else{return tx;}           
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+
+}
+
+export {
+    Lottery,
+    LotteryNetwork,
+    LotteryManager
+}