@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/dist/solana/program/SolanaProgramBase.d.ts

@@ -1,73 +1,73 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Idl, Program } from "@coral-xyz/anchor";
-import { SolanaChainInterface } from "../chain/SolanaChainInterface";
-import { SolanaProgramEvents } from "./modules/SolanaProgramEvents";
-import { Keypair, PublicKey } from "@solana/web3.js";
-import { Buffer } from "buffer";
-/**
- * Base class providing program specific utilities
- */
-export declare class SolanaProgramBase<T extends Idl> {
-    /**
-     * @internal
-     */
-    protected readonly logger: {
-        debug: (msg: string, ...args: any[]) => false | void;
-        info: (msg: string, ...args: any[]) => false | void;
-        warn: (msg: string, ...args: any[]) => false | void;
-        error: (msg: string, ...args: any[]) => false | void;
-    };
-    program: Program<T>;
-    /**
-     * @internal
-     */
-    readonly _Events: SolanaProgramEvents<T>;
-    /**
-     * @internal
-     */
-    readonly _Chain: SolanaChainInterface;
-    constructor(chainInterface: SolanaChainInterface, programIdl: any, programAddress?: string);
-    /**
-     * Derives static PDA address from the seed
-     *
-     * @param seed
-     *
-     * @internal
-     */
-    protected pda(seed: string): PublicKey;
-    /**
-     * Returns a function for deriving a dynamic PDA address from seed + dynamic arguments
-     *
-     * @param seed
-     * @param func function translating the function argument to Buffer[]
-     *
-     * @internal
-     */
-    protected pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (...args: T) => PublicKey;
-    /**
-     * Derives static PDA address from the seed
-     *
-     * @param seed
-     *
-     * @internal
-     */
-    static _pda(seed: string): (programId: PublicKey) => PublicKey;
-    /**
-     * Returns a function for deriving a dynamic PDA address from seed + dynamic arguments
-     *
-     * @param seed
-     * @param func function translating the function argument to Buffer[]
-     *
-     * @internal
-     */
-    static _pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (programId: PublicKey, ...args: T) => PublicKey;
-    /**
-     * Returns a function for deriving a dynamic deterministic keypair from dynamic arguments
-     *
-     * @param func function translating the function argument to Buffer[] to be used for deriving the keypair
-     *
-     * @internal
-     */
-    _keypair<T extends Array<any>>(func: (...args: T) => Buffer[]): (...args: T) => Keypair;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+import { Idl, Program } from "@coral-xyz/anchor";
+import { SolanaChainInterface } from "../chain/SolanaChainInterface";
+import { SolanaProgramEvents } from "./modules/SolanaProgramEvents";
+import { Keypair, PublicKey } from "@solana/web3.js";
+import { Buffer } from "buffer";
+/**
+ * Base class providing program specific utilities
+ */
+export declare class SolanaProgramBase<T extends Idl> {
+    /**
+     * @internal
+     */
+    protected readonly logger: {
+        debug: (msg: string, ...args: any[]) => false | void;
+        info: (msg: string, ...args: any[]) => false | void;
+        warn: (msg: string, ...args: any[]) => false | void;
+        error: (msg: string, ...args: any[]) => false | void;
+    };
+    program: Program<T>;
+    /**
+     * @internal
+     */
+    readonly _Events: SolanaProgramEvents<T>;
+    /**
+     * @internal
+     */
+    readonly _Chain: SolanaChainInterface;
+    constructor(chainInterface: SolanaChainInterface, programIdl: any, programAddress?: string);
+    /**
+     * Derives static PDA address from the seed
+     *
+     * @param seed
+     *
+     * @internal
+     */
+    protected pda(seed: string): PublicKey;
+    /**
+     * Returns a function for deriving a dynamic PDA address from seed + dynamic arguments
+     *
+     * @param seed
+     * @param func function translating the function argument to Buffer[]
+     *
+     * @internal
+     */
+    protected pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (...args: T) => PublicKey;
+    /**
+     * Derives static PDA address from the seed
+     *
+     * @param seed
+     *
+     * @internal
+     */
+    static _pda(seed: string): (programId: PublicKey) => PublicKey;
+    /**
+     * Returns a function for deriving a dynamic PDA address from seed + dynamic arguments
+     *
+     * @param seed
+     * @param func function translating the function argument to Buffer[]
+     *
+     * @internal
+     */
+    static _pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (programId: PublicKey, ...args: T) => PublicKey;
+    /**
+     * Returns a function for deriving a dynamic deterministic keypair from dynamic arguments
+     *
+     * @param func function translating the function argument to Buffer[] to be used for deriving the keypair
+     *
+     * @internal
+     */
+    _keypair<T extends Array<any>>(func: (...args: T) => Buffer[]): (...args: T) => Keypair;
+}

package/dist/solana/program/SolanaProgramBase.js

@@ -1,54 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaProgramBase = void 0;
-const anchor_1 = require("@coral-xyz/anchor");
-const SolanaProgramEvents_1 = require("./modules/SolanaProgramEvents");
-const web3_js_1 = require("@solana/web3.js");
-const sha2_1 = require("@noble/hashes/sha2");
-const buffer_1 = require("buffer");
-const SolanaKeypairWallet_1 = require("../wallet/SolanaKeypairWallet");
-const Utils_1 = require("../../utils/Utils");
-/**
- * Base class providing program specific utilities
- */
-class SolanaProgramBase {
-    constructor(chainInterface, programIdl, programAddress) {
-        /**
-         * @internal
-         */
-        this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
-        this._Chain = chainInterface;
-        this.program = new anchor_1.Program(programIdl, programAddress || programIdl.metadata.address, new anchor_1.AnchorProvider(chainInterface._connection, new SolanaKeypairWallet_1.SolanaKeypairWallet(web3_js_1.Keypair.generate()), {}));
-        this._Events = new SolanaProgramEvents_1.SolanaProgramEvents(chainInterface, this);
-    }
-    pda(seed, func) {
-        if (func == null) {
-            return SolanaProgramBase._pda(seed)(this.program.programId);
-        }
-        return SolanaProgramBase._pda(seed, func).bind(this, this.program.programId);
-    }
-    static _pda(seed, func) {
-        if (func == null) {
-            return (programId) => web3_js_1.PublicKey.findProgramAddressSync([buffer_1.Buffer.from(seed)], programId)[0];
-        }
-        return (programId, ...args) => {
-            const res = func(...args);
-            return web3_js_1.PublicKey.findProgramAddressSync([buffer_1.Buffer.from(seed)].concat(res), programId)[0];
-        };
-    }
-    /**
-     * Returns a function for deriving a dynamic deterministic keypair from dynamic arguments
-     *
-     * @param func function translating the function argument to Buffer[] to be used for deriving the keypair
-     *
-     * @internal
-     */
-    _keypair(func) {
-        return (...args) => {
-            const res = func(...args);
-            const buff = (0, sha2_1.sha256)(buffer_1.Buffer.concat(res));
-            return web3_js_1.Keypair.fromSeed(buff);
-        };
-    }
-}
-exports.SolanaProgramBase = SolanaProgramBase;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaProgramBase = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const SolanaProgramEvents_1 = require("./modules/SolanaProgramEvents");
+const web3_js_1 = require("@solana/web3.js");
+const sha2_1 = require("@noble/hashes/sha2");
+const buffer_1 = require("buffer");
+const SolanaKeypairWallet_1 = require("../wallet/SolanaKeypairWallet");
+const Utils_1 = require("../../utils/Utils");
+/**
+ * Base class providing program specific utilities
+ */
+class SolanaProgramBase {
+    constructor(chainInterface, programIdl, programAddress) {
+        /**
+         * @internal
+         */
+        this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
+        this._Chain = chainInterface;
+        this.program = new anchor_1.Program(programIdl, programAddress || programIdl.metadata.address, new anchor_1.AnchorProvider(chainInterface._connection, new SolanaKeypairWallet_1.SolanaKeypairWallet(web3_js_1.Keypair.generate()), {}));
+        this._Events = new SolanaProgramEvents_1.SolanaProgramEvents(chainInterface, this);
+    }
+    pda(seed, func) {
+        if (func == null) {
+            return SolanaProgramBase._pda(seed)(this.program.programId);
+        }
+        return SolanaProgramBase._pda(seed, func).bind(this, this.program.programId);
+    }
+    static _pda(seed, func) {
+        if (func == null) {
+            return (programId) => web3_js_1.PublicKey.findProgramAddressSync([buffer_1.Buffer.from(seed)], programId)[0];
+        }
+        return (programId, ...args) => {
+            const res = func(...args);
+            return web3_js_1.PublicKey.findProgramAddressSync([buffer_1.Buffer.from(seed)].concat(res), programId)[0];
+        };
+    }
+    /**
+     * Returns a function for deriving a dynamic deterministic keypair from dynamic arguments
+     *
+     * @param func function translating the function argument to Buffer[] to be used for deriving the keypair
+     *
+     * @internal
+     */
+    _keypair(func) {
+        return (...args) => {
+            const res = func(...args);
+            const buff = (0, sha2_1.sha256)(buffer_1.Buffer.concat(res));
+            return web3_js_1.Keypair.fromSeed(buff);
+        };
+    }
+}
+exports.SolanaProgramBase = SolanaProgramBase;

package/dist/solana/program/SolanaProgramModule.d.ts

@@ -1,8 +1,8 @@
-import { SolanaModule } from "../chain/SolanaModule";
-import { Idl } from "@coral-xyz/anchor";
-import { SolanaProgramBase } from "./SolanaProgramBase";
-import { SolanaChainInterface } from "../chain/SolanaChainInterface";
-export declare class SolanaProgramModule<IDL extends Idl> extends SolanaModule {
-    protected readonly program: SolanaProgramBase<IDL>;
-    constructor(chainInterface: SolanaChainInterface, program: SolanaProgramBase<IDL>);
-}
+import { SolanaModule } from "../chain/SolanaModule";
+import { Idl } from "@coral-xyz/anchor";
+import { SolanaProgramBase } from "./SolanaProgramBase";
+import { SolanaChainInterface } from "../chain/SolanaChainInterface";
+export declare class SolanaProgramModule<IDL extends Idl> extends SolanaModule {
+    protected readonly program: SolanaProgramBase<IDL>;
+    constructor(chainInterface: SolanaChainInterface, program: SolanaProgramBase<IDL>);
+}

package/dist/solana/program/SolanaProgramModule.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaProgramModule = void 0;
-const SolanaModule_1 = require("../chain/SolanaModule");
-class SolanaProgramModule extends SolanaModule_1.SolanaModule {
-    constructor(chainInterface, program) {
-        super(chainInterface);
-        this.program = program;
-    }
-}
-exports.SolanaProgramModule = SolanaProgramModule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaProgramModule = void 0;
+const SolanaModule_1 = require("../chain/SolanaModule");
+class SolanaProgramModule extends SolanaModule_1.SolanaModule {
+    constructor(chainInterface, program) {
+        super(chainInterface);
+        this.program = program;
+    }
+}
+exports.SolanaProgramModule = SolanaProgramModule;

package/dist/solana/program/modules/SolanaProgramEvents.d.ts

@@ -1,53 +1,53 @@
-import { SolanaEvents } from "../../chain/modules/SolanaEvents";
-import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
-import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
-import { ParsedMessage, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
-import { SolanaProgramBase } from "../SolanaProgramBase";
-import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
-type DecodedFieldOrNull<D, Defined> = D extends IdlField ? DecodeType<D["type"], Defined> : unknown;
-type ArgsTuple<A extends IdlField[], Defined> = {
-    [K in A[number]["name"]]: DecodedFieldOrNull<Extract<A[number], {
-        name: K;
-    }>, Defined>;
-};
-export type InstructionWithAccounts<IDL extends Idl> = SingleInstructionWithAccounts<IDL["instructions"][number], IDL>;
-export type SingleInstructionWithAccounts<I extends IdlInstruction, IDL extends Idl> = {
-    name: I["name"];
-    accounts: {
-        [key in I["accounts"][number]["name"]]: PublicKey;
-    };
-    data: ArgsTuple<I["args"], IdlTypes<IDL>>;
-};
-export type ProgramEvent<IDL extends Idl> = Event<NonNullable<IDL["events"]>[number], Record<string, any>>;
-export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
-    private readonly programCoder;
-    private readonly eventParser;
-    private readonly program;
-    private readonly nameMappedInstructions;
-    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>);
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param topicKey
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
-     * @param startBlockheight
-     */
-    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T | null | undefined>, abortSignal?: AbortSignal, logBatchSize?: number, startBlockheight?: number): Promise<T | null>;
-    /**
-     * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
-     *  for every instruction that doesn't correspond to this program (as those are impossible to parse)
-     *
-     * @param transactionMessage
-     */
-    decodeInstructions(transactionMessage: ParsedMessage): (InstructionWithAccounts<IDL> | null)[];
-    /**
-     * Parses program event related to this program from transaction logs
-     *
-     * @param logs
-     */
-    parseLogs(logs: string[]): ProgramEvent<IDL>[];
-}
-export {};
+import { SolanaEvents } from "../../chain/modules/SolanaEvents";
+import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
+import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
+import { ParsedMessage, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
+import { SolanaProgramBase } from "../SolanaProgramBase";
+import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
+type DecodedFieldOrNull<D, Defined> = D extends IdlField ? DecodeType<D["type"], Defined> : unknown;
+type ArgsTuple<A extends IdlField[], Defined> = {
+    [K in A[number]["name"]]: DecodedFieldOrNull<Extract<A[number], {
+        name: K;
+    }>, Defined>;
+};
+export type InstructionWithAccounts<IDL extends Idl> = SingleInstructionWithAccounts<IDL["instructions"][number], IDL>;
+export type SingleInstructionWithAccounts<I extends IdlInstruction, IDL extends Idl> = {
+    name: I["name"];
+    accounts: {
+        [key in I["accounts"][number]["name"]]: PublicKey;
+    };
+    data: ArgsTuple<I["args"], IdlTypes<IDL>>;
+};
+export type ProgramEvent<IDL extends Idl> = Event<NonNullable<IDL["events"]>[number], Record<string, any>>;
+export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
+    private readonly programCoder;
+    private readonly eventParser;
+    private readonly program;
+    private readonly nameMappedInstructions;
+    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>);
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param topicKey
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
+     */
+    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T | null | undefined>, abortSignal?: AbortSignal, logBatchSize?: number, startBlockheight?: number): Promise<T | null>;
+    /**
+     * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
+     *  for every instruction that doesn't correspond to this program (as those are impossible to parse)
+     *
+     * @param transactionMessage
+     */
+    decodeInstructions(transactionMessage: ParsedMessage): (InstructionWithAccounts<IDL> | null)[];
+    /**
+     * Parses program event related to this program from transaction logs
+     *
+     * @param logs
+     */
+    parseLogs(logs: string[]): ProgramEvent<IDL>[];
+}
+export {};

