test(benches): add nft test

spell/cspell-list.txt

@@ -1,3 +1,4 @@
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAU
 Aksakov
 Aliaksandr
 alnum

src/benchmarks/nft/run.ts

@@ -0,0 +1,131 @@
+import "@ton/test-utils";
+import type { Address } from "@ton/core";
+import { Cell, beginCell, contractAddress } from "@ton/core";
+
+import {
+    generateResults,
+    generateCodeSizeResults,
+    printBenchmarkTable,
+    type BenchmarkResult,
+    type CodeSizeResult,
+} from "@/benchmarks/utils/gas";
+import { resolve } from "path";
+import { readFileSync } from "fs";
+import { posixNormalize } from "@/utils/filePath";
+
+import { NFTCollection } from "@/benchmarks/nft/tact/output/collection_NFTCollection";
+import type { RoyaltyParams } from "@/benchmarks/nft/tact/output/collection_NFTCollection";
+import { NFTItem } from "@/benchmarks/nft/tact/output/collection_NFTItem";
+
+import benchmarkResults from "@/benchmarks/nft/gas.json";
+import benchmarkCodeSizeResults from "@/benchmarks/nft/size.json";
+
+const loadFunCNFTBoc = () => {
+    const bocCollection = readFileSync(
+        posixNormalize(resolve(__dirname, "./func/output/nft-collection.boc")),
+    );
+
+    const bocItem = readFileSync(
+        posixNormalize(resolve(__dirname, "./func/output/nft-item.boc")),
+    );
+
+    return { bocCollection, bocItem };
+};
+
+const fromInitCollection = (
+    owner: Address,
+    index: bigint,
+    content: Cell,
+    royaltyParams: RoyaltyParams,
+) => {
+    const nftData = loadFunCNFTBoc();
+    const __code = Cell.fromBoc(nftData.bocCollection)[0]!;
+
+    const royaltyCell = beginCell()
+        .storeUint(royaltyParams.nominator, 16)
+        .storeUint(royaltyParams.dominator, 16)
+        .storeAddress(royaltyParams.owner)
+        .endCell();
+
+    const __data = beginCell()
+        .storeAddress(owner)
+        .storeUint(index, 64)
+        .storeRef(content)
+        .storeRef(Cell.fromBoc(nftData.bocItem)[0]!)
+        .storeRef(royaltyCell)
+        .endCell();
+
+    const __gen_init = { code: __code, data: __data };
+    const address = contractAddress(0, __gen_init);
+    return Promise.resolve(new NFTCollection(address, __gen_init));
+};
+
+const fromInitItem = (
+    _owner: Address | null,
+    _content: Cell | null,
+    collectionAddress: Address,
+    itemIndex: bigint,
+) => {
+    const nftData = loadFunCNFTBoc();
+    const __code = Cell.fromBoc(nftData.bocItem)[0]!;
+
+    const __data = beginCell()
+        .storeUint(itemIndex, 64)
+        .storeAddress(collectionAddress)
+        .endCell();
+
+    const __gen_init = { code: __code, data: __data };
+    const address = contractAddress(0, __gen_init);
+    return Promise.resolve(new NFTItem(address, __gen_init));
+};
+
+export const run = (
+    testNFT: (
+        benchmarkResults: BenchmarkResult,
+        codeSizeResults: CodeSizeResult,
+        fromInitCollection: (
+            owner: Address,
+            index: bigint,
+            content: Cell,
+            royaltyParams: RoyaltyParams,
+        ) => Promise<NFTCollection>,
+        fromInitItem: (
+            owner: Address | null,
+            content: Cell | null,
+            collectionAddress: Address,
+            itemIndex: bigint,
+        ) => Promise<NFTItem>,
+    ) => void,
+) => {
+    describe("NFT Gas Tests", () => {
+        const fullResults = generateResults(benchmarkResults);
+        const fullCodeSizeResults = generateCodeSizeResults(
+            benchmarkCodeSizeResults,
+        );
+
+        describe("func", () => {
+            const funcCodeSize = fullCodeSizeResults.at(0)!;
+            const funcResult = fullResults.at(0)!;
+
+            testNFT(funcResult, funcCodeSize, fromInitCollection, fromInitItem);
+        });
+
+        describe("tact", () => {
+            const tactCodeSize = fullCodeSizeResults.at(-1)!;
+            const tactResult = fullResults.at(-1)!;
+            testNFT(
+                tactResult,
+                tactCodeSize,
+                NFTCollection.fromInit.bind(NFTCollection),
+                NFTItem.fromInit.bind(NFTItem),
+            );
+        });
+
+        afterAll(() => {
+            printBenchmarkTable(fullResults, fullCodeSizeResults, {
+                implementationName: "FunC",
+                printMode: "full",
+            });
+        });
+    });
+};

src/benchmarks/nft/tact/item.tact

@@ -49,7 +49,7 @@ contract NFTItem(
         throwUnless(NotInit, self.owner != null);
         throwUnless(IncorrectSender, sender() == self.owner);
         throwUnless(IncorrectForwardPayload, msg.forwardPayload.bits() >= 1);
-        forceBasechain(msg.newOwner);
+        forceBasechainFunc(msg.newOwner);
 
         let fwdFees = context().readForwardFee();
 
@@ -80,7 +80,7 @@ contract NFTItem(
         }
 
         if (needResponse) {
-            forceBasechain(msg.responseDestination!!);
+            forceBasechainFunc(msg.responseDestination!!);
             sendMsg(
                 msg.responseDestination!!,
                 restAmount,
@@ -105,6 +105,8 @@ contract NFTItem(
     }
 }
 
+asm fun forceBasechainFunc(address: Address) { REWRITESTDADDR DROP 333 THROWIF }
+
 inline fun sendMsg(toAddress: Address, amount: Int, op: Int, queryId: Int, payload: Builder, sendMode: Int) {
     message(MessageParameters {
         bounce: false,

src/benchmarks/nft/test.spec.ts

@@ -0,0 +1,21 @@
+import { type FromInitItem, testItem } from "@/benchmarks/nft/tests/item";
+import {
+    type FromInitCollection,
+    testCollection,
+} from "@/benchmarks/nft/tests/collection";
+
+import type { BenchmarkResult, CodeSizeResult } from "@/benchmarks/utils/gas";
+
+export const testNFT = (
+    _benchmarkResults: BenchmarkResult,
+    _codeSizeResults: CodeSizeResult,
+    fromInitCollection: FromInitCollection,
+    fromInitItem: FromInitItem,
+) => {
+    testItem(fromInitItem);
+    testCollection(fromInitCollection, fromInitItem);
+};
+
+import { run } from "@/benchmarks/nft/run";
+
+run(testNFT);