@actuallyfair/verifier 0.0.3 → 0.0.5

package/src/generated/context/plinko.ts

@@ -2,13 +2,72 @@
 import _m0 from "protobufjs/minimal";
 import { Amount } from "../amount";
 
+export enum DuelPlinkoRisk {
+  DUEL_PLINKO_RISK_UNSPECIFIED = 0,
+  DUEL_PLINKO_RISK_LOW = 1,
+  DUEL_PLINKO_RISK_MEDIUM = 2,
+  DUEL_PLINKO_RISK_HIGH = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function duelPlinkoRiskFromJSON(object: any): DuelPlinkoRisk {
+  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;
+  }
+}
+
+export function duelPlinkoRiskToJSON(object: DuelPlinkoRisk): string {
+  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";
+  }
+}
+
 export interface Plinko {
   amount: Amount | undefined;
+  payouts: PlinkoPayouts | undefined;
+}
+
+export interface PlinkoPayouts {
+  custom?: CustomPlinkoPayouts | undefined;
+  duel?: DuelPlinkoPayouts | undefined;
+}
+
+export interface DuelPlinkoPayouts {
+  rows: number;
+  risk: DuelPlinkoRisk;
+}
+
+export interface CustomPlinkoPayouts {
   possibilities: number[];
 }
 
 function createBasePlinko(): Plinko {
-  return { amount: undefined, possibilities: [] };
+  return { amount: undefined, payouts: undefined };
 }
 
 export const Plinko = {
@@ -16,11 +75,9 @@ export const Plinko = {
     if (message.amount !== undefined) {
       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) {
+      PlinkoPayouts.encode(message.payouts, writer.uint32(18).fork()).ldelim();
     }
-    writer.ldelim();
     return writer;
   },
 
@@ -39,13 +96,235 @@ export const Plinko = {
           message.amount = Amount.decode(reader, reader.uint32());
           continue;
         case 2:
-          if (tag === 17) {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.payouts = PlinkoPayouts.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Plinko {
+    return {
+      amount: isSet(object.amount) ? Amount.fromJSON(object.amount) : undefined,
+      payouts: isSet(object.payouts) ? PlinkoPayouts.fromJSON(object.payouts) : undefined,
+    };
+  },
+
+  toJSON(message: Plinko): unknown {
+    const obj: any = {};
+    if (message.amount !== undefined) {
+      obj.amount = Amount.toJSON(message.amount);
+    }
+    if (message.payouts !== undefined) {
+      obj.payouts = PlinkoPayouts.toJSON(message.payouts);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Plinko>, I>>(base?: I): Plinko {
+    return Plinko.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Plinko>, I>>(object: I): Plinko {
+    const message = createBasePlinko();
+    message.amount = (object.amount !== undefined && object.amount !== null)
+      ? Amount.fromPartial(object.amount)
+      : undefined;
+    message.payouts = (object.payouts !== undefined && object.payouts !== null)
+      ? PlinkoPayouts.fromPartial(object.payouts)
+      : undefined;
+    return message;
+  },
+};
+
+function createBasePlinkoPayouts(): PlinkoPayouts {
+  return { custom: undefined, duel: undefined };
+}
+
+export const PlinkoPayouts = {
+  encode(message: PlinkoPayouts, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.custom !== undefined) {
+      CustomPlinkoPayouts.encode(message.custom, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.duel !== undefined) {
+      DuelPlinkoPayouts.encode(message.duel, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PlinkoPayouts {
+    const reader = input instanceof _m0.Reader ? input : _m0.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 = CustomPlinkoPayouts.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.duel = DuelPlinkoPayouts.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PlinkoPayouts {
+    return {
+      custom: isSet(object.custom) ? CustomPlinkoPayouts.fromJSON(object.custom) : undefined,
+      duel: isSet(object.duel) ? DuelPlinkoPayouts.fromJSON(object.duel) : undefined,
+    };
+  },
+
+  toJSON(message: PlinkoPayouts): unknown {
+    const obj: any = {};
+    if (message.custom !== undefined) {
+      obj.custom = CustomPlinkoPayouts.toJSON(message.custom);
+    }
+    if (message.duel !== undefined) {
+      obj.duel = DuelPlinkoPayouts.toJSON(message.duel);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PlinkoPayouts>, I>>(base?: I): PlinkoPayouts {
+    return PlinkoPayouts.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PlinkoPayouts>, I>>(object: I): PlinkoPayouts {
+    const message = createBasePlinkoPayouts();
+    message.custom = (object.custom !== undefined && object.custom !== null)
+      ? CustomPlinkoPayouts.fromPartial(object.custom)
+      : undefined;
+    message.duel = (object.duel !== undefined && object.duel !== null)
+      ? DuelPlinkoPayouts.fromPartial(object.duel)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseDuelPlinkoPayouts(): DuelPlinkoPayouts {
+  return { rows: 0, risk: 0 };
+}
+
+export const DuelPlinkoPayouts = {
+  encode(message: DuelPlinkoPayouts, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.rows !== 0) {
+      writer.uint32(8).uint32(message.rows);
+    }
+    if (message.risk !== 0) {
+      writer.uint32(16).int32(message.risk);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DuelPlinkoPayouts {
+    const reader = input instanceof _m0.Reader ? input : _m0.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() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DuelPlinkoPayouts {
+    return {
+      rows: isSet(object.rows) ? globalThis.Number(object.rows) : 0,
+      risk: isSet(object.risk) ? duelPlinkoRiskFromJSON(object.risk) : 0,
+    };
+  },
+
+  toJSON(message: DuelPlinkoPayouts): unknown {
+    const obj: any = {};
+    if (message.rows !== 0) {
+      obj.rows = Math.round(message.rows);
+    }
+    if (message.risk !== 0) {
+      obj.risk = duelPlinkoRiskToJSON(message.risk);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DuelPlinkoPayouts>, I>>(base?: I): DuelPlinkoPayouts {
+    return DuelPlinkoPayouts.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DuelPlinkoPayouts>, I>>(object: I): DuelPlinkoPayouts {
+    const message = createBaseDuelPlinkoPayouts();
+    message.rows = object.rows ?? 0;
+    message.risk = object.risk ?? 0;
+    return message;
+  },
+};
+
+function createBaseCustomPlinkoPayouts(): CustomPlinkoPayouts {
+  return { possibilities: [] };
+}
+
+export const CustomPlinkoPayouts = {
+  encode(message: CustomPlinkoPayouts, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.possibilities) {
+      writer.double(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CustomPlinkoPayouts {
+    const reader = input instanceof _m0.Reader ? input : _m0.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());
@@ -64,34 +343,27 @@ export const Plinko = {
     return message;
   },
 
-  fromJSON(object: any): Plinko {
+  fromJSON(object: any): CustomPlinkoPayouts {
     return {
-      amount: isSet(object.amount) ? Amount.fromJSON(object.amount) : undefined,
       possibilities: globalThis.Array.isArray(object?.possibilities)
         ? object.possibilities.map((e: any) => globalThis.Number(e))
         : [],
     };
   },
 
-  toJSON(message: Plinko): unknown {
+  toJSON(message: CustomPlinkoPayouts): unknown {
     const obj: any = {};
-    if (message.amount !== undefined) {
-      obj.amount = Amount.toJSON(message.amount);
-    }
     if (message.possibilities?.length) {
       obj.possibilities = message.possibilities;
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<Plinko>, I>>(base?: I): Plinko {
-    return Plinko.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<CustomPlinkoPayouts>, I>>(base?: I): CustomPlinkoPayouts {
+    return CustomPlinkoPayouts.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<Plinko>, I>>(object: I): Plinko {
-    const message = createBasePlinko();
-    message.amount = (object.amount !== undefined && object.amount !== null)
-      ? Amount.fromPartial(object.amount)
-      : undefined;
+  fromPartial<I extends Exact<DeepPartial<CustomPlinkoPayouts>, I>>(object: I): CustomPlinkoPayouts {
+    const message = createBaseCustomPlinkoPayouts();
     message.possibilities = object.possibilities?.map((e) => e) || [];
     return message;
   },

package/src/index.ts

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