package/dist/solana/program/modules/SolanaProgramEvents.js

@@ -1,117 +1,117 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaProgramEvents = void 0;
-const SolanaEvents_1 = require("../../chain/modules/SolanaEvents");
-const anchor_1 = require("@coral-xyz/anchor");
-class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
-    constructor(chain, program) {
-        super(chain);
-        this.program = program;
-        this.programCoder = new anchor_1.BorshCoder(program.program.idl);
-        this.eventParser = new anchor_1.EventParser(program.program.programId, this.programCoder);
-        this.nameMappedInstructions = {};
-        for (let ix of program.program.idl.instructions) {
-            this.nameMappedInstructions[ix.name] = ix;
-        }
-    }
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param topicKey
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
-     * @param startBlockheight
-     */
-    findInEvents(topicKey, processor, abortSignal, logBatchSize, startBlockheight) {
-        return this.findInSignatures(topicKey, async (data) => {
-            if (data.signatures) {
-                for (let info of data.signatures) {
-                    if (info.err)
-                        continue;
-                    const tx = await this.connection.getParsedTransaction(info.signature, {
-                        commitment: "confirmed",
-                        maxSupportedTransactionVersion: 0
-                    });
-                    if (tx == null || tx.meta == null || tx.meta.err || tx.meta.logMessages == null)
-                        continue;
-                    const events = this.parseLogs(tx.meta.logMessages);
-                    events.reverse();
-                    for (let event of events) {
-                        if (abortSignal != null)
-                            abortSignal.throwIfAborted();
-                        const result = await processor(event, tx);
-                        if (result != null)
-                            return result;
-                    }
-                }
-            }
-            else if (data.txs) {
-                for (let tx of data.txs) {
-                    if (tx.meta == null || tx.meta.err || tx.meta.logMessages == null)
-                        continue;
-                    const events = this.parseLogs(tx.meta.logMessages);
-                    events.reverse();
-                    for (let event of events) {
-                        if (abortSignal != null)
-                            abortSignal.throwIfAborted();
-                        const result = await processor(event, tx);
-                        if (result != null)
-                            return result;
-                    }
-                }
-            }
-            return null;
-        }, abortSignal, logBatchSize, startBlockheight);
-    }
-    /**
-     * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
-     *  for every instruction that doesn't correspond to this program (as those are impossible to parse)
-     *
-     * @param transactionMessage
-     */
-    decodeInstructions(transactionMessage) {
-        const instructions = [];
-        for (let _ix of transactionMessage.instructions) {
-            if (!_ix.programId.equals(this.program.program.programId)) {
-                instructions.push(null);
-                continue;
-            }
-            const ix = _ix;
-            if (ix.data == null)
-                continue;
-            const parsedIx = this.programCoder.instruction.decode(ix.data, 'base58');
-            if (parsedIx == null)
-                throw new Error(`Failed to decode transaction instruction: ${ix.data}!`);
-            const accountsData = this.nameMappedInstructions[parsedIx.name];
-            let accounts = null;
-            if (accountsData != null && accountsData.accounts != null) {
-                accounts = {};
-                for (let i = 0; i < accountsData.accounts.length; i++) {
-                    accounts[accountsData.accounts[i].name] = ix.accounts[i];
-                }
-            }
-            instructions.push({
-                name: parsedIx.name,
-                data: parsedIx.data,
-                accounts: accounts
-            });
-        }
-        return instructions;
-    }
-    /**
-     * Parses program event related to this program from transaction logs
-     *
-     * @param logs
-     */
-    parseLogs(logs) {
-        const eventsGenerator = this.eventParser.parseLogs(logs);
-        const events = [];
-        for (let log of eventsGenerator) {
-            events.push(log);
-        }
-        return events;
-    }
-}
-exports.SolanaProgramEvents = SolanaProgramEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaProgramEvents = void 0;
+const SolanaEvents_1 = require("../../chain/modules/SolanaEvents");
+const anchor_1 = require("@coral-xyz/anchor");
+class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
+    constructor(chain, program) {
+        super(chain);
+        this.program = program;
+        this.programCoder = new anchor_1.BorshCoder(program.program.idl);
+        this.eventParser = new anchor_1.EventParser(program.program.programId, this.programCoder);
+        this.nameMappedInstructions = {};
+        for (let ix of program.program.idl.instructions) {
+            this.nameMappedInstructions[ix.name] = ix;
+        }
+    }
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param topicKey
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
+     */
+    findInEvents(topicKey, processor, abortSignal, logBatchSize, startBlockheight) {
+        return this.findInSignatures(topicKey, async (data) => {
+            if (data.signatures) {
+                for (let info of data.signatures) {
+                    if (info.err)
+                        continue;
+                    const tx = await this.connection.getParsedTransaction(info.signature, {
+                        commitment: "confirmed",
+                        maxSupportedTransactionVersion: 0
+                    });
+                    if (tx == null || tx.meta == null || tx.meta.err || tx.meta.logMessages == null)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
+                }
+            }
+            else if (data.txs) {
+                for (let tx of data.txs) {
+                    if (tx.meta == null || tx.meta.err || tx.meta.logMessages == null)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
+                }
+            }
+            return null;
+        }, abortSignal, logBatchSize, startBlockheight);
+    }
+    /**
+     * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
+     *  for every instruction that doesn't correspond to this program (as those are impossible to parse)
+     *
+     * @param transactionMessage
+     */
+    decodeInstructions(transactionMessage) {
+        const instructions = [];
+        for (let _ix of transactionMessage.instructions) {
+            if (!_ix.programId.equals(this.program.program.programId)) {
+                instructions.push(null);
+                continue;
+            }
+            const ix = _ix;
+            if (ix.data == null)
+                continue;
+            const parsedIx = this.programCoder.instruction.decode(ix.data, 'base58');
+            if (parsedIx == null)
+                throw new Error(`Failed to decode transaction instruction: ${ix.data}!`);
+            const accountsData = this.nameMappedInstructions[parsedIx.name];
+            let accounts = null;
+            if (accountsData != null && accountsData.accounts != null) {
+                accounts = {};
+                for (let i = 0; i < accountsData.accounts.length; i++) {
+                    accounts[accountsData.accounts[i].name] = ix.accounts[i];
+                }
+            }
+            instructions.push({
+                name: parsedIx.name,
+                data: parsedIx.data,
+                accounts: accounts
+            });
+        }
+        return instructions;
+    }
+    /**
+     * Parses program event related to this program from transaction logs
+     *
+     * @param logs
+     */
+    parseLogs(logs) {
+        const eventsGenerator = this.eventParser.parseLogs(logs);
+        const events = [];
+        for (let log of eventsGenerator) {
+            events.push(log);
+        }
+        return events;
+    }
+}
+exports.SolanaProgramEvents = SolanaProgramEvents;