@actuallyfair/verifier 0.0.3 → 0.0.5

package/dist/generated/context/plinko.js

@@ -3,23 +3,66 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Plinko = void 0;
+exports.CustomPlinkoPayouts = exports.DuelPlinkoPayouts = exports.PlinkoPayouts = exports.Plinko = exports.duelPlinkoRiskToJSON = exports.duelPlinkoRiskFromJSON = exports.DuelPlinkoRisk = 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) {
+    switch (object) {
+        case 0:
+        case "DUEL_PLINKO_RISK_UNSPECIFIED":
+            return DuelPlinkoRisk.DUEL_PLINKO_RISK_UNSPECIFIED;
+        case 1:
+        case "DUEL_PLINKO_RISK_LOW":
+            return DuelPlinkoRisk.DUEL_PLINKO_RISK_LOW;
+        case 2:
+        case "DUEL_PLINKO_RISK_MEDIUM":
+            return DuelPlinkoRisk.DUEL_PLINKO_RISK_MEDIUM;
+        case 3:
+        case "DUEL_PLINKO_RISK_HIGH":
+            return DuelPlinkoRisk.DUEL_PLINKO_RISK_HIGH;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return DuelPlinkoRisk.UNRECOGNIZED;
+    }
+}
+exports.duelPlinkoRiskFromJSON = duelPlinkoRiskFromJSON;
+function duelPlinkoRiskToJSON(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:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.duelPlinkoRiskToJSON = duelPlinkoRiskToJSON;
 function createBasePlinko() {
-    return { amount: undefined, possibilities: [] };
+    return { amount: undefined, payouts: undefined };
 }
 exports.Plinko = {
     encode(message, writer = minimal_1.default.Writer.create()) {
         if (message.amount !== undefined) {
             amount_1.Amount.encode(message.amount, writer.uint32(10).fork()).ldelim();
         }
-        writer.uint32(18).fork();
-        for (const v of message.possibilities) {
-            writer.double(v);
+        if (message.payouts !== undefined) {
+            exports.PlinkoPayouts.encode(message.payouts, writer.uint32(18).fork()).ldelim();
         }
-        writer.ldelim();
         return writer;
     },
     decode(input, length) {
@@ -36,11 +79,210 @@ exports.Plinko = {
                     message.amount = amount_1.Amount.decode(reader, reader.uint32());
                     continue;
                 case 2:
-                    if (tag === 17) {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.payouts = exports.PlinkoPayouts.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            amount: isSet(object.amount) ? amount_1.Amount.fromJSON(object.amount) : undefined,
+            payouts: isSet(object.payouts) ? exports.PlinkoPayouts.fromJSON(object.payouts) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.amount !== undefined) {
+            obj.amount = amount_1.Amount.toJSON(message.amount);
+        }
+        if (message.payouts !== undefined) {
+            obj.payouts = exports.PlinkoPayouts.toJSON(message.payouts);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Plinko.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePlinko();
+        message.amount = (object.amount !== undefined && object.amount !== null)
+            ? amount_1.Amount.fromPartial(object.amount)
+            : undefined;
+        message.payouts = (object.payouts !== undefined && object.payouts !== null)
+            ? exports.PlinkoPayouts.fromPartial(object.payouts)
+            : undefined;
+        return message;
+    },
+};
+function createBasePlinkoPayouts() {
+    return { custom: undefined, duel: 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();
+        }
+        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 = createBasePlinkoPayouts();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.custom = exports.CustomPlinkoPayouts.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.duel = exports.DuelPlinkoPayouts.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            custom: isSet(object.custom) ? exports.CustomPlinkoPayouts.fromJSON(object.custom) : undefined,
+            duel: isSet(object.duel) ? exports.DuelPlinkoPayouts.fromJSON(object.duel) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.custom !== undefined) {
+            obj.custom = exports.CustomPlinkoPayouts.toJSON(message.custom);
+        }
+        if (message.duel !== undefined) {
+            obj.duel = exports.DuelPlinkoPayouts.toJSON(message.duel);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PlinkoPayouts.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePlinkoPayouts();
+        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;
+        return message;
+    },
+};
+function createBaseCustomPlinkoPayouts() {
+    return { possibilities: [] };
+}
+exports.CustomPlinkoPayouts = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.possibilities) {
+            writer.double(v);
+        }
+        writer.ldelim();
+        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 = createBaseCustomPlinkoPayouts();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag === 9) {
                         message.possibilities.push(reader.double());
                         continue;
                     }
-                    if (tag === 18) {
+                    if (tag === 10) {
                         const end2 = reader.uint32() + reader.pos;
                         while (reader.pos < end2) {
                             message.possibilities.push(reader.double());
@@ -58,7 +300,6 @@ exports.Plinko = {
     },
     fromJSON(object) {
         return {
-            amount: isSet(object.amount) ? amount_1.Amount.fromJSON(object.amount) : undefined,
             possibilities: globalThis.Array.isArray(object?.possibilities)
                 ? object.possibilities.map((e) => globalThis.Number(e))
                 : [],
@@ -66,22 +307,16 @@ exports.Plinko = {
     },
     toJSON(message) {
         const obj = {};
-        if (message.amount !== undefined) {
-            obj.amount = amount_1.Amount.toJSON(message.amount);
-        }
         if (message.possibilities?.length) {
             obj.possibilities = message.possibilities;
         }
         return obj;
     },
     create(base) {
-        return exports.Plinko.fromPartial(base ?? {});
+        return exports.CustomPlinkoPayouts.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBasePlinko();
-        message.amount = (object.amount !== undefined && object.amount !== null)
-            ? amount_1.Amount.fromPartial(object.amount)
-            : undefined;
+        const message = createBaseCustomPlinkoPayouts();
         message.possibilities = object.possibilities?.map((e) => e) || [];
         return message;
     },

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export * from "./generated/context/tower";
 export * from "./generated/context/plinko";
 export * from "./format-amount";
 export * from "./compute-wager";
+export * from "./duel-plinko-payouts";

package/dist/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./generated/context/tower"), exports);
 __exportStar(require("./generated/context/plinko"), exports);
 __exportStar(require("./format-amount"), exports);
 __exportStar(require("./compute-wager"), exports);
+__exportStar(require("./duel-plinko-payouts"), exports);

package/package.json

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

package/protobuf/context/plinko.proto

@@ -3,5 +3,28 @@ import "amount.proto";
 
 message Plinko {
   Amount amount = 1;
-  repeated double possibilities = 2;
-}
+  PlinkoPayouts payouts = 2;
+}
+
+message PlinkoPayouts {
+  oneof payout_table {
+    CustomPlinkoPayouts custom = 1;
+    DuelPlinkoPayouts duel = 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;
+}

package/src/compute-wager.ts

@@ -14,6 +14,7 @@ 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) {
@@ -279,7 +280,7 @@ export function computePlinkoResult(
   clientSeed: string,
   bet: Plinko
 ): PlinkoResult {
-  const possibilities = bet.possibilities;
+  const possibilities = resolvePlinkoPayouts(bet);
   if (possibilities.length < 2) {
     throw new Error("invalid possibilities ");
   }
@@ -297,6 +298,20 @@ export function computePlinkoResult(
   };
 }
 
+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);