wan-ton-sdk 0.0.6

package/utils/compileContract.ts

@@ -0,0 +1,60 @@
+import {compileFunc, compilerVersion, CompilerConfig, CompilerVersion} from '@ton-community/func-js';
+import {Cell} from '@ton/core';
+import fs_1 from "fs";
+
+import {logger} from '../utils/logger'
+const formatUtil = require('util');
+
+export interface CR {
+    version:CompilerVersion,
+    hashHex:string,
+    codeBase64:string,
+}
+
+export async function compileContract(conf: CompilerConfig) {
+    // You can get compiler version
+    let version = await compilerVersion();
+
+    let result = await compileFunc(conf);
+
+    if (result.status === 'error') {
+        console.error(result.message)
+        return;
+    }
+
+    let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc, "base64"))[0];
+    logger.info(formatUtil.format("hash=>",codeCell.hash().toString('hex')));
+    let cr:CR = {
+        version,
+        hashHex:codeCell.hash().toString('hex'),
+        codeBase64: result.codeBoc,
+    }
+    return cr;
+}
+
+export function writeCR(filePath:string,cr:CR){
+    return fs_1.writeFileSync(filePath,JSON.stringify(cr));
+}
+
+export async function doCompile(conf:CompilerConfig,resultFilePath?:string){
+    let ret = await compileContract(conf);
+    //logger.info(formatUtil.format(ret?.toBoc().toString('base64'));
+
+    logger.info(formatUtil.format("result file path: %s",resultFilePath));
+    if(resultFilePath){
+        writeCR(resultFilePath,ret);
+        let cr:CR = JSON.parse(fs_1.readFileSync(resultFilePath,'utf-8'));
+        let codeCell = Cell.fromBoc(Buffer.from(cr.codeBase64, "base64"))[0];
+        return {
+            status:codeCell.hash().toString('hex') == cr.hashHex && cr.hashHex == ret?.hashHex,
+            codeCell:codeCell
+        }
+    }else{
+        let codeCell = Cell.fromBoc(Buffer.from(ret?.codeBase64, "base64"))[0];
+        return {
+            status:true,
+            codeCell:codeCell
+        }
+    }
+
+}

package/utils/log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json

@@ -0,0 +1,15 @@
+{
+    "keep": {
+        "days": true,
+        "amount": 10
+    },
+    "auditLog": "log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json",
+    "files": [
+        {
+            "date": 1736305494907,
+            "name": "log/wan-ton-sdk.out.2025-01-08",
+            "hash": "51ab306b7b02734edef3a311247d781fcca3d2c4118fc13713f863b2e9b1b14b"
+        }
+    ],
+    "hashType": "sha256"
+}

package/utils/logger.spec.ts

@@ -0,0 +1,14 @@
+import {logger} from './logger'
+const formatUtil = require('util');
+
+describe('logger', () => {
+
+    beforeAll(async () => {
+    },50000);
+
+    it('logger.info', async () => {
+        logger.info("Entering ");
+        logger.info(formatUtil.format("hello %s  %s","Jacob", "alice"));
+    },500000);
+
+});

package/utils/logger.ts

