@actuallyfair/verifier 0.0.5 → 0.0.6

package/dist/generated/context/plinko.js

@@ -3,55 +3,199 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomPlinkoPayouts = exports.DuelPlinkoPayouts = exports.PlinkoPayouts = exports.Plinko = exports.duelPlinkoRiskToJSON = exports.duelPlinkoRiskFromJSON = exports.DuelPlinkoRisk = void 0;
+exports.CustomPlinkoPayouts = exports.PlinkoPayouts = exports.Plinko = exports.plinkoPayoutTableToJSON = exports.plinkoPayoutTableFromJSON = exports.PlinkoPayoutTable = void 0;
 /* eslint-disable */
 const minimal_1 = __importDefault(require("protobufjs/minimal"));
 const amount_1 = require("../amount");
-var DuelPlinkoRisk;
-(function (DuelPlinkoRisk) {
-    DuelPlinkoRisk[DuelPlinkoRisk["DUEL_PLINKO_RISK_UNSPECIFIED"] = 0] = "DUEL_PLINKO_RISK_UNSPECIFIED";
-    DuelPlinkoRisk[DuelPlinkoRisk["DUEL_PLINKO_RISK_LOW"] = 1] = "DUEL_PLINKO_RISK_LOW";
-    DuelPlinkoRisk[DuelPlinkoRisk["DUEL_PLINKO_RISK_MEDIUM"] = 2] = "DUEL_PLINKO_RISK_MEDIUM";
-    DuelPlinkoRisk[DuelPlinkoRisk["DUEL_PLINKO_RISK_HIGH"] = 3] = "DUEL_PLINKO_RISK_HIGH";
-    DuelPlinkoRisk[DuelPlinkoRisk["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
-})(DuelPlinkoRisk || (exports.DuelPlinkoRisk = DuelPlinkoRisk = {}));
-function duelPlinkoRiskFromJSON(object) {
+var PlinkoPayoutTable;
+(function (PlinkoPayoutTable) {
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_UNSPECIFIED"] = 0] = "PLINKO_PAYOUT_TABLE_UNSPECIFIED";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_8_LOW"] = 1] = "PLINKO_PAYOUT_TABLE_DUEL_8_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM"] = 2] = "PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_8_HIGH"] = 3] = "PLINKO_PAYOUT_TABLE_DUEL_8_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_9_LOW"] = 4] = "PLINKO_PAYOUT_TABLE_DUEL_9_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM"] = 5] = "PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_9_HIGH"] = 6] = "PLINKO_PAYOUT_TABLE_DUEL_9_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_10_LOW"] = 7] = "PLINKO_PAYOUT_TABLE_DUEL_10_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM"] = 8] = "PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_10_HIGH"] = 9] = "PLINKO_PAYOUT_TABLE_DUEL_10_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_11_LOW"] = 10] = "PLINKO_PAYOUT_TABLE_DUEL_11_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM"] = 11] = "PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_11_HIGH"] = 12] = "PLINKO_PAYOUT_TABLE_DUEL_11_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_12_LOW"] = 13] = "PLINKO_PAYOUT_TABLE_DUEL_12_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM"] = 14] = "PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_12_HIGH"] = 15] = "PLINKO_PAYOUT_TABLE_DUEL_12_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_13_LOW"] = 16] = "PLINKO_PAYOUT_TABLE_DUEL_13_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM"] = 17] = "PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_13_HIGH"] = 18] = "PLINKO_PAYOUT_TABLE_DUEL_13_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_14_LOW"] = 19] = "PLINKO_PAYOUT_TABLE_DUEL_14_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM"] = 20] = "PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_14_HIGH"] = 21] = "PLINKO_PAYOUT_TABLE_DUEL_14_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_15_LOW"] = 22] = "PLINKO_PAYOUT_TABLE_DUEL_15_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM"] = 23] = "PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_15_HIGH"] = 24] = "PLINKO_PAYOUT_TABLE_DUEL_15_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_16_LOW"] = 25] = "PLINKO_PAYOUT_TABLE_DUEL_16_LOW";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM"] = 26] = "PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM";
+    PlinkoPayoutTable[PlinkoPayoutTable["PLINKO_PAYOUT_TABLE_DUEL_16_HIGH"] = 27] = "PLINKO_PAYOUT_TABLE_DUEL_16_HIGH";
+    PlinkoPayoutTable[PlinkoPayoutTable["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(PlinkoPayoutTable || (exports.PlinkoPayoutTable = PlinkoPayoutTable = {}));
+function plinkoPayoutTableFromJSON(object) {
     switch (object) {
         case 0:
-        case "DUEL_PLINKO_RISK_UNSPECIFIED":
-            return DuelPlinkoRisk.DUEL_PLINKO_RISK_UNSPECIFIED;
+        case "PLINKO_PAYOUT_TABLE_UNSPECIFIED":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_UNSPECIFIED;
         case 1:
-        case "DUEL_PLINKO_RISK_LOW":
-            return DuelPlinkoRisk.DUEL_PLINKO_RISK_LOW;
+        case "PLINKO_PAYOUT_TABLE_DUEL_8_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_LOW;
         case 2:
-        case "DUEL_PLINKO_RISK_MEDIUM":
-            return DuelPlinkoRisk.DUEL_PLINKO_RISK_MEDIUM;
+        case "PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM;
         case 3:
-        case "DUEL_PLINKO_RISK_HIGH":
-            return DuelPlinkoRisk.DUEL_PLINKO_RISK_HIGH;
+        case "PLINKO_PAYOUT_TABLE_DUEL_8_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_HIGH;
+        case 4:
+        case "PLINKO_PAYOUT_TABLE_DUEL_9_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_LOW;
+        case 5:
+        case "PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM;
+        case 6:
+        case "PLINKO_PAYOUT_TABLE_DUEL_9_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_HIGH;
+        case 7:
+        case "PLINKO_PAYOUT_TABLE_DUEL_10_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_LOW;
+        case 8:
+        case "PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM;
+        case 9:
+        case "PLINKO_PAYOUT_TABLE_DUEL_10_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_HIGH;
+        case 10:
+        case "PLINKO_PAYOUT_TABLE_DUEL_11_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_LOW;
+        case 11:
+        case "PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM;
+        case 12:
+        case "PLINKO_PAYOUT_TABLE_DUEL_11_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_HIGH;
+        case 13:
+        case "PLINKO_PAYOUT_TABLE_DUEL_12_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_LOW;
+        case 14:
+        case "PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM;
+        case 15:
+        case "PLINKO_PAYOUT_TABLE_DUEL_12_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_HIGH;
+        case 16:
+        case "PLINKO_PAYOUT_TABLE_DUEL_13_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_LOW;
+        case 17:
+        case "PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM;
+        case 18:
+        case "PLINKO_PAYOUT_TABLE_DUEL_13_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_HIGH;
+        case 19:
+        case "PLINKO_PAYOUT_TABLE_DUEL_14_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_LOW;
+        case 20:
+        case "PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM;
+        case 21:
+        case "PLINKO_PAYOUT_TABLE_DUEL_14_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_HIGH;
+        case 22:
+        case "PLINKO_PAYOUT_TABLE_DUEL_15_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_LOW;
+        case 23:
+        case "PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM;
+        case 24:
+        case "PLINKO_PAYOUT_TABLE_DUEL_15_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_HIGH;
+        case 25:
+        case "PLINKO_PAYOUT_TABLE_DUEL_16_LOW":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_LOW;
+        case 26:
+        case "PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM;
+        case 27:
+        case "PLINKO_PAYOUT_TABLE_DUEL_16_HIGH":
+            return PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_HIGH;
         case -1:
         case "UNRECOGNIZED":
         default:
-            return DuelPlinkoRisk.UNRECOGNIZED;
+            return PlinkoPayoutTable.UNRECOGNIZED;
     }
 }
-exports.duelPlinkoRiskFromJSON = duelPlinkoRiskFromJSON;
-function duelPlinkoRiskToJSON(object) {
+exports.plinkoPayoutTableFromJSON = plinkoPayoutTableFromJSON;
+function plinkoPayoutTableToJSON(object) {
     switch (object) {
-        case DuelPlinkoRisk.DUEL_PLINKO_RISK_UNSPECIFIED:
-            return "DUEL_PLINKO_RISK_UNSPECIFIED";
-        case DuelPlinkoRisk.DUEL_PLINKO_RISK_LOW:
-            return "DUEL_PLINKO_RISK_LOW";
-        case DuelPlinkoRisk.DUEL_PLINKO_RISK_MEDIUM:
-            return "DUEL_PLINKO_RISK_MEDIUM";
-        case DuelPlinkoRisk.DUEL_PLINKO_RISK_HIGH:
-            return "DUEL_PLINKO_RISK_HIGH";
-        case DuelPlinkoRisk.UNRECOGNIZED:
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_UNSPECIFIED:
+            return "PLINKO_PAYOUT_TABLE_UNSPECIFIED";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_8_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_8_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_8_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_9_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_9_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_9_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_10_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_10_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_10_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_11_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_11_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_11_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_12_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_12_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_12_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_13_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_13_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_13_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_14_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_14_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_14_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_15_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_15_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_15_HIGH";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_LOW:
+            return "PLINKO_PAYOUT_TABLE_DUEL_16_LOW";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM:
+            return "PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM";
+        case PlinkoPayoutTable.PLINKO_PAYOUT_TABLE_DUEL_16_HIGH:
+            return "PLINKO_PAYOUT_TABLE_DUEL_16_HIGH";
+        case PlinkoPayoutTable.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
     }
 }
-exports.duelPlinkoRiskToJSON = duelPlinkoRiskToJSON;
+exports.plinkoPayoutTableToJSON = plinkoPayoutTableToJSON;
 function createBasePlinko() {
     return { amount: undefined, payouts: undefined };
 }
@@ -123,15 +267,15 @@ exports.Plinko = {
     },
 };
 function createBasePlinkoPayouts() {
-    return { custom: undefined, duel: undefined };
+    return { custom: undefined, table: undefined };
 }
 exports.PlinkoPayouts = {
     encode(message, writer = minimal_1.default.Writer.create()) {
         if (message.custom !== undefined) {
             exports.CustomPlinkoPayouts.encode(message.custom, writer.uint32(10).fork()).ldelim();
         }
-        if (message.duel !== undefined) {
-            exports.DuelPlinkoPayouts.encode(message.duel, writer.uint32(18).fork()).ldelim();
+        if (message.table !== undefined) {
+            writer.uint32(16).int32(message.table);
         }
         return writer;
     },
@@ -149,10 +293,10 @@ exports.PlinkoPayouts = {
                     message.custom = exports.CustomPlinkoPayouts.decode(reader, reader.uint32());
                     continue;
                 case 2:
-                    if (tag !== 18) {
+                    if (tag !== 16) {
                         break;
                     }
-                    message.duel = exports.DuelPlinkoPayouts.decode(reader, reader.uint32());
+                    message.table = reader.int32();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -165,7 +309,7 @@ exports.PlinkoPayouts = {
     fromJSON(object) {
         return {
             custom: isSet(object.custom) ? exports.CustomPlinkoPayouts.fromJSON(object.custom) : undefined,
-            duel: isSet(object.duel) ? exports.DuelPlinkoPayouts.fromJSON(object.duel) : undefined,
+            table: isSet(object.table) ? plinkoPayoutTableFromJSON(object.table) : undefined,
         };
     },
     toJSON(message) {
@@ -173,8 +317,8 @@ exports.PlinkoPayouts = {
         if (message.custom !== undefined) {
             obj.custom = exports.CustomPlinkoPayouts.toJSON(message.custom);
         }
-        if (message.duel !== undefined) {
-            obj.duel = exports.DuelPlinkoPayouts.toJSON(message.duel);
+        if (message.table !== undefined) {
+            obj.table = plinkoPayoutTableToJSON(message.table);
         }
         return obj;
     },
@@ -186,75 +330,7 @@ exports.PlinkoPayouts = {
         message.custom = (object.custom !== undefined && object.custom !== null)
             ? exports.CustomPlinkoPayouts.fromPartial(object.custom)
             : undefined;
-        message.duel = (object.duel !== undefined && object.duel !== null)
-            ? exports.DuelPlinkoPayouts.fromPartial(object.duel)
-            : undefined;
-        return message;
-    },
-};
-function createBaseDuelPlinkoPayouts() {
-    return { rows: 0, risk: 0 };
-}
-exports.DuelPlinkoPayouts = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.rows !== 0) {
-            writer.uint32(8).uint32(message.rows);
-        }
-        if (message.risk !== 0) {
-            writer.uint32(16).int32(message.risk);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseDuelPlinkoPayouts();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 8) {
-                        break;
-                    }
-                    message.rows = reader.uint32();
-                    continue;
-                case 2:
-                    if (tag !== 16) {
-                        break;
-                    }
-                    message.risk = reader.int32();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            rows: isSet(object.rows) ? globalThis.Number(object.rows) : 0,
-            risk: isSet(object.risk) ? duelPlinkoRiskFromJSON(object.risk) : 0,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.rows !== 0) {
-            obj.rows = Math.round(message.rows);
-        }
-        if (message.risk !== 0) {
-            obj.risk = duelPlinkoRiskToJSON(message.risk);
-        }
-        return obj;
-    },
-    create(base) {
-        return exports.DuelPlinkoPayouts.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBaseDuelPlinkoPayouts();
-        message.rows = object.rows ?? 0;
-        message.risk = object.risk ?? 0;
+        message.table = object.table ?? undefined;
         return message;
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actuallyfair/verifier",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/protobuf/context/plinko.proto

@@ -9,22 +9,41 @@ message Plinko {
 message PlinkoPayouts {
   oneof payout_table {
     CustomPlinkoPayouts custom = 1;
-    DuelPlinkoPayouts duel = 2;
+    PlinkoPayoutTable table = 2;
   }
 }
 
-message DuelPlinkoPayouts {
-  uint32 rows = 1;
-  DuelPlinkoRisk risk = 2;
-}
-
 message CustomPlinkoPayouts {
   repeated double possibilities = 1;
 }
 
-enum DuelPlinkoRisk {
-  DUEL_PLINKO_RISK_UNSPECIFIED = 0;
-  DUEL_PLINKO_RISK_LOW = 1;
-  DUEL_PLINKO_RISK_MEDIUM = 2;
-  DUEL_PLINKO_RISK_HIGH = 3;
+enum PlinkoPayoutTable {
+  PLINKO_PAYOUT_TABLE_UNSPECIFIED = 0;
+  PLINKO_PAYOUT_TABLE_DUEL_8_LOW = 1;
+  PLINKO_PAYOUT_TABLE_DUEL_8_MEDIUM = 2;
+  PLINKO_PAYOUT_TABLE_DUEL_8_HIGH = 3;
+  PLINKO_PAYOUT_TABLE_DUEL_9_LOW = 4;
+  PLINKO_PAYOUT_TABLE_DUEL_9_MEDIUM = 5;
+  PLINKO_PAYOUT_TABLE_DUEL_9_HIGH = 6;
+  PLINKO_PAYOUT_TABLE_DUEL_10_LOW = 7;
+  PLINKO_PAYOUT_TABLE_DUEL_10_MEDIUM = 8;
+  PLINKO_PAYOUT_TABLE_DUEL_10_HIGH = 9;
+  PLINKO_PAYOUT_TABLE_DUEL_11_LOW = 10;
+  PLINKO_PAYOUT_TABLE_DUEL_11_MEDIUM = 11;
+  PLINKO_PAYOUT_TABLE_DUEL_11_HIGH = 12;
+  PLINKO_PAYOUT_TABLE_DUEL_12_LOW = 13;
+  PLINKO_PAYOUT_TABLE_DUEL_12_MEDIUM = 14;
+  PLINKO_PAYOUT_TABLE_DUEL_12_HIGH = 15;
+  PLINKO_PAYOUT_TABLE_DUEL_13_LOW = 16;
+  PLINKO_PAYOUT_TABLE_DUEL_13_MEDIUM = 17;
+  PLINKO_PAYOUT_TABLE_DUEL_13_HIGH = 18;
+  PLINKO_PAYOUT_TABLE_DUEL_14_LOW = 19;
+  PLINKO_PAYOUT_TABLE_DUEL_14_MEDIUM = 20;
+  PLINKO_PAYOUT_TABLE_DUEL_14_HIGH = 21;
+  PLINKO_PAYOUT_TABLE_DUEL_15_LOW = 22;
+  PLINKO_PAYOUT_TABLE_DUEL_15_MEDIUM = 23;
+  PLINKO_PAYOUT_TABLE_DUEL_15_HIGH = 24;
+  PLINKO_PAYOUT_TABLE_DUEL_16_LOW = 25;
+  PLINKO_PAYOUT_TABLE_DUEL_16_MEDIUM = 26;
+  PLINKO_PAYOUT_TABLE_DUEL_16_HIGH = 27;
 }

package/src/compute-wager.ts

@@ -14,8 +14,6 @@ import {
 import { bytesToHex } from "@noble/hashes/utils";
 import { CrashDice } from "./generated/context/crash-dice";
 import { MultiRoulette } from "./generated/context/multi-roulette";
-import { getDuelPlinkoPayoutsFromEnum } from "./duel-plinko-payouts";
-import { Plinko } from "./generated/context/plinko";
 
 export function computeFairCoinTossResult(sig: Uint8Array) {
   // We're going to hash the signature just to really be sure its fairly distributed
@@ -61,11 +59,11 @@ function doComputeCrashResult(hash: Uint8Array, houseEdge: number) {
 }
 
 export function computeCrashResult(
-  vxSignature: Uint8Array,
+  hash: Uint8Array,
   gameHash: Uint8Array, // This is the hash of the next from the hash chain
   houseEdge: number = 0
 ) {
-  return doComputeCrashResult(hmac(sha256, vxSignature, gameHash), houseEdge);
+  return doComputeCrashResult(hmac(sha256, hash, gameHash), houseEdge);
 }
 
 export type CrashDiceOutcome = {
@@ -96,13 +94,13 @@ export function computeCrashDiceOutcome(
 
 // returns the index of which roulette outcome was picked
 export function computeMultiRouletteResult(
-  vxSignature: Uint8Array,
+  hash: Uint8Array,
   bet: MultiRoulette
 ) {
-  const hash = sha256(vxSignature);
+  const seedHash = sha256(hash);
 
   const nBits = 52;
-  const hashHex = bytesToHex(hash);
+  const hashHex = bytesToHex(seedHash);
   const seed = hashHex.slice(0, nBits / 4);
   const n = Number.parseInt(seed, 16);
 
@@ -119,7 +117,7 @@ export function computeMultiRouletteResult(
 }
 
 export function computeMineLocations(
-  vxSignature: Uint8Array,
+  hash: Uint8Array,
   revealedCells: Set<number>, // tiles we know are safe
   cells: number, // how many cells in total
   mines: number // how many mines there are going to be in total
@@ -136,7 +134,7 @@ export function computeMineLocations(
       break;
     }
 
-    let mineIndex = Number(bytesToNumberBE(vxSignature) % BigInt(cellsLeft));
+    let mineIndex = Number(bytesToNumberBE(hash) % BigInt(cellsLeft));
     let adjustedIndex = 0;
 
     for (let i = 0; i < cells; i++) {
@@ -211,7 +209,7 @@ export function computePinkoPossibilityIndexFromPath(path: PlinkoPath) {
 // return a path (saying 'L' or 'R', where 'L' means go left, and 'R' means going right)
 //  of possibilities-1 length
 export function computePlinkoPath(
-  vxSignature: Uint8Array,
+  hash: Uint8Array,
   possibilities: number
 ): PlinkoPath {
   if (
@@ -221,9 +219,9 @@ export function computePlinkoPath(
   ) {
     throw new Error("invalid possibilities ");
   }
-  const hash = sha256(vxSignature);
+  const pathHash = sha256(hash);
 
-  let n = bytesToNumberBE(hash);
+  let n = bytesToNumberBE(pathHash);
 
   let ret: ("L" | "R")[] = [];
   for (let i = 0; i < possibilities - 1; i++) {
@@ -259,12 +257,12 @@ export function computePlinkoPascalsProbabilities(rowNumber: number) {
   return lastRow.map((v) => v / sum);
 }
 
-export function computePlinkoHouseEdge(possibilities: number[]) {
-  const odds = computePlinkoPascalsProbabilities(possibilities.length);
+export function computePlinkoHouseEdge(payouts: number[]) {
+  const odds = computePlinkoPascalsProbabilities(payouts.length);
 
   let ev = 1; // you start off by betting everything
-  for (let i = 0; i < possibilities.length; i++) {
-    ev -= possibilities[i] * odds[i];
+  for (let i = 0; i < payouts.length; i++) {
+    ev -= payouts[i] * odds[i];
   }
   return ev;
 }
@@ -272,46 +270,29 @@ export function computePlinkoHouseEdge(possibilities: number[]) {
 export type PlinkoResult = {
   slot: number;
   multiplier: number;
-  win: boolean;
 };
 
 export function computePlinkoResult(
   hash: Uint8Array,
   clientSeed: string,
-  bet: Plinko
+  payouts: number[]
 ): PlinkoResult {
-  const possibilities = resolvePlinkoPayouts(bet);
-  if (possibilities.length < 2) {
+  if (payouts.length < 2) {
     throw new Error("invalid possibilities ");
   }
 
-  const probabilities = computePlinkoPascalsProbabilities(possibilities.length);
+  const probabilities = computePlinkoPascalsProbabilities(payouts.length);
   const rollHash = hmacSha256(hash, clientSeed);
   const roll = uniformFromHash(rollHash);
   const slot = pickSlot(probabilities, roll);
-  const multiplier = possibilities[slot] ?? 0;
+  const multiplier = payouts[slot] ?? 0;
 
   return {
     slot,
     multiplier,
-    win: multiplier >= 1,
   };
 }
 
-function resolvePlinkoPayouts(bet: Plinko): number[] {
-  const payouts = bet.payouts;
-  if (!payouts) {
-    return [];
-  }
-  if (payouts.duel) {
-    return getDuelPlinkoPayoutsFromEnum(payouts.duel.rows, payouts.duel.risk);
-  }
-  if (payouts.custom) {
-    return payouts.custom.possibilities;
-  }
-  return [];
-}
-
 function hmacSha256(key: Uint8Array, message: string): Uint8Array {
   const data = new TextEncoder().encode(message);
   return hmac(sha256, key, data);