feat: handle code with a single exotic cell, now we load actual code and return it along with originalCodeCell

Author: i582

src/methods.ts

@@ -291,38 +291,43 @@ export const getLibraryByHash = async (testnet: boolean, hash: string): Promise<
  * @param account   Current {@link ShardAccount} snapshot.
  * @param tx        Transaction whose `inMessage` may include `Init`.
  * @returns         Serialized dict cell or `undefined`
- *                  when no libraries are referenced.
+ *                  when no libraries are referenced and actual code cell if
+ *                  original code is just an exotic library cell
  */
 export const collectUsedLibraries = async (
     testnet: boolean,
     account: ShardAccount,
     tx: Transaction,
-): Promise<Cell | undefined> => {
+): Promise<[Cell | undefined, Cell | undefined]> => {
     const libs = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.Cell())
 
-    const addMaybeExoticLibrary = async (code: Cell | undefined): Promise<void> => {
+    const addMaybeExoticLibrary = async (code: Cell | undefined): Promise<Cell | undefined> => {
         const EXOTIC_LIBRARY_TAG = 2
-        if (code === undefined) return
-        if (code.bits.length !== 256 + 8) return // not an exotic library cell
+        if (code === undefined) return undefined
+        if (code.bits.length !== 256 + 8) return undefined // not an exotic library cell
 
         const cs = code.beginParse(true) // allow exotics
         const tag = cs.loadUint(8)
-        if (tag !== EXOTIC_LIBRARY_TAG) return // not a library cell
+        if (tag !== EXOTIC_LIBRARY_TAG) return undefined // not a library cell
 
         const libHash = cs.loadBuffer(32)
         const libHashHex = libHash.toString("hex").toUpperCase()
         const actualCode = await getLibraryByHash(testnet, libHashHex)
         libs.set(BigInt(`0x${libHashHex}`), actualCode)
+        return actualCode
     }
 
+    // if current contract code is exotic cell, we want to return actual code to the user
+    let loadedCellCode: Cell | undefined = undefined
+
     // 1. scan the *current* contract code for exotic‑library links
     const state = account.account?.storage.state
     if (state?.type === "active") {
         // The contract is already deployed and “active” so its `code`
         // cell may itself be a 264‑bit exotic library reference (tag 2).
         // If that’s the case, download the real library code and
         // register it in the `libs` dictionary.
-        await addMaybeExoticLibrary(state.state.code ?? undefined)
+        loadedCellCode = await addMaybeExoticLibrary(state.state.code ?? undefined)
     }
 
     // 2. scan the *incoming StateInit* (if present)
@@ -337,10 +342,10 @@ export const collectUsedLibraries = async (
     }
 
     // no libs found, return undefined, for emulator this means no libraries
-    if (libs.size === 0) return undefined
+    if (libs.size === 0) return [undefined, loadedCellCode]
 
     // emulator expects libraries as a Cell with immediate dictionary
-    return beginCell().storeDictDirect(libs).endCell()
+    return [beginCell().storeDictDirect(libs).endCell(), loadedCellCode]
 }
 
 /**

src/runner.ts

@@ -88,7 +88,7 @@ export const retrace = async (testnet: boolean, txLink: string): Promise<TraceRe
     // retrieve block config to pass it to emulator
     const blockConfig = await getBlockConfig(testnet, fullBlock)
     const shardAccountBeforeTx = await getBlockAccount(testnet, baseTx.address, fullBlock)
-    const libs = await collectUsedLibraries(testnet, shardAccountBeforeTx, tx.tx)
+    const [libs, loadedCode] = await collectUsedLibraries(testnet, shardAccountBeforeTx, tx.tx)
 
     // retrieve code cell if account in active mode
     const state = shardAccountBeforeTx.account?.storage.state
@@ -132,7 +132,8 @@ export const retrace = async (testnet: boolean, txLink: string): Promise<TraceRe
 
     return {
         stateUpdateHashOk,
-        codeCell,
+        codeCell: loadedCode ?? codeCell,
+        originalCodeCell: codeCell,
         inMsg: {
             sender,
             contract,

src/test/__snapshots__/test.spec.ts.snap

@@ -91,6 +91,7 @@ describe("transactions", () => {
     function checkResult(res: TraceResult, expectedOk: boolean = true): void {
         expect(res.stateUpdateHashOk).toEqual(expectedOk)
         expect(res.codeCell?.toBoc().toString("hex")).toMatchSnapshot()
+        expect(res.originalCodeCell?.toBoc().toString("hex")).toMatchSnapshot()
         expect(res.inMsg.sender?.toString()).toMatchSnapshot()
         expect(res.inMsg.contract.toString()).toMatchSnapshot()
         expect(res.inMsg.amount).toMatchSnapshot()

src/test/test.spec.ts

@@ -322,9 +322,15 @@ export interface TraceResult {
      */
     stateUpdateHashOk: boolean
     /**
-     * Code of an account before transaction
+     * Code of an account before transaction. If code is just an exotic cell,
+     * this field will contain actual library code, see {@link originalCodeCell}
+     * if you need original code cell.
      */
     codeCell: Cell | undefined
+    /**
+     * Code of an account before transaction
+     */
+    originalCodeCell: Cell | undefined
     /**
      * Information about in-message
      */