@@ -0,0 +1,96 @@
+import winston from "winston";
+import DailyRotateFile from 'winston-daily-rotate-file';
+const moment = require('moment');
+const path = require('path');
+
+const customFormat = winston.format.printf(({ level, message, timestamp}) => {
+    return `${timestamp} [${level}]: ${message}`;
+});
+
+class Logger {
+    private filePath: any;
+    private errorFilePath: string;
+    private level: string;
+    private errorFile: any;
+    private file: any;
+    private name: any;
+    private logger: any;
+
+    constructor(name, file, errorFile, level = 'info') {
+        this.name = name;
+        this.file = file;
+        this.errorFile = errorFile;
+        this.level = level ? level : 'info';
+        if (global.pkg) {
+            this.filePath = path.join(process.cwd(), file);
+            this.errorFilePath = path.join(process.cwd(), errorFile);
+        } else {
+            this.filePath = file;
+            this.errorFilePath = errorFile;
+        }
+
+        this.init(this.name, this.file, this.errorFile, this.level);
+    }
+
+    init(name, file, errorFile, level) {
+        this.logger = winston.createLogger({
+            levels: winston.config.syslog.levels,
+            level: level,
+            format: winston.format.combine(
+                winston.format.timestamp(),
+                customFormat
+            ),
+            transports: [
+                //
+                // - Write to all logs with level `level` and below to file
+                // - Write all logs error (and below) to errorFile.
+                //
+                new winston.transports.Console({
+                    handleExceptions: true
+                }),
+                new (DailyRotateFile)({
+                    filename: this.filePath,
+                    level: level,
+                    datePattern: 'YYYY-MM-DD',
+                    zippedArchive: true,
+                    maxSize: '50m',
+                    maxFiles: (global.testnet || global.isLeader) ? '30d' : '10d'
+                })
+            ],
+            exitOnError: false
+        });
+    }
+
+    debug(...params) {
+        try {
+            this.logger.debug(...params);
+        } catch (err) {
+            this.error(err);
+        }
+    }
+
+    info(...params) {
+        try {
+            this.logger.info(...params);
+        } catch (err) {
+            this.error(err);
+        }
+    }
+
+    warn(...params) {
+        try {
+            this.logger.warning(...params);
+        } catch (err) {
+            this.error(err);
+        }
+    }
+
+    error(...params) {
+        try {
+            this.logger.error(...params);
+        } catch (err) {
+            console.log(err);
+        }
+    }
+}
+export const logger = new Logger("wan-ton-sdk", './log/wan-ton-sdk.out', './log/wan-ton-sdk.err', global.SDK_LOG_LEVEL);

package/utils/utils.spec.ts

@@ -0,0 +1,21 @@
+import {logger} from './logger'
+const formatUtil = require('util');
+import {getQueryID} from "./utils";
+
+describe('queryID', () => {
+
+    beforeAll(async () => {
+    },50000);
+
+    it('getQueryID', async () => {
+        logger.info("Entering ");
+        while(true){
+            let queryID = await getQueryID();
+            if(queryID<0){
+                console.log("queryId",queryID);
+                break;
+            }
+        }
+    },500000);
+
+});

package/utils/utils.ts

