@subsquid/solana-normalization 0.0.3 → 1.0.0-portal-api.d887ad

package/lib/transaction-context.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionContext = void 0;
+const assert_1 = __importDefault(require("assert"));
+class TransactionContext {
+    constructor(transactionIndex, tx, journal) {
+        this.transactionIndex = transactionIndex;
+        this.tx = tx;
+        this.journal = journal;
+        if (tx.version == 'legacy') {
+            this.accounts = tx.transaction.message.accountKeys;
+        }
+        else {
+            this.accounts = tx.transaction.message.accountKeys.concat(tx.meta.loadedAddresses?.writable ?? [], tx.meta.loadedAddresses?.readonly ?? []);
+        }
+        let err = this.tx.meta.err;
+        if (err && 'InstructionError' in err) {
+            let pos = err.InstructionError?.[0];
+            let type = err.InstructionError?.[1];
+            if (Number.isSafeInteger(pos)) {
+                this.erroredInstruction = pos;
+            }
+            else {
+                this.erroredInstruction = tx.transaction.message.instructions.length;
+                this.warn({ transactionError: err }, 'got InstructionError of unrecognized shape');
+            }
+            this.exceededCallDepth = type === 'CallDepth';
+        }
+        else {
+            this.erroredInstruction = tx.transaction.message.instructions.length;
+            this.exceededCallDepth = false;
+        }
+    }
+    get isCommitted() {
+        return this.tx.meta.err == null;
+    }
+    get transactionHash() {
+        return this.tx.transaction.signatures[0];
+    }
+    getAccount(index) {
+        (0, assert_1.default)(index < this.accounts.length);
+        return this.accounts[index];
+    }
+    warn(props, msg) {
+        this.journal.warn({
+            transactionHash: this.transactionHash,
+            transactionIndex: this.transactionIndex,
+            ...props
+        }, msg);
+    }
+    error(props, msg) {
+        this.journal.error({
+            transactionHash: this.transactionHash,
+            transactionIndex: this.transactionIndex,
+            ...props
+        }, msg);
+    }
+}
+exports.TransactionContext = TransactionContext;
+//# sourceMappingURL=transaction-context.js.map

package/lib/transaction-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-context.js","sourceRoot":"","sources":["../src/transaction-context.ts"],"names":[],"mappings":";;;;;;AAEA,oDAA2B;AAS3B,MAAa,kBAAkB;IAM3B,YACoB,gBAAwB,EACxB,EAAmB,EAC3B,OAAgB;QAFR,qBAAgB,GAAhB,gBAAgB,CAAQ;QACxB,OAAE,GAAF,EAAE,CAAiB;QAC3B,YAAO,GAAP,OAAO,CAAS;QAExB,IAAI,EAAE,CAAC,OAAO,IAAI,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,WAAW,CAAA;QACtD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CACrD,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,IAAI,EAAE,EACvC,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,IAAI,EAAE,CAC1C,CAAA;QACL,CAAC;QAED,IAAI,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAA;QAC1B,IAAI,GAAG,IAAI,kBAAkB,IAAI,GAAG,EAAE,CAAC;YACnC,IAAI,GAAG,GAAG,GAAG,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAA;YACnC,IAAI,IAAI,GAAG,GAAG,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAA;YACpC,IAAI,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5B,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAA;YACjC,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAA;gBACpE,IAAI,CAAC,IAAI,CAAC,EAAC,gBAAgB,EAAE,GAAG,EAAC,EAAE,4CAA4C,CAAC,CAAA;YACpF,CAAC;YACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,KAAK,WAAW,CAAA;QACjD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAA;YACpE,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAA;QAClC,CAAC;IACL,CAAC;IAED,IAAI,WAAW;QACX,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAA;IACnC,CAAC;IAED,IAAI,eAAe;QACf,OAAO,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;IAC5C,CAAC;IAED,UAAU,CAAC,KAAa;QACpB,IAAA,gBAAM,EAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;QACpC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAC/B,CAAC;IAED,IAAI,CAAC,KAAU,EAAE,GAAW;QACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YACd,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,GAAG,KAAK;SACX,EAAE,GAAG,CAAC,CAAA;IACX,CAAC;IAED,KAAK,CAAC,KAAU,EAAE,GAAW;QACzB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YACf,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,GAAG,KAAK;SACX,EAAE,GAAG,CAAC,CAAA;IACX,CAAC;CACJ;AAjED,gDAiEC"}

package/lib/votes.d.ts

