feat: replace runvmArg and hash with uint for simplicity (#18)

Author: i582

src/generator/gen-constructors.ts

@@ -131,7 +131,6 @@ const generateArg = (arg: $.arg): t.TSType => {
         case "control":
         case "plduzArg":
         case "tinyInt":
-        case "runvmArg":
         case "minusOne":
         case "s1":
         case "setcpArg":
@@ -142,8 +141,6 @@ const generateArg = (arg: $.arg): t.TSType => {
             return t.tsBigIntKeyword()
         case "debugstr":
             return t.tsTypeReference(t.tsQualifiedName(TON_CORE_QUALIFIER, t.identifier("Slice")))
-        case "hash":
-            return t.tsTypeReference(t.tsQualifiedName(UTIL_QUALIFIER, t.identifier("Hash")))
         case "codeSlice":
             return t.tsTypeReference(t.tsQualifiedName(UTIL_QUALIFIER, t.identifier("Code")))
         case "refCodeSlice":

src/generator/gen-converter.ts

@@ -215,10 +215,8 @@ function isIntegerArg(arg: $.arg) {
         arg.$ === "uint" ||
         arg.$ === "plduzArg" ||
         arg.$ === "tinyInt" ||
-        arg.$ === "runvmArg" ||
         arg.$ === "minusOne" ||
         arg.$ === "delta" ||
-        arg.$ === "hash" || // TODO: separate type
         arg.$ === "setcpArg"
     )
 }

src/generator/gen-printer.ts

@@ -150,10 +150,8 @@ const generateArg = (name: string, arg: $.arg): t.Statement[] => {
         case "plduzArg":
         case "tinyInt":
         case "largeInt":
-        case "runvmArg":
         case "minusOne":
         case "setcpArg":
-        case "hash":
             return [writeToString(name)]
 
         case "delta":

src/generator/gen-types.ts

@@ -237,8 +237,6 @@ const generateArg = (arg: $.arg): t.Expression => {
             return t.memberExpression(UTIL_QUALIFIER, t.identifier("tinyInt"))
         case "largeInt":
             return t.memberExpression(UTIL_QUALIFIER, t.identifier("largeInt"))
-        case "runvmArg":
-            return t.memberExpression(UTIL_QUALIFIER, t.identifier("runvmArg"))
         case "minusOne":
             return t.memberExpression(UTIL_QUALIFIER, t.identifier("minusOne"))
         case "s1":
@@ -250,8 +248,6 @@ const generateArg = (arg: $.arg): t.Expression => {
                 t.numericLiteral(arg.delta),
                 generateArg(arg.arg),
             ])
-        case "hash":
-            return t.memberExpression(UTIL_QUALIFIER, t.identifier("hash"))
         case "codeSlice":
             return generateCodeSlice(arg)
         case "refCodeSlice":

src/generator/instructions.ts

@@ -7,8 +7,6 @@ export type arg =
     | plduzArg
     | tinyInt
     | largeInt
-    | runvmArg
-    | hash
     | minusOne
     | s1
     | setcpArg
@@ -62,12 +60,6 @@ export const s1: s1 = {$: "s1"}
 export type minusOne = {$: "minusOne"}
 export const minusOne: minusOne = {$: "minusOne"}
 
-export type runvmArg = {$: "runvmArg"}
-export const runvmArg: runvmArg = {$: "runvmArg"}
-
-export type hash = {$: "hash"}
-export const hash: hash = {$: "hash"}
-
 // special case: [-15, 239]
 export type setcpArg = {$: "setcpArg", range: range}
 export const setcpArg: setcpArg = {$: "setcpArg", range: range(-15n, 239n)}
@@ -374,6 +366,7 @@ const uint7 = uint(7, uint7range)
 const uint8 = uint(8, uint8range)
 const uint11 = uint(11, uint11range)
 const uint14 = uint(14, uint14range)
+const hash = uint(8, {min: 0n, max: 4n})
 
 export const instructions: Record<string, Opcode> = {
     PUSHNAN: cat("int_const", mksimple(0x83ff, 16, `exec_push_nan`)),
@@ -1177,7 +1170,7 @@ export const instructions: Record<string, Opcode> = {
     SAVEALTCTR: cat("continuation_change", mkfixedrangen(0xedb0, 0xedb8, 16, 4, seq(control), `exec_savealt_ctr`)),
     SAVEBOTHCTR: cat("continuation_change", mkfixedrangen(0xedc0, 0xedc8, 16, 4, seq(control), `exec_saveboth_ctr`)),
 
-    RUNVM: version(4, cat("continuation_jump", mkfixedn(0xdb4, 12, 12, seq(runvmArg), `exec_runvm`))),
+    RUNVM: version(4, cat("continuation_jump", mkfixedn(0xdb4, 12, 12, seq(uint(12, {min: 0n, max: 511n})), `exec_runvm`))),
 
     // special case: numeric
     "2SWAP": cat("stack", mksimple(0x5a, 8, `exec_2swap`)),

src/runtime/constructors.ts

@@ -6937,44 +6937,44 @@ export type LSHIFT_DIVMODC = {
     arg0: number
     loc: $.Loc | undefined
 }
-export const HASHEXT = (arg0: $.Hash, loc?: $.Loc): HASHEXT => ({
+export const HASHEXT = (arg0: number, loc?: $.Loc): HASHEXT => ({
     $: "HASHEXT",
     arg0,
     loc,
 })
 export type HASHEXT = {
     $: "HASHEXT"
-    arg0: $.Hash
+    arg0: number
     loc: $.Loc | undefined
 }
-export const HASHEXTR = (arg0: $.Hash, loc?: $.Loc): HASHEXTR => ({
+export const HASHEXTR = (arg0: number, loc?: $.Loc): HASHEXTR => ({
     $: "HASHEXTR",
     arg0,
     loc,
 })
 export type HASHEXTR = {
     $: "HASHEXTR"
-    arg0: $.Hash
+    arg0: number
     loc: $.Loc | undefined
 }
-export const HASHEXTA = (arg0: $.Hash, loc?: $.Loc): HASHEXTA => ({
+export const HASHEXTA = (arg0: number, loc?: $.Loc): HASHEXTA => ({
     $: "HASHEXTA",
     arg0,
     loc,
 })
 export type HASHEXTA = {
     $: "HASHEXTA"
-    arg0: $.Hash
+    arg0: number
     loc: $.Loc | undefined
 }
-export const HASHEXTAR = (arg0: $.Hash, loc?: $.Loc): HASHEXTAR => ({
+export const HASHEXTAR = (arg0: number, loc?: $.Loc): HASHEXTAR => ({
     $: "HASHEXTAR",
     arg0,
     loc,
 })
 export type HASHEXTAR = {
     $: "HASHEXTAR"
-    arg0: $.Hash
+    arg0: number
     loc: $.Loc | undefined
 }
 export const STREF = (loc?: $.Loc): STREF => ({

src/runtime/types.ts

@@ -7181,11 +7181,11 @@ export const SAVEBOTHCTR: $.Type<c.SAVEBOTHCTR> = {
 export const RUNVM: $.Type<c.RUNVM> = {
     load: s => {
         s.skip(12)
-        return c.RUNVM($.runvmArg.load(s))
+        return c.RUNVM($.uint(12).load(s))
     },
     store: (b, val, options) => {
         b.storeInstructionPrefix(3508, 12, val)
-        $.runvmArg.store(b, val.arg0, options)
+        $.uint(12).store(b, val.arg0, options)
     },
 }
 export const SWAP2: $.Type<c.SWAP2> = {
@@ -7587,41 +7587,41 @@ export const LSHIFT_DIVMODC: $.Type<c.LSHIFT_DIVMODC> = {
 export const HASHEXT: $.Type<c.HASHEXT> = {
     load: s => {
         s.skip(16)
-        return c.HASHEXT($.hash.load(s))
+        return c.HASHEXT($.uint(8).load(s))
     },
     store: (b, val, options) => {
         b.storeInstructionPrefix(63748, 16, val)
-        $.hash.store(b, val.arg0, options)
+        $.uint(8).store(b, val.arg0, options)
     },
 }
 export const HASHEXTR: $.Type<c.HASHEXTR> = {
     load: s => {
         s.skip(16)
-        return c.HASHEXTR($.hash.load(s))
+        return c.HASHEXTR($.uint(8).load(s))
     },
     store: (b, val, options) => {
         b.storeInstructionPrefix(63749, 16, val)
-        $.hash.store(b, val.arg0, options)
+        $.uint(8).store(b, val.arg0, options)
     },
 }
 export const HASHEXTA: $.Type<c.HASHEXTA> = {
     load: s => {
         s.skip(16)
-        return c.HASHEXTA($.hash.load(s))
+        return c.HASHEXTA($.uint(8).load(s))
     },
     store: (b, val, options) => {
         b.storeInstructionPrefix(63750, 16, val)
-        $.hash.store(b, val.arg0, options)
+        $.uint(8).store(b, val.arg0, options)
     },
 }
 export const HASHEXTAR: $.Type<c.HASHEXTAR> = {
     load: s => {
         s.skip(16)
-        return c.HASHEXTAR($.hash.load(s))
+        return c.HASHEXTAR($.uint(8).load(s))
     },
     store: (b, val, options) => {
         b.storeInstructionPrefix(63751, 16, val)
-        $.hash.store(b, val.arg0, options)
+        $.uint(8).store(b, val.arg0, options)
     },
 }
 export const STREF: $.Type<c.STREF> = {

src/runtime/util.ts

@@ -449,16 +449,9 @@ export const debugstr: Type<Slice> = {
     },
 }
 
-// TODO: revert
-export const refs = (count: number): number => {
-    return count
-}
-
 const uint3 = uint(3)
 const uint4 = uint(4)
 const uint5 = uint(5)
-const uint8 = uint(8)
-const uint12 = uint(12)
 
 export const control: Type<number> = {
     store: (b, t, options) => {
@@ -511,26 +504,6 @@ export const largeInt: Type<bigint> = {
     load: s => s.loadIntBig(3 + ((uint5.load(s) & 31) + 2) * 8),
 }
 
-// special case: RUNVM { ... }
-// +1 = same_c3 (set c3 to code)
-// +2 = push_0 (push an implicit 0 before running the code)
-// +4 = load c4 (persistent data) from stack and return its final value
-// +8 = load gas limit from stack and return consumed gas
-// +16 = load c7 (smart-contract context)
-// +32 = return c5 (actions)
-// +64 = pop hard gas limit (enabled by ACCEPT) from stack as well
-// +128 = isolated gas consumption (separate set of visited cells, reset chksgn counter)
-// +256 = pop number N, return exactly N values from stack (only if res=0 or 1; if not enough then res=stk_und)
-// if (mode >= 512) { throw new VmError(Excno.range_chk, "invalid flags"); }
-export type RunVmArg = number
-
-export const runvmArg: Type<RunVmArg> = {
-    store: (b, t, options) => {
-        uint12.store(b, t, options)
-    },
-    load: s => uint12.load(s),
-}
-
 // special case: CALLXARGS $ -1
 export const minusOne: Type<number> = {
     store: (_b, t, _options) => {
@@ -567,19 +540,6 @@ export const delta = (n: number, ty: Type<number>): Type<number> => ({
     load: s => ty.load(s) + n,
 })
 
-export const hash: Type<Hash> = {
-    store: (b, t, options) => {
-        uint8.store(b, t, options)
-    },
-    load: s => {
-        const r = uint8.load(s)
-        if (!(r in Hash)) {
-            throw new Error("Wrong hash")
-        }
-        return r
-    },
-}
-
 // TODO: slice
 export const PSEUDO_PUSHSLICE: Type<c.PSEUDO_PUSHSLICE> = {
     load: _s => {