wan-ton-sdk 0.0.7 → 0.0.9

package/dist/utils/logger.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const winston_daily_rotate_file_1 = __importDefault(require("winston-daily-rotate-file"));
+const moment = require('moment');
+const path = require('path');
+const customFormat = winston_1.default.format.printf(({ level, message, timestamp }) => {
+    return `${timestamp} [${level}]: ${message}`;
+});
+class Logger {
+    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_1.default.createLogger({
+            levels: winston_1.default.config.syslog.levels,
+            level: level,
+            format: winston_1.default.format.combine(winston_1.default.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 (winston_daily_rotate_file_1.default)({
+                    filename: this.filePath,
+                    level: level,
+                    datePattern: 'YYYY-MM-DD',
+                    zippedArchive: true,
+                    maxSize: '50m',
+                    maxFiles: (global.testnet || global.isLeader) ? '30d' : '10d'
+                })
+            ],
+            exitOnError: false
+        });
+    }
+    debug(...params) {
+        let msgFull = params.join(" ");
+        try {
+            this.logger.debug(msgFull);
+        }
+        catch (err) {
+            this.error(err);
+        }
+    }
+    info(...params) {
+        let msgFull = params.join(" ");
+        try {
+            this.logger.info(msgFull);
+        }
+        catch (err) {
+            this.error(err);
+        }
+    }
+    warn(...params) {
+        let msgFull = params.join(" ");
+        try {
+            this.logger.warning(msgFull);
+        }
+        catch (err) {
+            this.error(err);
+        }
+    }
+    error(...params) {
+        let msgFull = params.join(" ");
+        try {
+            this.logger.error(msgFull);
+        }
+        catch (err) {
+            exports.logger.info(err);
+        }
+    }
+}
+exports.Logger = Logger;
+const LOG_ROOT = path.join(__dirname, "../log/");
+exports.logger = new Logger("wan-ton-sdk", path.join(LOG_ROOT, 'wan-ton-sdk.out'), path.join(LOG_ROOT, 'wan-ton-sdk.err'), global.SDK_LOG_LEVEL);

package/dist/utils/utils.d.ts

@@ -0,0 +1,26 @@
+import { Address } from "@ton/core";
+export declare const randomAddress: (wc?: number) => Address;
+export declare const getRandomTon: (min: number, max: number) => bigint;
+export declare const BufferrToHexString: (buff: Buffer) => string;
+export declare const HexStringToBuffer: (str: String) => Buffer;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function getQueryID(): Promise<number>;
+export declare function bigIntReviver(key: any, value: any): any;
+export declare function bigIntReplacer(key: any, value: any): any;
+export declare function isAddressEqual(src: Address | string, dst: Address | string): boolean;
+export declare function bigIntToBytes32(value: bigint): Buffer;
+export declare function int64ToByte32(int64Value: any): string;
+export declare function remove0x(str: string): string;
+export declare function add0x(str: string): string;
+export declare function ensureFileAndPath(fullFilePath: string): Promise<boolean>;
+export declare function ensurePath(fullFilePath: string): Promise<boolean>;
+export declare function ensureDirectoryExists(directoryPath: any): Promise<void>;
+export declare function removeFile(fullFilePath: string): Promise<boolean>;
+export declare function formatError(err: any): string;
+export declare function isValidHexString(str: string): boolean;
+export declare function isNotBase64(str: any): boolean;
+export declare function toBase64(str: any): any;
+export declare function BigToAddress(big: bigint): Address;
+export declare function bigIntToBuffer(big: bigint): Buffer;
+export declare function bufferToBigInt(buffer: Buffer, isBigEndian?: boolean): bigint;
+export declare function AddressToBig(addr: Address): bigint;

