feat: new functions in stdlib from stdlib.fc and math.fc

CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Docs: `preloadRef` method for the `Slice` type: PR [#1044](https://github.com/tact-lang/tact/pull/1044)
 - Docs: added DeDust cookbook: PR [#954](https://github.com/tact-lang/tact/pull/954)
 - Docs: described the limit for deeply nested expressions: PR [#1101](https://github.com/tact-lang/tact/pull/1101)
+- New functions in stdlib from `stdlib.fc` and `math.fc`: `Builder.depth`, `Slice.skipLastBits`, `Slice.firstBits`, `Slice.lastBits`, `Slice.depth`, `Cell.computeDataSize`, `Slice.computeDataSize`, `Cell.depth`, `curLt`, `blockLt`, `setGasLimit`, `getSeed`, `setSeed`, `myCode`, `sign`, `divc`, `muldivc`, `mulShiftRight`, `mulShiftRightRound`, `mulShiftRightCeil`, `sqrt`, `addressNone`: PR [#986](https://github.com/tact-lang/tact/pull/986)
 
 ### Changed
 

cspell.json

@@ -73,6 +73,7 @@
     "minmax",
     "mintable",
     "mktemp",
+    "muldivc",
     "multiformats",
     "nanotons",
     "Neovim",

src/test/e2e-emulated/__snapshots__/local-type-inference.spec.ts.snap

@@ -321,6 +321,39 @@ exports[`local-type-inference should automatically set types for let statements
     },
   ],
   "types": [
+    {
+      "fields": [
+        {
+          "name": "cells",
+          "type": {
+            "format": 257,
+            "kind": "simple",
+            "optional": false,
+            "type": "int",
+          },
+        },
+        {
+          "name": "bits",
+          "type": {
+            "format": 257,
+            "kind": "simple",
+            "optional": false,
+            "type": "int",
+          },
+        },
+        {
+          "name": "refs",
+          "type": {
+            "format": 257,
+            "kind": "simple",
+            "optional": false,
+            "type": "int",
+          },
+        },
+      ],
+      "header": null,
+      "name": "DataSize",
+    },
     {
       "fields": [
         {

src/test/e2e-emulated/contracts/math.tact

@@ -426,4 +426,32 @@ contract MathTester with Deployable {
         a >>= b;
         return a;
     }
+
+    get fun sign(x: Int): Int {
+        return sign(x);
+    }
+
+    get fun divc(x: Int, y: Int): Int {
+        return divc(x, y);
+    }
+
+    get fun muldivc(x: Int, y: Int, z: Int): Int {
+        return muldivc(x, y, z);
+    }
+
+    get fun mulShiftRight(x: Int, y: Int, z: Int): Int {
+        return mulShiftRight(x, y, z);
+    }
+
+    get fun mulShiftRightRound(x: Int, y: Int, z: Int): Int {
+        return mulShiftRightRound(x, y, z);
+    }
+
+    get fun mulShiftRightCeil(x: Int, y: Int, z: Int): Int {
+        return mulShiftRightCeil(x, y, z);
+    }
+
+    get fun sqrt(x: Int): Int {
+        return sqrt(x);
+    }
 }

src/test/e2e-emulated/contracts/stdlib.tact

@@ -58,4 +58,70 @@ contract StdlibTest {
     get fun parseVarAddress(slice: Slice): VarAddress {
         return parseVarAddress(slice);
     }
-}
+
+    get fun builderDepth(bl: Builder): Int {
+        return bl.depth();
+    }
+
+    get fun skipLastBits(sc: Slice, n: Int): Slice {
+        return sc.skipLastBits(n);
+    }
+
+    get fun firstBits(sc: Slice, n: Int): Slice {
+        return sc.firstBits(n);
+    }
+
+    get fun lastBits(sc: Slice, n: Int): Slice {
+        return sc.lastBits(n);
+    }
+
+    get fun sliceDepth(sc: Slice): Int {
+        return sc.depth();
+    }
+
+    get fun addressNone(): Address? {
+        return addressNone();
+    }
+
+    get fun computeDataSizeCell(c: Cell, maxCells: Int): DataSize {
+        return c.computeDataSize(maxCells);
+    }
+
+    get fun computeDataSizeSlice(sc: Slice, maxCells: Int): DataSize {
+        return sc.computeDataSize(maxCells);
+    }
+
+    get fun cellDepth(c: Cell): Int {
+        return c.depth();
+    }
+
+    get fun curLt(): Int {
+        return curLt();
+    }
+
+    get fun blockLt(): Int {
+        return blockLt();
+    }
+
+    get fun setGasLimit(gl: Int): Int {
+        setGasLimit(gl);
+        let x = 0;
+        repeat (100) {
+            x += 1;
+        }
+        return gasConsumed();
+    }
+
+    get fun getSeed(): Int {
+        return getSeed();
+    }
+
+    get fun setSeed(seed: Int): Int {
+        setSeed(seed);
+        return getSeed();
+    }
+
+    get fun myCode(): Cell {
+        return myCode();
+    }
+}

src/test/e2e-emulated/math.spec.ts

@@ -507,5 +507,63 @@ describe("math", () => {
         expect(await contract.getAugmentedShiftRight(2n, 1n)).toBe(1n);
         expect(await contract.getAugmentedShiftRight(4n, 2n)).toBe(1n);
         expect(await contract.getAugmentedShiftRight(16n, 3n)).toBe(2n);
+
+        // sign
+        expect(await contract.getSign(123n)).toBe(1n);
+        expect(await contract.getSign(-123n)).toBe(-1n);
+        expect(await contract.getSign(0n)).toBe(0n);
+
+        // divc: ceil(x/y)
+        expect(await contract.getDivc(123n, 123n)).toBe(1n);
+        expect(await contract.getDivc(123n, 124n)).toBe(1n);
+        expect(await contract.getDivc(0n, 123n)).toBe(0n);
+        expect(await contract.getDivc(123n, 122n)).toBe(2n);
+
+        // muldivc: ceil(x*y/z)
+        expect(await contract.getMuldivc(123n, 123n, 123n)).toBe(123n);
+        expect(await contract.getMuldivc(100n, 100n, 10001n)).toBe(1n);
+        expect(await contract.getMuldivc(100n, 100n, 10000n)).toBe(1n);
+        expect(await contract.getMuldivc(100n, 100n, 9999n)).toBe(2n);
+        expect(await contract.getMuldivc(100n, 0n, 1n)).toBe(0n);
+
+        // mulShiftRight: floor(x*y/2^z)
+        expect(await contract.getMulShiftRight(2n, 4n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRight(2n, 4n, 2n)).toBe(2n);
+        expect(await contract.getMulShiftRight(2n, 4n, 1n)).toBe(4n);
+        expect(await contract.getMulShiftRight(2n, 4n, 0n)).toBe(8n);
+        expect(await contract.getMulShiftRight(1n, 6n, 0n)).toBe(6n);
+        expect(await contract.getMulShiftRight(1n, 6n, 3n)).toBe(0n);
+
+        // mulShiftRightRound: round(x*y/2^z)
+        expect(await contract.getMulShiftRightRound(2n, 4n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRightRound(2n, 4n, 2n)).toBe(2n);
+        expect(await contract.getMulShiftRightRound(2n, 4n, 1n)).toBe(4n);
+        expect(await contract.getMulShiftRightRound(2n, 4n, 0n)).toBe(8n);
+        expect(await contract.getMulShiftRightRound(1n, 6n, 0n)).toBe(6n);
+        expect(await contract.getMulShiftRightRound(1n, 4n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRightRound(1n, 3n, 3n)).toBe(0n);
+
+        // mulShiftRightCeil: ceil(x*y/2^z)
+        expect(await contract.getMulShiftRightCeil(2n, 4n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRightCeil(2n, 4n, 2n)).toBe(2n);
+        expect(await contract.getMulShiftRightCeil(2n, 4n, 1n)).toBe(4n);
+        expect(await contract.getMulShiftRightCeil(2n, 4n, 0n)).toBe(8n);
+        expect(await contract.getMulShiftRightCeil(1n, 6n, 0n)).toBe(6n);
+        expect(await contract.getMulShiftRightCeil(1n, 7n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRightCeil(1n, 4n, 3n)).toBe(1n);
+        expect(await contract.getMulShiftRightCeil(1n, 3n, 3n)).toBe(1n);
+
+        // sqrt: round(sqrt(num))
+        for (let num = 0n; num <= 100n; num++) {
+            // console.log(`sqrt(${num}) = ${await contract.getSqrt(num)}`);
+            expect(await contract.getSqrt(num)).toBe(
+                BigInt(Math.round(Math.sqrt(Number(num)))),
+            );
+        }
+        for (let num = -3n; num < 0n; num++) {
+            await expect(contract.getSqrt(num)).rejects.toThrow(
+                "Unable to execute get method. Got exit_code: 5",
+            );
+        }
     });
 });

src/test/e2e-emulated/stdlib.spec.ts

@@ -1,4 +1,4 @@
-import { Address, beginCell, toNano } from "@ton/core";
+import { Address, beginCell, Cell, toNano } from "@ton/core";
 import { Blockchain, SandboxContract, TreasuryContract } from "@ton/sandbox";
 import { StdlibTest } from "./contracts/output/stdlib_StdlibTest";
 import "@ton/test-utils";
@@ -56,7 +56,7 @@ describe("stdlib", () => {
                 .toString(),
         ).toBe(beginCell().storeBit(true).endCell().toString());
 
-        expect(await contract.getTvm_2023_07Upgrade()).toEqual(1355n);
+        expect(await contract.getTvm_2023_07Upgrade()).toEqual(1455n);
         expect(await contract.getTvm_2024_04Upgrade()).toEqual(82009144n);
 
         expect(
@@ -106,5 +106,63 @@ describe("stdlib", () => {
         expect(addrVar.address.asCell()).toEqualCell(
             beginCell().storeUint(345, 123).endCell(),
         );
+
+        expect(await contract.getBuilderDepth(beginCell())).toBe(0n);
+        expect(
+            await contract.getBuilderDepth(beginCell().storeRef(Cell.EMPTY)),
+        ).toBe(1n);
+
+        expect(await contract.getSkipLastBits(slice, 1n)).toEqualSlice(
+            beginCell()
+                .storeBit(1)
+                .storeRef(beginCell().storeBit(1).endCell())
+                .endCell()
+                .asSlice(),
+        );
+
+        expect(await contract.getFirstBits(slice, 1n)).toEqualSlice(
+            beginCell().storeBit(1).endCell().asSlice(),
+        );
+
+        expect(await contract.getLastBits(slice, 1n)).toEqualSlice(
+            beginCell().storeBit(1).endCell().asSlice(),
+        );
+
+        expect(await contract.getSliceDepth(slice)).toBe(1n);
+
+        expect(await contract.getAddressNone()).toEqual(null);
+
+        expect(
+            await contract.getComputeDataSizeCell(slice.asCell(), 1000n),
+        ).toMatchObject({
+            $$type: "DataSize",
+            cells: 2n,
+            bits: 3n,
+            refs: 1n,
+        });
+
+        expect(
+            await contract.getComputeDataSizeSlice(slice, 1000n),
+        ).toMatchObject({
+            $$type: "DataSize",
+            cells: 1n, // -1 for slice
+            bits: 3n,
+            refs: 1n,
+        });
+
+        expect(await contract.getCellDepth(slice.asCell())).toBe(1n);
+
+        expect(await contract.getCurLt()).toBe(0n);
+
+        expect(await contract.getBlockLt()).toBe(0n);
+
+        expect(await contract.getSetGasLimit(5000n)).toBe(3997n); // 5000 just to make sure it's enough, 3997 is how much it actually costs
+        await expect(contract.getSetGasLimit(3996n)).rejects.toThrow("-14"); // 3996 gas is not enough for sure
+
+        expect(await contract.getGetSeed()).toBe(0n);
+
+        expect(await contract.getSetSeed(123n)).toBe(123n);
+
+        expect(await contract.getMyCode()).toEqualCell(contract.init!.code);
     });
 });

stdlib/std/cells.tact

@@ -82,6 +82,8 @@ asm extends fun refs(self: Builder): Int { BREFS }
 
 asm extends fun bits(self: Builder): Int { BBITS }
 
+asm extends fun depth(self: Builder): Int { BDEPTH }
+
 //
 // Slice
 //
@@ -167,6 +169,14 @@ asm extends mutates fun skipBits(self: Slice, l: Int) { SDSKIPFIRST }
 
 asm extends fun endParse(self: Slice) { ENDS }
 
+asm extends fun skipLastBits(self: Slice, len: Int): Slice { SDSKIPLAST }
+
+asm extends fun firstBits(self: Slice, len: Int): Slice { SDCUTFIRST }
+
+asm extends fun lastBits(self: Slice, len: Int): Slice { SDCUTLAST }
+
+asm extends fun depth(self: Slice): Int { SDEPTH }
+
 //
 // Slice size
 //
@@ -210,3 +220,18 @@ inline fun emptyCell(): Cell {
 inline fun emptySlice(): Slice {
     return emptyCell().asSlice();
 }
+
+asm fun addressNone(): Address? { b{00} PUSHSLICE }
+
+struct DataSize {
+    cells: Int;
+    bits: Int;
+    refs: Int;
+}
+
+asm extends fun computeDataSize(self: Cell, maxCells: Int): DataSize { CDATASIZE }
+
+asm extends fun computeDataSize(self: Slice, maxCells: Int): DataSize { SDATASIZE }
+
+asm extends fun depth(self: Cell): Int { CDEPTH }
+

stdlib/std/contract.tact

@@ -240,3 +240,15 @@ asm fun parseStdAddress(slice: Slice): StdAddress { REWRITESTDADDR }
 /// See: https://docs.tact-lang.org/ref/core-advanced#parsevaraddress
 ///
 asm fun parseVarAddress(slice: Slice): VarAddress { REWRITEVARADDR }
+
+asm fun curLt(): Int { LTIME }
+
+asm fun blockLt(): Int { BLOCKLT }
+
+asm fun setGasLimit(limit: Int) { SETGASLIMIT }
+
+asm fun getSeed(): Int { RANDSEED }
+
+asm fun setSeed(seed: Int) { SETRAND }
+
+asm fun myCode(): Cell { MYCODE }