@@ -0,0 +1,3 @@
+import { Block } from './data';
+export declare function removeVotes(block: Block): void;
+//# sourceMappingURL=votes.d.ts.map

package/lib/votes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"votes.d.ts","sourceRoot":"","sources":["../src/votes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,QAAQ,CAAA;AAG5B,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAkB9C"}

package/lib/votes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeVotes = removeVotes;
+function removeVotes(block) {
+    let removed = new Set();
+    for (let i of block.instructions) {
+        if (i.programId == 'Vote111111111111111111111111111111111111111') {
+            removed.add(i.transactionIndex);
+        }
+    }
+    function kept(item) {
+        return !removed.has(item.transactionIndex);
+    }
+    block.transactions = block.transactions.filter(kept);
+    block.instructions = block.instructions.filter(kept);
+    block.logs = block.logs.filter(kept);
+    block.balances = block.balances.filter(kept);
+    block.tokenBalances = block.tokenBalances.filter(kept);
+}
+//# sourceMappingURL=votes.js.map

package/lib/votes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"votes.js","sourceRoot":"","sources":["../src/votes.ts"],"names":[],"mappings":";;AAGA,kCAkBC;AAlBD,SAAgB,WAAW,CAAC,KAAY;IACpC,IAAI,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;IAE/B,KAAK,IAAI,CAAC,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;QAC/B,IAAI,CAAC,CAAC,SAAS,IAAI,6CAA6C,EAAE,CAAC;YAC/D,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAA;QACnC,CAAC;IACL,CAAC;IAED,SAAS,IAAI,CAAC,IAAgC;QAC1C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;IAC9C,CAAC;IAED,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACpD,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACpD,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACpC,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC5C,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;AAC1D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subsquid/solana-normalization",
-  "version": "0.0.3",
+  "version": "1.0.0-portal-api.d887ad",
   "description": "Solana data model",
   "license": "GPL-3.0-or-later",
   "repository": "git@github.com:subsquid/squid.git",