package/dist/utils/utils.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HexStringToBuffer = exports.BufferrToHexString = exports.getRandomTon = exports.randomAddress = void 0;
+exports.sleep = sleep;
+exports.getQueryID = getQueryID;
+exports.bigIntReviver = bigIntReviver;
+exports.bigIntReplacer = bigIntReplacer;
+exports.isAddressEqual = isAddressEqual;
+exports.bigIntToBytes32 = bigIntToBytes32;
+exports.int64ToByte32 = int64ToByte32;
+exports.remove0x = remove0x;
+exports.add0x = add0x;
+exports.ensureFileAndPath = ensureFileAndPath;
+exports.ensurePath = ensurePath;
+exports.ensureDirectoryExists = ensureDirectoryExists;
+exports.removeFile = removeFile;
+exports.formatError = formatError;
+exports.isValidHexString = isValidHexString;
+exports.isNotBase64 = isNotBase64;
+exports.toBase64 = toBase64;
+exports.BigToAddress = BigToAddress;
+exports.bigIntToBuffer = bigIntToBuffer;
+exports.bufferToBigInt = bufferToBigInt;
+exports.AddressToBig = AddressToBig;
+const core_1 = require("@ton/core");
+const crypto_1 = require("@ton/crypto");
+const logger_1 = require("../utils/logger");
+const randomAddress = (wc = 0) => {
+    const buf = Buffer.alloc(32);
+    for (let i = 0; i < buf.length; i++) {
+        buf[i] = Math.floor(Math.random() * 256);
+    }
+    return new core_1.Address(wc, buf);
+};
+exports.randomAddress = randomAddress;
+const getRandom = (min, max) => {
+    return Math.random() * (max - min) + min;
+};
+const getRandomTon = (min, max) => {
+    return (0, core_1.toNano)(getRandom(min, max).toFixed(9));
+};
+exports.getRandomTon = getRandomTon;
+const BufferrToHexString = (buff) => {
+    return "0x" + buff.toString('hex');
+};
+exports.BufferrToHexString = BufferrToHexString;
+const HexStringToBuffer = (str) => {
+    return Buffer.from(str, 'hex');
+};
+exports.HexStringToBuffer = HexStringToBuffer;
+async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function getQueryID() {
+    while (true) {
+        let queryID = await (0, crypto_1.getSecureRandomNumber)(1, Math.pow(2, 52) - 1);
+        if (queryID > 0) {
+            return queryID;
+        }
+    }
+}
+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;
+}
+function bigIntReplacer(key, value) {
+    if (typeof value === "bigint") {
+        return value.toString(10);
+    }
+    return value;
+}
+function isAddressEqual(src, dst) {
+    let srcAddr;
+    let dstAddr;
+    if (!(src instanceof core_1.Address)) {
+        srcAddr = core_1.Address.parse(src);
+    }
+    else {
+        srcAddr = src;
+    }
+    if (!(dst instanceof core_1.Address)) {
+        dstAddr = core_1.Address.parse(dst);
+    }
+    else {
+        dstAddr = dst;
+    }
+    return srcAddr.equals(dstAddr);
+}
+function bigIntToBytes32(value) {
+    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');
+}
+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;
+}
+function remove0x(str) {
+    return (str.slice(0, 2).toLowerCase() == '0x') ? str.slice(2) : str;
+}
+function add0x(str) {
+    return (str.slice(0, 2).toLowerCase() == '0x') ? str : '0x' + str;
+}
+const fs = require('node:fs/promises');
+const path = require('node:path');
+async function ensureFileAndPath(fullFilePath) {
+    try {
+        await fs.access(fullFilePath);
+        logger_1.logger.info(`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') {
+                    logger_1.logger.info(`mkdir: ${directoryPath}`);
+                    await fs.mkdir(directoryPath, { recursive: true });
+                }
+                else {
+                    logger_1.logger.error(`mkdir (${directoryPath}):`, dirError);
+                    return false;
+                }
+            }
+            try {
+                await fs.writeFile(fullFilePath, '');
+                logger_1.logger.info(`file created: ${fullFilePath}`);
+            }
+            catch (fileError) {
+                logger_1.logger.error(`create file fail (${fullFilePath}):`, fileError);
+                return false;
+            }
+        }
+        else {
+            logger_1.logger.error(`access file fail (${fullFilePath}):`, error);
+            return false;
+        }
+    }
+    return true;
+}
+async function ensurePath(fullFilePath) {
+    try {
+        await fs.access(fullFilePath);
+        logger_1.logger.info(`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') {
+                    logger_1.logger.info(`mkdir: ${directoryPath}`);
+                    await fs.mkdir(directoryPath, { recursive: true });
+                }
+                else {
+                    logger_1.logger.error(`mkdir (${directoryPath}):`, dirError);
+                    return false;
+                }
+            }
+        }
+        else {
+            logger_1.logger.error(`access file fail (${fullFilePath}):`, error);
+            return false;
+        }
+    }
+    return true;
+}
+async function ensureDirectoryExists(directoryPath) {
+    try {
+        await fs.access(directoryPath);
+        logger_1.logger.info(`目录 "${directoryPath}" 已存在。`);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            try {
+                await fs.mkdir(directoryPath, { recursive: true });
+                logger_1.logger.info(`目录 "${directoryPath}" 创建成功。`);
+            }
+            catch (mkdirError) {
+                logger_1.logger.error(`创建目录 "${directoryPath}" 失败:`, mkdirError);
+                throw mkdirError; // Re-throw the error if directory creation fails
+            }
+        }
+        else {
+            logger_1.logger.error(`检查目录 "${directoryPath}" 失败:`, error);
+            throw error; // Re-throw other errors during access check
+        }
+    }
+}
+async function removeFile(fullFilePath) {
+    try {
+        await fs.access(fullFilePath);
+        logger_1.logger.info(`file exist: ${fullFilePath}`);
+        await fs.unlink(fullFilePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return true;
+        }
+        else {
+            logger_1.logger.error(`access file fail (${fullFilePath}):`, formatError(error));
+            return false;
+        }
+    }
+}
+const util = require('util');
+const ERROR_WHITELIST = new Set(['message', 'code', 'cause', 'name', 'status']);
+function formatErrorStack(error) {
+    if (!error.stack)
+        return [];
+    const stackLines = error.stack.split('\n');
+    return stackLines.slice(1).map(line => line.trim());
+}
+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;
+    }
+    if (err instanceof Error) {
+        details['stack'] = formatErrorStack(err);
+    }
+    return details;
+}
+function formatError(err) {
+    return JSON.stringify(extractErrorDetails(err), null, 2);
+}
+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);
+}
+function isValidHexString(str) {
+    return isEvenLengthHex(remove0x(str));
+}
+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);
+}
+function toBase64(str) {
+    if (isValidHexString(str)) {
+        return Buffer.from(remove0x(str), 'hex').toString('base64');
+    }
+    else {
+        if (!isNotBase64(str)) {
+            return str;
+        }
+        else {
+            throw new Error(`invalid string ${str}`);
+        }
+    }
+}
+function BigToAddress(big) {
+    let bufHash = bigIntToBuffer(big);
+    return new core_1.Address(0, bufHash);
+}
+function bigIntToBuffer(big) {
+    let buffer = Buffer.from(big.toString(16), 'hex');
+    let bufferLeft = Buffer.alloc(32 - buffer.length);
+    return Buffer.concat([bufferLeft, buffer]);
+}
+function bufferToBigInt(buffer, isBigEndian = true) {
+    let result = 0n;
+    const bytes = isBigEndian ? buffer : [...buffer].reverse();
+    for (const byte of bytes) {
+        result = (result << 8n) | BigInt(byte);
+    }
+    return result;
+}
+function AddressToBig(addr) {
+    let hash = addr.hash;
+    return bufferToBigInt(hash);
+}