@@ -0,0 +1,295 @@
+
+import { Address, toNano, fromNano } from "@ton/core";
+import {getSecureRandomNumber} from '@ton/crypto';
+
+export const randomAddress = (wc: number = 0) => {
+    const buf = Buffer.alloc(32);
+    for (let i = 0; i < buf.length; i++) {
+        buf[i] = Math.floor(Math.random() * 256);
+    }
+    return new Address(wc, buf);
+};
+
+const getRandom = (min:number, max:number) => {
+    return Math.random() * (max - min) + min;
+}
+
+export const getRandomTon = (min:number, max:number): bigint => {
+    return toNano(getRandom(min, max).toFixed(9));
+}
+
+export const BufferrToHexString = (buff: Buffer): string =>{
+    return "0x" + buff.toString('hex');
+}
+
+export const HexStringToBuffer = (str:String): Buffer =>{
+    return Buffer.from(str,'hex')
+}
+
+export async function sleep(ms:number)  {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+export async function getQueryID(){
+    while(true){
+        let queryID = await getSecureRandomNumber(1,Math.pow(2,52)-1);
+        if(queryID>0){
+            return queryID;
+        }
+    }
+}
+
+
+/*export function bigIntReviver(key, value) {
+    if (typeof value === "string" && value.endsWith("n")) {
+        return BigInt(value.slice(0, -1));
+    }
+    return value;
+}
+
+export function bigIntReplacer(key, value) {
+    if (typeof value === "bigint") {
+        return value.toString() + "n";
+    }
+    return value;
+}*/
+
+export function bigIntReviver(key, value) {
+    if (typeof value === "string" && value.endsWith("n")) {
+        return BigInt(value.slice(0, -1));
+    }
+    if(typeof value === "string"){
+        return BigInt(value);
+    }
+    return value;
+}
+
+export function bigIntReplacer(key, value) {
+    if (typeof value === "bigint") {
+        return value.toString(10);
+    }
+    return value;
+}
+
+export function isAddressEqual(src:Address|string,dst:Address|string){
+    let srcAddr :Address;
+    let dstAddr :Address;
+    if(!(src instanceof  Address)){
+        srcAddr = Address.parse(src)
+    }else{
+        srcAddr = src
+    }
+
+    if(!(dst instanceof  Address)){
+        dstAddr = Address.parse(dst)
+    }else{
+        dstAddr = dst
+    }
+
+    return srcAddr.equals(dstAddr);
+}
+
+export  function bigIntToBytes32(value:bigint) {
+
+    if (value < 0n || value >= 2n ** 256n) {
+        throw new Error("Value must be a 256-bit unsigned integer");
+    }
+    const hex = value.toString(16).padStart(64, '0');
+    return Buffer.from(hex, 'hex');
+}
+
+export function int64ToByte32(int64Value) {
+    // 确保输入是 BigInt
+    if (typeof int64Value !== 'bigint') {
+        throw new Error('Input must be a BigInt');
+    }
+
+    // 创建一个 8 字节的缓冲区（64 位）
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+
+    // 将 BigInt 写入缓冲区（小端序）
+    view.setBigUint64(0, int64Value, true);
+
+    // 将缓冲区转换为字节数组
+    const byteArray = new Uint8Array(buffer);
+
+    // 创建一个 32 字节的缓冲区
+    const byte32Buffer = new ArrayBuffer(32);
+    const byte32Array = new Uint8Array(byte32Buffer);
+
+    // 将 8 字节的 int64 复制到 32 字节缓冲区的末尾（右对齐）
+    byte32Array.set(byteArray, 24); // 24 = 32 - 8
+
+    // 将字节数组转换为十六进制字符串
+    let hexString = '0x';
+    byte32Array.forEach(byte => {
+        hexString += byte.toString(16).padStart(2, '0');
+    });
+
+    return hexString;
+}
+
+export function remove0x(str:string){
+    return (str.slice(0,2).toLowerCase() == '0x') ? str.slice(2):str;
+}
+
+export function add0x(str:string){
+    return (str.slice(0,2).toLowerCase() == '0x') ? str:'0x' + str;
+}
+
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+export async function ensureFileAndPath(fullFilePath:string):Promise<boolean>{
+    try {
+        await fs.access(fullFilePath);
+        console.log(`file exist: ${fullFilePath}`);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            const directoryPath = path.dirname(fullFilePath);
+
+            try {
+                await fs.access(directoryPath);
+            } catch (dirError) {
+                if (dirError.code === 'ENOENT') {
+                    console.log(`mkdir: ${directoryPath}`);
+                    await fs.mkdir(directoryPath, { recursive: true });
+                } else {
+                    console.error(`mkdir (${directoryPath}):`, dirError);
+                    return false;
+                }
+            }
+
+            try {
+                await fs.writeFile(fullFilePath, '');
+                console.log(`file created: ${fullFilePath}`);
+            } catch (fileError) {
+                console.error(`create file fail (${fullFilePath}):`, fileError);
+                return false;
+            }
+        } else {
+            console.error(`access file fail (${fullFilePath}):`, error);
+            return false
+        }
+    }
+    return true;
+}
+
+export async function ensurePath(fullFilePath:string):Promise<boolean>{
+    try {
+        await fs.access(fullFilePath);
+        console.log(`file exist: ${fullFilePath}`);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            const directoryPath = path.dirname(fullFilePath);
+
+            try {
+                await fs.access(directoryPath);
+            } catch (dirError) {
+                if (dirError.code === 'ENOENT') {
+                    console.log(`mkdir: ${directoryPath}`);
+                    await fs.mkdir(directoryPath, { recursive: true });
+                } else {
+                    console.error(`mkdir (${directoryPath}):`, dirError);
+                    return false;
+                }
+            }
+        } else {
+            console.error(`access file fail (${fullFilePath}):`, error);
+            return false
+        }
+    }
+    return true;
+}
+
+export async function removeFile(fullFilePath:string):Promise<boolean>{
+    try {
+        await fs.access(fullFilePath);
+        console.log(`file exist: ${fullFilePath}`);
+        await fs.unlink(fullFilePath);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return true
+        } else {
+            console.error(`access file fail (${fullFilePath}):`, formatError(error));
+            return false
+        }
+    }
+}
+
+
+const util = require('util');
+
+const ERROR_WHITELIST = new Set(['message', 'code', 'cause', 'name', 'status']);
+
+function extractErrorDetails(err, depth = 0, maxDepth = 3) {
+    if (depth > maxDepth) return '[Max Depth Exceeded]';
+    if (!err || typeof err !== 'object') return err;
+
+    const details = {};
+    ERROR_WHITELIST.forEach((key) => {
+
+        const value = err[key];
+        if (value !== undefined) {
+            details[key] = key === 'cause'
+                ? extractErrorDetails(value, depth + 1, maxDepth)
+                : value;
+        }
+    });
+
+    if(err.response?.config?.data){
+        details['response.config.data'] = err.response?.config?.data;
+    }
+    if(err.response?.data){
+        details['response.data.error'] = err.response?.data;
+    }
+    return details;
+}
+
+export function formatError(err:any):string{
+    return JSON.stringify(extractErrorDetails(err))
+}
+
+function isHexStringWithPrefix(str) {
+    return /^(0x)?[0-9a-fA-F]+$/.test(str);
+}
+
+function isEvenLengthHex(str) {
+    return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;
+}
+
+export function isValidHexString(str:string){
+    return isHexStringWithPrefix && isValidHexString;
+}
+
+
+export function isNotBase64(str) {
+    // 同时匹配标准Base64和URL安全Base64的正则表达式
+    const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$|^(?:[A-Za-z0-9\-_]{4})*(?:[A-Za-z0-9\-_]{2}==|[A-Za-z0-9\-_]{3}=)?$/;
+
+    // 类型检查
+    if (typeof str !== 'string') return true;
+
+    // 基础校验
+    const len = str.length;
+    if (len === 0) return false;        // 空字符串视为有效
+    if (len % 4 !== 0) return true;     // 长度必须是4的倍数
+
+    // 检查编码格式
+    return !BASE64_REGEX.test(str);
+}
+
+export function toBase64(str){
+    if(isNotBase64(str) && isValidHexString(str)){
+        return Buffer.from(str,'hex').toString('base64');
+    }else{
+        if(!isNotBase64(str)){
+            return str;
+        }else{
+            throw new Error(`invalid string ${str}`)
+        }
+    }
+}