@@ -13,13 +13,15 @@
   ],
   "main": "lib/index.js",
   "dependencies": {
-    "@subsquid/solana-rpc-data": "^0.0.3",
-    "@subsquid/util-internal": "^3.2.0",
+    "@subsquid/solana-rpc-data": "1.0.0-portal-api.d887ad",
+    "@subsquid/util-internal": "3.3.0-portal-api.d887ad",
     "@subsquid/util-internal-validation": "^0.7.0"
   },
   "devDependencies": {
+    "@subsquid/util-internal-json": "^1.2.3",
+    "@subsquid/util-internal-json-fix-unsafe-integers": "^0.0.0",
     "@types/node": "^18.18.14",
-    "typescript": "~5.3.2"
+    "typescript": "5.5.4"
   },
   "scripts": {
     "build": "rm -rf lib && tsc"

package/src/archive.ts

@@ -0,0 +1,186 @@
+import {Base58Bytes} from '@subsquid/solana-rpc-data'
+import * as norm from './data'
+
+
+/**
+ * Block account index
+ */
+export type AccountIndex = number
+
+
+export interface Block {
+    header: BlockHeader
+    accounts: Base58Bytes[]
+    transactions: Transaction[]
+    instructions: Instruction[]
+    logs: LogMessage[]
+    balances: Balance[]
+    tokenBalances: TokenBalance[]
+    rewards: Reward[]
+}
+
+
+export interface BlockHeader {
+    number: number
+    hash: string
+    parentNumber: number
+    parentHash: string
+    height?: number
+    timestamp?: number
+}
+
+
+export type Transaction = Omit<norm.Transaction, 'accountKeys' | 'addressTableLookups' | 'loadedAddresses'> & {
+    accountKeys: AccountIndex[]
+    addressTableLookups: AddressTableLookup[]
+    loadedAddresses: {
+        readonly: AccountIndex[]
+        writable: AccountIndex[]
+    }
+}
+
+
+export interface AddressTableLookup {
+    accountKey: AccountIndex
+    readonlyIndexes: number[]
+    writableIndexes: number[]
+}
+
+
+export type Instruction = Omit<norm.Instruction, 'programId' | 'accounts'> & {
+    programId: AccountIndex
+    accounts: AccountIndex[]
+}
+
+
+export type LogMessage = Omit<norm.LogMessage, 'programId'> & {
+    programId: AccountIndex
+}
+
+
+export type Balance = Omit<norm.Balance, 'account'> & {
+    account: AccountIndex
+}
+
+
+export type TokenBalance = PatchAccounts<norm.TokenBalance>
+
+
+type PatchAccounts<T> = {
+    [K in keyof T]: T[K] extends string ? AccountIndex : T[K]
+}
+
+
+export type Reward = Omit<norm.Reward, 'pubkey'> & {
+    pubkey: AccountIndex
+}
+
+
+export function toArchiveBlock(block: norm.Block): Block {
+    let dict = new AccountDict()
+
+    let {
+        header: {number: slot, parentNumber: parentSlot, ...hdr}
+    } = block
+
+    let header = {
+        number: slot,
+        parentNumber: parentSlot,
+        ...hdr
+    }
+
+    let transactions = block.transactions.map(tx => {
+        let {accountKeys, addressTableLookups, loadedAddresses, ...props} = tx
+        return {
+            ...props,
+            accountKeys: accountKeys.map(a => dict.get(a)),
+            addressTableLookups: addressTableLookups.map(lookup => {
+                return {
+                    accountKey: dict.get(lookup.accountKey),
+                    readonlyIndexes: lookup.readonlyIndexes,
+                    writableIndexes: lookup.writableIndexes
+                }
+            }),
+            loadedAddresses: {
+                readonly: loadedAddresses.readonly.map(a => dict.get(a)),
+                writable: loadedAddresses.writable.map(a => dict.get(a))
+            }
+        }
+    })
+
+    let instructions = block.instructions.map(ins => {
+        let {programId, accounts, ...props} = ins
+        return {
+            ...props,
+            programId: dict.get(programId),
+            accounts: accounts.map(a => dict.get(a))
+        }
+    })
+
+    let logs = block.logs.map(rec => {
+        let {programId, ...props} = rec
+        return {
+            ...props,
+            programId: dict.get(programId)
+        }
+    })
+
+    let balances = block.balances.map(b => {
+        let {account, ...props} = b
+        return {
+            ...props,
+            account: dict.get(account)
+        }
+    })
+
+    let tokenBalances: TokenBalance[] = block.tokenBalances.map(b => {
+        let res: any = {}
+        let key: keyof norm.TokenBalance
+        for (key in b) {
+            let val = b[key]
+            if (typeof val == 'string') {
+                res[key] = dict.get(val)
+            } else {
+                res[key] = val
+            }
+        }
+        return res
+    })
+
+    let rewards = block.rewards.map(reward => {
+        let {pubkey, ...props} = reward
+        return {
+            pubkey: dict.get(pubkey),
+            ...props
+        }
+    })
+
+    return {
+        header,
+        accounts: dict.list(),
+        transactions,
+        instructions,
+        logs,
+        balances,
+        tokenBalances,
+        rewards
+    }
+}
+
+
+class AccountDict {
+    private map = new Map<Base58Bytes, AccountIndex>
+
+    get(account: Base58Bytes): AccountIndex {
+        let idx = this.map.get(account)
+        if (idx == null) {
+            idx = this.map.size
+            this.map.set(account, idx)
+        }
+        return idx
+    }
+
+    list(): Base58Bytes[] {
+        return Array.from(this.map.keys())
+    }
+}

package/src/data.ts

@@ -2,10 +2,10 @@ import type {Base58Bytes} from '@subsquid/solana-rpc-data'
 
 
 export interface BlockHeader {
+    number: number
     hash: Base58Bytes
     height: number
-    slot: number
-    parentSlot: number
+    parentNumber: number
     parentHash: Base58Bytes
     timestamp: number
 }

package/src/index.ts

@@ -1,2 +1,4 @@
+export * as archive from './archive'
 export * from './data'
 export * from './mapping'
+export * from './votes'

package/src/instruction-parser.ts

@@ -0,0 +1,344 @@
+import * as rpc from '@subsquid/solana-rpc-data'
+import {unexpectedCase} from '@subsquid/util-internal'
+import assert from 'assert'
+import {Instruction, LogMessage} from './data'
+import {Message, parseLogMessage} from './log-parser'
+import {TransactionContext} from './transaction-context'
+
+
+const PROGRAMS_MISSING_INVOKE_LOG = new Set([
+    'AddressLookupTab1e1111111111111111111111111',
+    'BPFLoader1111111111111111111111111111111111',
+    'BPFLoader2111111111111111111111111111111111',
+    'BPFLoaderUpgradeab1e11111111111111111111111',
+    'Ed25519SigVerify111111111111111111111111111',
+    'KeccakSecp256k11111111111111111111111111111',
+    'NativeLoader1111111111111111111111111111111',
+    'ZkTokenProof1111111111111111111111111111111'
+])
+
+
+export class ParsingError {
+    instructionIndex?: number
+    innerInstructionIndex?: number
+    logMessageIndex?: number
+
+    constructor(
+        public msg: string
+    ) {
+    }
+}
+
+
+export class MessageStream {
+    private messages: Message[]
+    private pos = 0
+
+    constructor(messages: string[]) {
+        this.messages = messages.map(parseLogMessage)
+    }
+
+    get unfinished(): boolean {
+        return !this.ended
+    }
+
+    get ended(): boolean {
+        return this.pos >= this.messages.length || this.messages[this.pos].kind == 'truncate'
+    }
+
+    get truncated(): boolean {
+        return this.pos < this.messages.length && this.messages[this.pos].kind == 'truncate'
+    }
+
+    get current(): Message {
+        assert(this.pos < this.messages.length, 'eof reached')
+        return this.messages[this.pos]
+    }
+
+    get position(): number {
+        return this.pos
+    }
+
+    advance(): boolean {
+        if (this.truncated) return false
+        this.pos = Math.min(this.pos + 1, this.messages.length)
+        return this.pos < this.messages.length
+    }
+}
+
+
+export class InstructionTreeTraversal {
+    private lastAddress: number[]
+    private instructions: rpc.Instruction[]
+    private pos = 0
+
+    constructor(
+        private tx: TransactionContext,
+        private messages: MessageStream,
+        private instructionIndex: number,
+        instruction: rpc.Instruction,
+        inner: rpc.Instruction[],
+        private output: Instruction[],
+        private log: LogMessage[]
+    ) {
+        this.lastAddress = [instructionIndex - 1]
+        this.instructions = [instruction, ...inner]
+        if (this.tx.erroredInstruction >= this.instructionIndex) {
+            this.call(1)
+            this.finishLogLess()
+        } else {
+            this.assert(
+                this.instructions.length === 1,
+                'failed instructions should not have inner calls'
+            )
+            this.push(1)
+        }
+    }
+
+    private call(stackHeight: number): void {
+        let ins = this.current
+
+        this.assert(
+            ins.stackHeight == null || ins.stackHeight === stackHeight,
+            'stack height mismatch',
+            this.pos
+        )
+
+        let programId = this.tx.getAccount(ins.programIdIndex)
+
+        if (
+            this.messages.unfinished &&
+            this.messages.current.kind === 'invoke' &&
+            this.messages.current.programId === programId
+        ) {
+            this.assert(
+                this.messages.current.stackHeight === stackHeight,
+                'invoke message has unexpected stack height',
+                this.pos,
+                this.messages.position
+            )
+            this.messages.advance()
+            this.invoke(stackHeight)
+            return
+        }
+
+        if (this.messages.truncated) {
+            return
+        }
+
+        if (PROGRAMS_MISSING_INVOKE_LOG.has(programId)) {
+            this.push(stackHeight).hasDroppedLogMessages = true
+            this.dropNonInvokeMessages()
+            return
+        }
+
+        if (this.messages.ended) {
+            throw this.error('unexpected end of message log', this.pos)
+        }
+
+        throw this.error('missing invoke message', this.pos, this.messages.position)
+    }
+
+    private invoke(stackHeight: number): void {
+        let pos = this.pos
+        let ins = this.push(stackHeight)
+
+        this.takeInstructionMessages(ins, pos)
+
+        if (this.messages.truncated) {
+            ins.hasDroppedLogMessages = true
+            return
+        }
+
+        if (this.messages.ended) {
+            throw this.error('unexpected end of log', pos)
+        }
+
+        let result = this.messages.current
+        assert(result.kind === 'invoke-result')
+        this.assert(
+            result.programId === ins.programId,
+            'invoke result message and instruction program ids don\'t match'
+        )
+        ins.error = result.error
+        this.messages.advance()
+
+        // consume invoke-less subcalls,
+        // that might have left unvisited due to missing 'invoke' messages
+        this.eatInvokeLessSubCalls(ins)
+    }
+
+    private eatInvokeLessSubCalls(parent: Instruction) {
+        while (this.unfinished) {
+            let stackHeight: number
+            if (this.current.stackHeight == null) {
+                if (parent.error) {
+                    // all remaining calls must belong to the given parent
+                    stackHeight = parent.instructionAddress.length + 1
+                } else {
+                    stackHeight = 2
+                }
+            } else {
+                stackHeight = this.current.stackHeight
+            }
+
+            if (stackHeight <= parent.instructionAddress.length) return
+
+            let pos = this.pos
+            let ins = this.push(stackHeight)
+
+            // even if we have some messages emitted,
+            // we already assigned them to parent call
+            ins.hasDroppedLogMessages = true
+
+            if (PROGRAMS_MISSING_INVOKE_LOG.has(ins.programId)) {
+                // all good, it is expected to not have 'invoke' message
+            } else if (
+                this.tx.exceededCallDepth &&
+                this.tx.erroredInstruction == this.instructionIndex &&
+                this.ended
+            ) {
+                // we've reached the max stack depth,
+                // there will be no invoke message either
+            } else {
+                this.tx.error({
+                    instruction: this.instructionIndex,
+                    innerInstruction: pos - 1
+                }, 'missing invoke message for inner instruction')
+            }
+        }
+    }
+
+    private takeInstructionMessages(ins: Instruction, pos: number): void {
+        while (this.messages.unfinished) {
+            let msg = this.messages.current
+            switch(msg.kind) {
+                case 'log':
+                case 'data':
+                case 'other':
+                    this.log.push({
+                        transactionIndex: this.tx.transactionIndex,
+                        logIndex: this.messages.position,
+                        instructionAddress: ins.instructionAddress,
+                        programId: ins.programId,
+                        kind: msg.kind,
+                        message: msg.message
+                    })
+                    this.messages.advance()
+                    break
+                case 'cu':
+                    if (ins.programId == msg.programId) {
+                        ins.computeUnitsConsumed = msg.consumed
+                        this.messages.advance()
+                    } else {
+                        throw this.error(
+                            'unexpected programId in compute unit message',
+                            pos,
+                            this.messages.position
+                        )
+                    }
+                    break
+                case 'invoke':
+                    this.call(ins.instructionAddress.length + 1)
+                    break
+                case 'invoke-result':
+                case 'truncate':
+                    return
+                default:
+                    throw unexpectedCase()
+            }
+        }
+    }
+
+    private dropNonInvokeMessages(): void {
+        while (this.messages.unfinished) {
+            let msg = this.messages.current
+            switch(msg.kind) {
+                case 'log':
+                case 'data':
+                case 'cu':
+                case 'other':
+                    this.messages.advance()
+                    break
+                case 'invoke':
+                case 'invoke-result':
+                case 'truncate':
+                    return
+                default:
+                    throw unexpectedCase()
+            }
+        }
+    }
+
+    private finishLogLess(): void {
+        while (this.unfinished) {
+            this.push(this.current.stackHeight ?? 2).hasDroppedLogMessages = true
+        }
+    }
+
+    private get current(): rpc.Instruction {
+        assert(this.pos < this.instructions.length)
+        return this.instructions[this.pos]
+    }
+
+    private get unfinished(): boolean {
+        return this.pos < this.instructions.length
+    }
+
+    private get ended(): boolean {
+        return !this.unfinished
+    }
+
+    private assert(ok: any, msg: string, pos?: number, messagePos?: number): void {
+        if (!ok) throw this.error(msg, pos, messagePos)
+    }
+
+    private error(msg: string, pos?: number, messagePos?: number): ParsingError {
+        let err = new ParsingError(msg)
+        err.instructionIndex = this.instructionIndex
+        if (pos) {
+            err.innerInstructionIndex = pos - 1
+        }
+        if (messagePos != null) {
+            err.logMessageIndex = messagePos
+        }
+        return err
+    }
+
+    private push(stackHeight: number): Instruction {
+        assert(stackHeight > 0)
+
+        let ins = this.current
+        if (ins.stackHeight != null) {
+            assert(stackHeight === ins.stackHeight)
+        }
+
+        let address = this.lastAddress.slice()
+
+        while (address.length > stackHeight) {
+            address.pop()
+        }
+
+        if (address.length === stackHeight) {
+            address[stackHeight - 1] += 1
+        } else {
+            assert(address.length + 1 == stackHeight)
+            address[stackHeight - 1] = 0
+        }
+
+        let mapped: Instruction = {
+            transactionIndex: this.tx.transactionIndex,
+            instructionAddress: address,
+            programId: this.tx.getAccount(ins.programIdIndex),
+            accounts: ins.accounts.map(a => this.tx.getAccount(a)),
+            data: ins.data,
+            isCommitted: this.tx.isCommitted,
+            hasDroppedLogMessages: false
+        }
+
+        this.output.push(mapped)
+        this.lastAddress = address
+        this.pos = Math.min(this.pos + 1, this.instructions.length)
+        return mapped
+    }
+}