package/dist/wallet/balance.d.ts

@@ -0,0 +1,5 @@
+import { Blockchain } from "@ton/sandbox";
+import { Address } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+export declare function CoinBalance(client: WanTonClient | Blockchain, addr: Address): Promise<bigint>;
+export declare function TokenBalance(client: WanTonClient | Blockchain, tokenAddr: Address, addr: Address): Promise<bigint>;

package/dist/wallet/balance.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinBalance = CoinBalance;
+exports.TokenBalance = TokenBalance;
+const jetton_1 = require("./jetton");
+const JettonMinter_1 = require("../JettonMinter");
+const JettonWallet_1 = require("../JettonWallet");
+const client_interface_1 = require("../client/client-interface");
+async function CoinBalance(client, addr) {
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        return await client.getBalance(addr);
+    }
+    else {
+        return (await client.getContract(addr)).balance;
+    }
+}
+async function TokenBalance(client, tokenAddr, addr) {
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        return await (0, jetton_1.getJettonBalance)(client, tokenAddr, addr);
+    }
+    else {
+        let jetttonMaster = JettonMinter_1.JettonMinter.createFromAddress(tokenAddr);
+        let jetttonMasterOpened = await client.openContract(jetttonMaster);
+        let jettonAddr = await jetttonMasterOpened.getWalletAddress(addr);
+        let jettonWallet = JettonWallet_1.JettonWallet.createFromAddress(jettonAddr);
+        let jettonWalletOpened = await client.openContract(jettonWallet);
+        return await jettonWalletOpened.getJettonBalance();
+    }
+}

package/dist/wallet/jetton.d.ts