package/wallet/balance.ts

@@ -0,0 +1,29 @@
+import {JettonMaster,  TonClient} from "@ton/ton";
+import {Blockchain} from "@ton/sandbox";
+import {Address} from "@ton/core";
+import {getJettonBalance} from "./jetton";
+import {JettonMinter} from "../JettonMinter";
+import {JettonWallet} from "../JettonWallet";
+
+export async function CoinBalance(client:TonClient|Blockchain, addr:Address) {
+    if(client instanceof TonClient){
+       return await client.getBalance(addr)
+    }else{
+        return (await client.getContract(addr)).balance
+    }
+}
+
+export async function TokenBalance(client:TonClient|Blockchain, tokenAddr:Address,addr:Address) {
+    if(client instanceof TonClient){
+        return await getJettonBalance(client,tokenAddr,addr)
+    }else{
+        let jetttonMaster = JettonMinter.createFromAddress(tokenAddr);
+        let jetttonMasterOpened = await client.openContract(jetttonMaster)
+        let jettonAddr = await jetttonMasterOpened.getWalletAddress(addr)
+
+
+        let jettonWallet = JettonWallet.createFromAddress(jettonAddr)
+        let jettonWalletOpened = await client.openContract(jettonWallet)
+        return await jettonWalletOpened.getJettonBalance()
+    }
+}

package/wallet/jetton.spec.ts

@@ -0,0 +1,27 @@
+import {buildWrappedJettonContent,parseWrappedJettonContent} from "./jetton";
+
+const opts= {
+    name:'dog',   // string
+    symbol:'dog symbol', // string
+    decimal:'5',  // string
+}
+
+describe('jetton content', () => {
+
+    beforeAll(async () => {
+    });
+
+    beforeEach(async () => {
+
+    });
+
+
+    it('build jetton content', async () => {
+        let ret = await buildWrappedJettonContent(opts);
+        console.log(ret);
+
+        let optsNew = await parseWrappedJettonContent(ret);
+        console.log(optsNew);
+    });
+
+});