@layerzerolabs/ton-sdk-tools 3.0.71 → 3.0.73

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @layerzerolabs/ton-sdk-tools
 
+## 3.0.73
+
+### Patch Changes
+
+- 41cec93: Publish new package for TON sdk
+
+## 3.0.72
+
+### Patch Changes
+
+- a994069: nibiru, plumephoenix
+
 ## 3.0.71
 
 ### Patch Changes

package/dist/index.cjs

@@ -345,8 +345,156 @@ function parseClasses(strInput) {
   }
   return results;
 }
-function saveTonContractWrapper(tonObjects, directory, baseWrapper) {
-  const generatedMethods = Object.entries(tonObjects).map(([_, tonObject]) => tonObject.constructorCode ?? "").join("\n");
+function saveBaseEventHandler(directory) {
+  const allTypes = ["ExtendedContract", "ActionEvent", "Md", "nameMap"].sort();
+  const savedCode = `${file_signature_header}
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+
+import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric, beginCell } from '@ton/core'
+import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
+import { flattenTransaction } from '@ton/test-utils'
+
+import { OPCODES } from '../constants'
+
+import { getLzDict,
+${allTypes.map((type) => "    " + type + ",\n").join("")}} from './allTypes'
+
+import { TonObjectUnwrapper } from './TonObjectUnwrapper'
+import { TonContractWrapper } from './TonContractWrapper'
+
+export class LzEvent {
+    private _eventPromise: Promise<ActionEvent>
+    private _event: ActionEvent | null
+    public topic: string
+    public body: Md
+    public bodyName: string
+    public initialStorage: Cell
+    public initialized: boolean
+
+    constructor(wrapper: ExtendedContract<TonContractWrapper>, cell: Cell) {
+        this._eventPromise = TonObjectUnwrapper.getActionEventToTS(wrapper, cell)
+        this._event = null
+        this.topic = ''
+        this.body = {}
+        this.initialStorage = beginCell().endCell()
+        this.initialized = false
+        this.bodyName = ''
+    }
+
+    async load(wrapper: ExtendedContract<TonContractWrapper>): Promise<boolean> {
+        this._event = await this._eventPromise
+        this.topic = TonContractWrapper.bigintToAsciiString(this._event.topic)
+        this.bodyName = await TonObjectUnwrapper.getTypeOf(wrapper, this._event.body)
+        const tsCasterName = 'get' + nameMap[this.bodyName] + 'ToTS'
+
+        const method = TonObjectUnwrapper[tsCasterName as keyof typeof TonObjectUnwrapper]
+        if (typeof method === 'function') {
+            this.body = await method(wrapper, this._event.body)
+        } else {
+            console.log('Method' + tsCasterName + 'does not exist.')
+        }
+
+        this.initialStorage = this._event.initialStorage
+        this.initialized = true
+        return this.initialized
+    }
+}
+
+export class BaseEventHandler {
+    public allFailures = {
+        txList: [] as BlockchainTransaction[],
+        events: [] as EventMessageSent[],
+    }
+    public allVictories = {
+        txList: [] as BlockchainTransaction[],
+        eventObjects: [] as LzEvent[],
+    }
+
+    async postProcessSuccess(event: LzEvent, tx: BlockchainTransaction & Transaction): Promise<void> {
+        // base case: do nothing
+    }
+
+    async postProcessFailure(event: EventMessageSent, tx: BlockchainTransaction & Transaction): Promise<void> {
+        // base case: do nothing
+    }
+
+    async addCurrentEventsToAllEvents(
+        results: SendMessageResult,
+        contract: ExtendedContract<TonContractWrapper>
+    ): Promise<void> {
+        for (let i = 0; i < results.transactions.length; i++) {
+            const tx: BlockchainTransaction & Transaction = results.transactions[i]
+            const desc = tx.description
+            if (desc.type !== 'generic' || desc.computePhase.type !== 'skipped') continue
+
+            const eventBody = tx.inMessage?.body
+            if (eventBody === undefined) continue
+            const eventBodySlice = eventBody.beginParse()
+            // the event body is empty if we are sending a payment with no corresponding payload
+            if (eventBodySlice.remainingBits < 32) continue
+            const opCode = eventBodySlice.loadUint(32)
+            if (opCode === Number(OPCODES.BaseInterface_OP_EVENT)) {
+                if (eventBody.refs.length > 0) {
+                    const eventInnerCell = eventBody.refs[0]
+                    const newLzEvent = new LzEvent(contract, eventInnerCell)
+                    await newLzEvent.load(contract)
+                    this.allVictories.txList.push(tx)
+                    this.allVictories.eventObjects.push(newLzEvent)
+                    await this.postProcessSuccess(newLzEvent, tx)
+                }
+            } else {
+                const failureEvent = results.events[i] as EventMessageSent
+                this.allFailures.txList.push(tx)
+                this.allFailures.events.push(failureEvent)
+                await this.postProcessFailure(failureEvent, tx)
+            }
+        }
+    }
+}
+`;
+  fs__namespace.writeFileSync(path__namespace.join(directory, "BaseEventHandler.ts"), savedCode);
+}
+function saveLzEventHandler(directory) {
+  const savedCode = `${file_signature_header}
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+
+import { Cell, Transaction } from '@ton/core'
+import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
+
+import { Md, MdPacketSent } from './allTypes'
+import { BaseEventHandler, LzEvent } from './BaseEventHandler'
+
+export class LzEventHandler extends BaseEventHandler {
+    public allVictories = {
+        txList: [] as BlockchainTransaction[],
+        eventObjects: [] as LzEvent[],
+        packetsSent: [] as MdPacketSent[],
+    }
+
+    async postProcessSuccess(event: LzEvent, tx: BlockchainTransaction & Transaction): Promise<void> {
+        if (event.topic === 'Channel::event::PACKET_SENT' && this.isMdPacketSent(event.body)) {
+            this.allVictories.packetsSent.push(event.body)
+        }
+        await Promise.resolve()
+    }
+
+    isMdPacketSent(md: Md): md is MdPacketSent {
+        return (
+            'nativeFee' in md &&
+            'zroFee' in md &&
+            'extraOptions' in md &&
+            'enforcedOptions' in md &&
+            'packetEncoded' in md &&
+            'nonce' in md
+        )
+    }
+}
+`;
+  fs__namespace.writeFileSync(path__namespace.join(directory, "LzEventHandler.ts"), savedCode);
+}
+function saveClasslibWrapper(directory, baseWrapper) {
   if (baseWrapper === void 0) {
     baseWrapper = `import { BaseWrapper, SendRequestOptions } from '@layerzerolabs/ton-sdk-tools'`;
   }
@@ -377,10 +525,10 @@ export type GetIntFnNames =
     | 'cl::get<bool>'
     | 'cl::get<address>'
 
-export class TonContractWrapper extends BaseWrapper {
-    static create(code: Cell, data: Cell, workchain = 0): TonContractWrapper {
+export class ClasslibWrapper extends BaseWrapper {
+    static create(code: Cell, data: Cell, workchain = 0): ClasslibWrapper {
         const init = { code, data }
-        return new TonContractWrapper(contractAddress(workchain, init), init)
+        return new ClasslibWrapper(contractAddress(workchain, init), init)
     }
 
     buildRequest(
@@ -507,8 +655,46 @@ export class TonContractWrapper extends BaseWrapper {
         const ret = await provider.get('cl::dict256::setRef', args)
         return ret.stack.readCell()
     }
+}
+`;
+  fs__namespace.writeFileSync(path__namespace.join(directory, "ClasslibWrapper.ts"), savedCode);
+}
+function saveTonContractWrapper(tonObjects, directory) {
+  const generatedMethods = Object.entries(tonObjects).map(([_, tonObject]) => tonObject.constructorCode ?? "").join("\n");
+  const savedCode = `${file_signature_header}
+
+import {
+    Address,
+    Cell,
+    ContractProvider,
+    ContractState,
+    Sender,
+    SenderArguments,
+    TupleItem,
+    TupleReader,
+    contractAddress,
+    beginCell,
+} from '@ton/core'
+
+import { ClasslibWrapper } from './ClasslibWrapper'
+
+export class TonContractWrapper extends ClasslibWrapper {
+    static create(code: Cell, data: Cell, workchain = 0): TonContractWrapper {
+        const init = { code, data }
+        return new TonContractWrapper(contractAddress(workchain, init), init)
+    }
+
+    static bigintToAsciiString(num: bigint): string {
+        let result = ''
+        while (num > 0n) {
+            const charCode = Number(num & 255n)
+            result = String.fromCharCode(charCode) + result
+            num = num >> 8n
+        }
+        return result
+    }
 
-${generatedMethods}
+    ${generatedMethods}
 }
 `;
   fs__namespace.writeFileSync(path__namespace.join(directory, "TonContractWrapper.ts"), savedCode);
@@ -574,6 +760,11 @@ export class LzDict {
     }
 }
 
+export async function getLzDict(obj: Cell, fieldName: bigint, wrapper: ExtendedContract<TonContractWrapper>): Promise<LzDict> {
+    const dictCell = await wrapper.getClDict(obj, fieldName)
+    return new LzDict(dictCell)
+}
+
 export interface Md {}
 
 ${generatedTypes}
@@ -582,14 +773,8 @@ ${generatedNameMaps}
 `;
   fs__namespace.writeFileSync(path__namespace.join(directory, "allTypes.ts"), savedCode);
 }
-function saveTonObjectUnwrapper(tonObjects, directory) {
-  const allTypes = [
-    ...Object.values(tonObjects).map((obj) => obj.tsTypeName).filter((name) => name !== void 0),
-    "ExtendedContract",
-    "LzDict",
-    "Md",
-    "nameMap"
-  ].sort();
+function saveLzGasTracker(directory, opcodesImportPath) {
+  opcodesImportPath = opcodesImportPath ?? "../constants";
   const savedCode = `${file_signature_header}
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
@@ -598,106 +783,9 @@ import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric,
 import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
 import { flattenTransaction } from '@ton/test-utils'
 
-import { OPCODES } from '../constants'
-
-import {
-${allTypes.map((type) => "    " + type + ",\n").join("")}} from './allTypes'
-import { TonContractWrapper } from './TonContractWrapper'
-
-function bigintToAsciiString(num: bigint): string {
-    let result = ''
-    while (num > 0n) {
-        const charCode = Number(num & 255n)
-        result = String.fromCharCode(charCode) + result
-        num = num >> 8n
-    }
-    return result
-}
-
-export class LzEvent {
-    private _eventPromise: Promise<ActionEvent>
-    private _event: ActionEvent | null
-    public topic: string
-    public body: Md
-    public bodyName: string
-    public initialStorage: Cell
-    public initialized: boolean
-
-    constructor(wrapper: ExtendedContract<TonContractWrapper>, cell: Cell) {
-        this._eventPromise = TonObjectUnwrapper.getActionEventToTS(wrapper, cell)
-        this._event = null
-        this.topic = ''
-        this.body = {}
-        this.initialStorage = beginCell().endCell()
-        this.initialized = false
-        this.bodyName = ''
-    }
-
-    async load(wrapper: ExtendedContract<TonContractWrapper>): Promise<boolean> {
-        this._event = await this._eventPromise
-        this.topic = bigintToAsciiString(this._event.topic)
-        this.bodyName = await TonObjectUnwrapper.getTypeOf(wrapper, this._event.body)
-        const tsCasterName = 'get' + nameMap[this.bodyName] + 'ToTS'
-
-        const method = TonObjectUnwrapper[tsCasterName as keyof typeof TonObjectUnwrapper]
-        if (typeof method === 'function') {
-            this.body = await method(wrapper, this._event.body)
-        } else {
-            console.log('Method' + tsCasterName + 'does not exist.')
-        }
-
-        this.initialStorage = this._event.initialStorage
-        this.initialized = true
-        return this.initialized
-    }
-}
+import { OPCODES } from '${opcodesImportPath}'
 
-export class LzEventHandler {
-    public allFailures = {
-        txList: [] as BlockchainTransaction[],
-        events: [] as EventMessageSent[],
-    }
-    public allVictories = {
-        txList: [] as BlockchainTransaction[],
-        eventObjects: [] as LzEvent[],
-        packetsSent: [] as MdPacketSent[],
-    }   
-    async addCurrentEventsToAllEvents(results: SendMessageResult, contract: ExtendedContract<TonContractWrapper>): Promise<void> {
-        for (let i = 0; i < results.transactions.length; i++) {
-            const tx: BlockchainTransaction & Transaction = results.transactions[i]
-            const desc = tx.description
-            if (desc.type !== 'generic' || desc.computePhase.type !== 'skipped') continue
-    
-            const eventBody = tx.inMessage?.body
-            if (eventBody === undefined) continue
-            const eventBodySlice = eventBody.beginParse()
-            // the event body is empty if we are sending a payment with no corresponding payload
-            if (eventBodySlice.remainingBits < 32) continue
-            const opCode = eventBodySlice.loadUint(32)
-            if (opCode === Number(OPCODES.BaseInterface_OP_EVENT)) {
-                if (eventBody.refs.length > 0) {
-                    const eventInnerCell = eventBody.refs[0]
-                    const newLzEvent = new LzEvent(contract, eventInnerCell)
-                    await newLzEvent.load(contract)
-                    this.allVictories.txList.push(tx)
-                    this.allVictories.eventObjects.push(newLzEvent)
-                    if (newLzEvent.topic === 'Channel::event::PACKET_SENT' && this.isMdPacketSent(newLzEvent.body)) {
-                        this.allVictories.packetsSent.push(newLzEvent.body)
-                        // getMdLzSendToTS(contract, newLzEvent.body.lzSend)
-                    }
-                }
-            } else {
-                this.allFailures.txList.push(tx)
-                this.allFailures.events.push(results.events[i] as EventMessageSent)
-            }
-        }
-    }
-    isMdPacketSent(md: Md): md is MdPacketSent {
-        return 'nativeFee' in md && 'zroFee' in md && 'extraOptions' in md && 'enforcedOptions' in md && 'packetEncoded' in md && 'nonce' in md
-    }
-}
-
-interface GasStructure {
+export interface GasStructure {
     actionFee: bigint
     forwardFee: bigint
     computeFee: bigint
@@ -813,17 +901,35 @@ export class LzGasTracker {
         // Log the entire table
         return tableString
     }
+}`;
+  fs__namespace.writeFileSync(path__namespace.join(directory, "LzGasTracker.ts"), savedCode);
 }
+function saveTonObjectUnwrapper(tonObjects, directory) {
+  const allTypes = [
+    ...Object.values(tonObjects).map((obj) => obj.tsTypeName).filter((name) => name !== void 0),
+    "ExtendedContract",
+    "LzDict",
+    "Md",
+    "nameMap"
+  ].sort();
+  const savedCode = `${file_signature_header}
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
 
-async function getLzDict( obj: Cell, fieldName: bigint, wrapper: ExtendedContract<TonContractWrapper>): Promise<LzDict> {
-    const dictCell = await wrapper.getClDict(obj, fieldName)
-    return new LzDict(dictCell)
-}
+import { Cell, Transaction, TransactionComputeVm, TransactionDescriptionGeneric, beginCell } from '@ton/core'
+import { BlockchainTransaction, EventMessageSent, SendMessageResult } from '@ton/sandbox'
+import { flattenTransaction } from '@ton/test-utils'
+
+import { OPCODES } from '../constants'
+
+import { getLzDict,
+${allTypes.map((type) => "    " + type + ",\n").join("")}} from './allTypes'
+import { TonContractWrapper } from './TonContractWrapper'
 
 export class TonObjectUnwrapper {
     static async getTypeOf(provider: ExtendedContract<TonContractWrapper>, obj_cell: Cell): Promise<string> {
         const ret = await provider.getViewFunction('cl::typeof', [{ type: 'cell', cell: obj_cell }])
-        return bigintToAsciiString(ret.readBigNumber())
+        return TonContractWrapper.bigintToAsciiString(ret.readBigNumber())
     }
 ${Array.from(
     new Map(
@@ -6269,8 +6375,12 @@ exports.orderConfigToCell = orderConfigToCell;
 exports.parseDirectory = parseDirectory;
 exports.printTransactionTrace = printTransactionTrace;
 exports.saveAllTypes = saveAllTypes;
+exports.saveBaseEventHandler = saveBaseEventHandler;
+exports.saveClasslibWrapper = saveClasslibWrapper;
 exports.saveConstantsFile = saveConstantsFile;
 exports.saveEventsFile = saveEventsFile;
+exports.saveLzEventHandler = saveLzEventHandler;
+exports.saveLzGasTracker = saveLzGasTracker;
 exports.saveObjectsAsTS = saveObjectsAsTS;
 exports.saveTonContractWrapper = saveTonContractWrapper;
 exports.saveTonObjectUnwrapper = saveTonObjectUnwrapper;