@@ -0,0 +1,16 @@
+import { Address, Cell } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+import { Blockchain } from "@ton/sandbox";
+export declare function getJettonBalance(client: WanTonClient | Blockchain, jettonMasterAddr: Address, userAddress: Address): Promise<bigint>;
+export declare function getJettonAddress(client: WanTonClient | Blockchain, jettonMasterAddr: Address, userAddress: Address): Promise<Address>;
+export declare function getJettonData(client: WanTonClient | Blockchain, jettonMasterAddr: Address): Promise<{
+    totalSupply: bigint;
+    mintable: boolean;
+    adminAddress: Address;
+    content: import("@ton/core").Cell;
+    walletCode: import("@ton/core").Cell;
+}>;
+export declare function getJettonWalletCode(client: WanTonClient | Blockchain, jettonMasterAddr: Address): Promise<Cell>;
+export declare function getJettonDataContent(client: WanTonClient | Blockchain, jettonMasterAddr: Address): Promise<Cell>;
+export declare function buildWrappedJettonContent(opts: any): Promise<Cell>;
+export declare function parseWrappedJettonContent(cell: Cell): Promise<{}>;

package/dist/wallet/jetton.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJettonBalance = getJettonBalance;
+exports.getJettonAddress = getJettonAddress;
+exports.getJettonData = getJettonData;
+exports.getJettonWalletCode = getJettonWalletCode;
+exports.getJettonDataContent = getJettonDataContent;
+exports.buildWrappedJettonContent = buildWrappedJettonContent;
+exports.parseWrappedJettonContent = parseWrappedJettonContent;
+const core_1 = require("@ton/core");
+const ton_1 = require("@ton/ton");
+const crypto_1 = require("@ton/crypto");
+const client_interface_1 = require("../client/client-interface");
+const logger_1 = require("../utils/logger");
+async function getJettonBalance(client, jettonMasterAddr, userAddress) {
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let jettonWalletAddress = await getJettonAddress(client, jettonMasterAddr, userAddress);
+        let jettonWalletContract = ton_1.JettonWallet.create(jettonWalletAddress);
+        return await (client.open(jettonWalletContract)).getBalance();
+    }
+    else {
+        let jettonWalletAddress = await getJettonAddress(client, jettonMasterAddr, userAddress);
+        let jettonWalletContract = ton_1.JettonWallet.create(jettonWalletAddress);
+        return await (client.openContract(jettonWalletContract)).getBalance();
+    }
+}
+async function getJettonAddress(client, jettonMasterAddr, userAddress) {
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let jettonMasterContract = ton_1.JettonMaster.create(jettonMasterAddr);
+        return await (client.open(jettonMasterContract).getWalletAddress(userAddress));
+    }
+    else {
+        let jettonMasterContract = ton_1.JettonMaster.create(jettonMasterAddr);
+        return await (client.openContract(jettonMasterContract).getWalletAddress(userAddress));
+    }
+}
+async function getJettonData(client, jettonMasterAddr) {
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let jettonMasterContract = ton_1.JettonMaster.create(jettonMasterAddr);
+        let openedContract = await client.open(jettonMasterContract);
+        return await openedContract.getJettonData();
+    }
+    else {
+        let jettonMasterContract = ton_1.JettonMaster.create(jettonMasterAddr);
+        let openedContract = await client.openContract(jettonMasterContract);
+        return await openedContract.getJettonData();
+    }
+}
+async function getJettonWalletCode(client, jettonMasterAddr) {
+    return (await getJettonData(client, jettonMasterAddr)).walletCode;
+}
+async function getJettonDataContent(client, jettonMasterAddr) {
+    return (await getJettonData(client, jettonMasterAddr)).content;
+}
+/*
+opts= {
+    name:'dog',   // string
+    symbol:'dog', // string
+    decimal:'5',  // string
+}
+ */
+function leftpad(str, len, ch = ' ') {
+    str = String(str);
+    const pad = new Array(len - str.length + 1).join(ch);
+    return pad + str;
+}
+const SNAKE_PREFIX = 0x00;
+const ONCHAIN_CONTENT_PREFIX = 0x00;
+const KEYLEN = 256;
+const jettonOnChainMetadataSpec = {
+    name: "utf8",
+    description: "utf8",
+    image: "ascii",
+    symbol: "utf8",
+    decimals: 'utf8'
+};
+async function getRidofProp(originalObj, propertiesToRemove) {
+    const newObj = Object.keys(originalObj)
+        .filter(key => !propertiesToRemove.includes(key))
+        .reduce((acc, key) => {
+        acc[key] = originalObj[key];
+        return acc;
+    }, {});
+    return newObj;
+}
+async function buildWrappedJettonContent(opts) {
+    const dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(KEYLEN), core_1.Dictionary.Values.Cell());
+    let newOpts = await getRidofProp(opts, ['tokenAddress', 'walletCodeBase64']);
+    Object.entries(newOpts).forEach(([k, v]) => {
+        if (!jettonOnChainMetadataSpec[k]) {
+            //throw new Error(`Unsupported token key: ${k}`);
+            logger_1.logger.error(`Unsupported token key: ${k}`);
+            return;
+        }
+        if (v === undefined || v === "")
+            return;
+        let bufferToStore = Buffer.from(v, jettonOnChainMetadataSpec[k]);
+        const rootCell = (0, core_1.beginCell)();
+        rootCell.storeUint(SNAKE_PREFIX, 8);
+        let currentCell = rootCell;
+        const CELL_MAX_SIZE_BYTES = Math.floor((1023 - 8) / 8);
+        while (bufferToStore.length > 0) {
+            currentCell.storeBuffer(bufferToStore.slice(0, CELL_MAX_SIZE_BYTES));
+            bufferToStore = bufferToStore.slice(CELL_MAX_SIZE_BYTES);
+            if (bufferToStore.length > 0) {
+                const newCell = (0, core_1.beginCell)();
+                currentCell.storeRef(newCell);
+                currentCell = newCell;
+            }
+        }
+        const keyHash = BigInt("0x" + (0, crypto_1.sha256_sync)(k).toString('hex'));
+        dict.set(keyHash, rootCell.endCell());
+    });
+    return (0, core_1.beginCell)()
+        .storeUint(ONCHAIN_CONTENT_PREFIX, 8)
+        .storeDict(dict)
+        .endCell();
+}
+async function parseWrappedJettonContent(cell) {
+    // const keys = Dictionary.Keys.BitString(256);
+    // const values = Dictionary.Values.Buffer(16);
+    // const keyName = new BitString(sha256_sync("name"),0,256);
+    // const keySymbol = new BitString(sha256_sync("symbol"),0,256);
+    // const keyDecimals = new BitString(sha256_sync("decimals"),0,256);
+    // let cs = cell.beginParse();
+    // cs.skip(8);
+    // let dictDs = Dictionary.loadDirect(keys, values, cs)
+    // return {
+    //     name:dictDs.get(keyName).toString('utf-8').trim(),
+    //     symbol:dictDs.get(keySymbol).toString('utf-8').trim(),
+    //     decimals:dictDs.get(keyDecimals).toString('utf-8').trim(),
+    // }
+    const defaultJettonKeys = ["uri", "name", "description", "image", "image_data", "symbol", "decimals", "amount_style"];
+    const defaultNftKeys = ["uri", "name", "description", "image", "image_data"];
+    const contentValue = {
+        serialize: (src, builder) => {
+            builder.storeRef((0, core_1.beginCell)().storeUint(0, 8).storeStringTail(src).endCell());
+        },
+        parse: (src) => {
+            const sc = src.loadRef().beginParse();
+            const prefix = sc.loadUint(8);
+            if (prefix == 0) {
+                return sc.loadStringTail();
+            }
+            else if (prefix == 1) {
+                // Not really tested, but feels like it should work
+                const chunkDict = core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.Uint(32), core_1.Dictionary.Values.Cell(), sc);
+                return chunkDict.values().map(x => x.beginParse().loadStringTail()).join('');
+            }
+            else {
+                throw (Error(`Prefix ${prefix} is not supported yet`));
+            }
+        }
+    };
+    const content = cell.beginParse();
+    const type = content.loadUint(8);
+    logger_1.logger.info(`type is ${JSON.stringify(type)}`);
+    const contentDict = core_1.Dictionary.load(core_1.Dictionary.Keys.BigUint(256), contentValue, content);
+    const contentMap = {};
+    const contentKeys = defaultJettonKeys;
+    for (const name of contentKeys) {
+        // I know we should pre-compute hashed keys for known values... just not today.
+        const dictKey = BigInt("0x" + ((0, crypto_1.sha256_sync)(name)).toString('hex'));
+        const dictValue = contentDict.get(dictKey);
+        if (dictValue !== undefined) {
+            contentMap[name] = dictValue;
+        }
+    }
+    logger_1.logger.info(`jetton has content ${JSON.stringify(contentMap, null, 2)}`);
+    return contentMap;
+}