@atomiqlabs/chain-solana 10.0.0-dev.3 → 11.0.0

package/src/solana/program/SolanaProgramBase.ts

@@ -1,80 +1,80 @@
-import {AnchorProvider, Idl, Program} from "@coral-xyz/anchor";
-import {SolanaFees} from "../chain/modules/SolanaFees";
-import {SolanaChainInterface, SolanaRetryPolicy} from "../chain/SolanaChainInterface";
-import {SolanaProgramEvents} from "./modules/SolanaProgramEvents";
-import {Connection, Keypair, PublicKey} from "@solana/web3.js";
-import {sha256} from "@noble/hashes/sha2";
-import {Buffer} from "buffer";
-import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
-import {getLogger} from "../../utils/Utils";
-
-/**
- * Base class providing program specific utilities
- */
-export class SolanaProgramBase<T extends Idl> {
-
-    protected readonly logger = getLogger(this.constructor.name+": ");
-
-    program: Program<T>;
-
-    public readonly Events: SolanaProgramEvents<T>;
-    public readonly Chain: SolanaChainInterface;
-
-    constructor(
-        chainInterface: SolanaChainInterface,
-        programIdl: any,
-        programAddress?: string
-    ) {
-        this.Chain = chainInterface;
-
-        this.program = new Program<T>(
-            programIdl as any,
-            programAddress || programIdl.metadata.address,
-            new AnchorProvider(chainInterface.connection, new SolanaKeypairWallet(Keypair.generate()), {})
-        );
-
-        this.Events = new SolanaProgramEvents(chainInterface, this);
-    }
-
-    /**
-     * Derives static PDA address from the seed
-     *
-     * @param seed
-     */
-    public 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[]
-     */
-    public pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (...args: T) => PublicKey;
-    public pda<T extends Array<any>>(seed: string, func?: (...args: T) => Buffer[]): PublicKey | ((...args: T) => PublicKey) {
-        if(func==null) {
-            return PublicKey.findProgramAddressSync(
-                [Buffer.from(seed)],
-                this.program.programId
-            )[0];
-        }
-        return (...args: T) => {
-            const res = func(...args);
-            return PublicKey.findProgramAddressSync(
-                [Buffer.from(seed)].concat(res),
-                this.program.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
-     */
-    public keypair<T extends Array<any>>(func: (...args: T) => Buffer[]): (...args: T) => Keypair {
-        return (...args: T) => {
-            const res = func(...args);
-            const buff = sha256(Buffer.concat(res));
-            return Keypair.fromSeed(buff);
-        }
-    }
-
+import {AnchorProvider, Idl, Program} from "@coral-xyz/anchor";
+import {SolanaFees} from "../chain/modules/SolanaFees";
+import {SolanaChainInterface, SolanaRetryPolicy} from "../chain/SolanaChainInterface";
+import {SolanaProgramEvents} from "./modules/SolanaProgramEvents";
+import {Connection, Keypair, PublicKey} from "@solana/web3.js";
+import {sha256} from "@noble/hashes/sha2";
+import {Buffer} from "buffer";
+import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
+import {getLogger} from "../../utils/Utils";
+
+/**
+ * Base class providing program specific utilities
+ */
+export class SolanaProgramBase<T extends Idl> {
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    program: Program<T>;
+
+    public readonly Events: SolanaProgramEvents<T>;
+    public readonly Chain: SolanaChainInterface;
+
+    constructor(
+        chainInterface: SolanaChainInterface,
+        programIdl: any,
+        programAddress?: string
+    ) {
+        this.Chain = chainInterface;
+
+        this.program = new Program<T>(
+            programIdl as any,
+            programAddress || programIdl.metadata.address,
+            new AnchorProvider(chainInterface.connection, new SolanaKeypairWallet(Keypair.generate()), {})
+        );
+
+        this.Events = new SolanaProgramEvents(chainInterface, this);
+    }
+
+    /**
+     * Derives static PDA address from the seed
+     *
+     * @param seed
+     */
+    public 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[]
+     */
+    public pda<T extends Array<any>>(seed: string, func: (...args: T) => Buffer[]): (...args: T) => PublicKey;
+    public pda<T extends Array<any>>(seed: string, func?: (...args: T) => Buffer[]): PublicKey | ((...args: T) => PublicKey) {
+        if(func==null) {
+            return PublicKey.findProgramAddressSync(
+                [Buffer.from(seed)],
+                this.program.programId
+            )[0];
+        }
+        return (...args: T) => {
+            const res = func(...args);
+            return PublicKey.findProgramAddressSync(
+                [Buffer.from(seed)].concat(res),
+                this.program.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
+     */
+    public keypair<T extends Array<any>>(func: (...args: T) => Buffer[]): (...args: T) => Keypair {
+        return (...args: T) => {
+            const res = func(...args);
+            const buff = sha256(Buffer.concat(res));
+            return Keypair.fromSeed(buff);
+        }
+    }
+
 }

package/src/solana/program/SolanaProgramModule.ts

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

package/src/solana/program/modules/SolanaProgramEvents.ts

@@ -1,141 +1,141 @@
-import {SolanaEvents} from "../../chain/modules/SolanaEvents";
-import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlTypes, Instruction} from "@coral-xyz/anchor";
-import {IdlField, IdlInstruction} from "@coral-xyz/anchor/dist/cjs/idl";
-import {ConfirmedSignatureInfo, ParsedMessage, PartiallyDecodedInstruction, 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<IDL["events"][number], Record<string, any>>;
-
-export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
-
-    private readonly programCoder: BorshCoder;
-    private readonly eventParser: EventParser;
-    private readonly program: SolanaProgramBase<IDL>;
-    private readonly nameMappedInstructions: {[name: string]: IdlInstruction};
-
-    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>) {
-        super(chain);
-        this.program = program;
-        this.programCoder = new BorshCoder(program.program.idl);
-        this.eventParser = new EventParser(program.program.programId, this.programCoder);
-        this.nameMappedInstructions = {};
-        for(let ix of program.program.idl.instructions) {
-            this.nameMappedInstructions[ix.name] = ix;
-        }
-    }
-
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    private async getEvents(signature: string): Promise<ProgramEvent<IDL>[]> {
-        const tx = await this.connection.getTransaction(signature, {
-            commitment: "confirmed",
-            maxSupportedTransactionVersion: 0
-        });
-        if(tx.meta.err) return [];
-
-        const events = this.parseLogs(tx.meta.logMessages);
-        events.reverse();
-
-        return events;
-    }
-
-    /**
-     * 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
-     */
-    public findInEvents<T>(
-        topicKey: PublicKey,
-        processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>,
-        abortSignal?: AbortSignal,
-        logBatchSize?: number
-    ): Promise<T> {
-        return this.findInSignatures<T>(topicKey, async (signatures: ConfirmedSignatureInfo[]) => {
-            for(let data of signatures) {
-                for(let event of await this.getEvents(data.signature)) {
-                    if(abortSignal!=null) abortSignal.throwIfAborted();
-                    const result: T = await processor(event, data);
-                    if(result!=null) return result;
-                }
-            }
-        }, abortSignal, logBatchSize);
-    }
-
-    /**
-     * 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
-     */
-    public decodeInstructions(transactionMessage: ParsedMessage): InstructionWithAccounts<IDL>[] {
-        const instructions: InstructionWithAccounts<IDL>[] = [];
-
-        for(let _ix of transactionMessage.instructions) {
-            if(!_ix.programId.equals(this.program.program.programId)) {
-                instructions.push(null);
-                continue;
-            }
-
-            const ix: PartiallyDecodedInstruction = _ix as PartiallyDecodedInstruction;
-            if(ix.data==null) continue;
-
-            const parsedIx: Instruction = this.programCoder.instruction.decode(ix.data, 'base58');
-            const accountsData = this.nameMappedInstructions[parsedIx.name];
-            let accounts: {[name: string]: PublicKey};
-            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 as any,
-                accounts: accounts as any
-            });
-        }
-
-        return instructions;
-    }
-
-    /**
-     * Parses program event related to this program from transaction logs
-     *
-     * @param logs
-     */
-    public parseLogs(logs: string[]): ProgramEvent<IDL>[] {
-        const eventsGenerator = this.eventParser.parseLogs(logs);
-
-        const events: ProgramEvent<IDL>[] = [];
-        for(let log of eventsGenerator) {
-            events.push(log as ProgramEvent<IDL>);
-        }
-
-        return events;
-    }
-
+import {SolanaEvents} from "../../chain/modules/SolanaEvents";
+import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlTypes, Instruction} from "@coral-xyz/anchor";
+import {IdlField, IdlInstruction} from "@coral-xyz/anchor/dist/cjs/idl";
+import {ConfirmedSignatureInfo, ParsedMessage, PartiallyDecodedInstruction, 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<IDL["events"][number], Record<string, any>>;
+
+export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
+
+    private readonly programCoder: BorshCoder;
+    private readonly eventParser: EventParser;
+    private readonly program: SolanaProgramBase<IDL>;
+    private readonly nameMappedInstructions: {[name: string]: IdlInstruction};
+
+    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>) {
+        super(chain);
+        this.program = program;
+        this.programCoder = new BorshCoder(program.program.idl);
+        this.eventParser = new EventParser(program.program.programId, this.programCoder);
+        this.nameMappedInstructions = {};
+        for(let ix of program.program.idl.instructions) {
+            this.nameMappedInstructions[ix.name] = ix;
+        }
+    }
+
+    /**
+     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
+     *
+     * @param signature
+     * @private
+     */
+    private async getEvents(signature: string): Promise<ProgramEvent<IDL>[]> {
+        const tx = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+        });
+        if(tx.meta.err) return [];
+
+        const events = this.parseLogs(tx.meta.logMessages);
+        events.reverse();
+
+        return events;
+    }
+
+    /**
+     * 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
+     */
+    public findInEvents<T>(
+        topicKey: PublicKey,
+        processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>,
+        abortSignal?: AbortSignal,
+        logBatchSize?: number
+    ): Promise<T> {
+        return this.findInSignatures<T>(topicKey, async (signatures: ConfirmedSignatureInfo[]) => {
+            for(let data of signatures) {
+                for(let event of await this.getEvents(data.signature)) {
+                    if(abortSignal!=null) abortSignal.throwIfAborted();
+                    const result: T = await processor(event, data);
+                    if(result!=null) return result;
+                }
+            }
+        }, abortSignal, logBatchSize);
+    }
+
+    /**
+     * 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
+     */
+    public decodeInstructions(transactionMessage: ParsedMessage): InstructionWithAccounts<IDL>[] {
+        const instructions: InstructionWithAccounts<IDL>[] = [];
+
+        for(let _ix of transactionMessage.instructions) {
+            if(!_ix.programId.equals(this.program.program.programId)) {
+                instructions.push(null);
+                continue;
+            }
+
+            const ix: PartiallyDecodedInstruction = _ix as PartiallyDecodedInstruction;
+            if(ix.data==null) continue;
+
+            const parsedIx: Instruction = this.programCoder.instruction.decode(ix.data, 'base58');
+            const accountsData = this.nameMappedInstructions[parsedIx.name];
+            let accounts: {[name: string]: PublicKey};
+            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 as any,
+                accounts: accounts as any
+            });
+        }
+
+        return instructions;
+    }
+
+    /**
+     * Parses program event related to this program from transaction logs
+     *
+     * @param logs
+     */
+    public parseLogs(logs: string[]): ProgramEvent<IDL>[] {
+        const eventsGenerator = this.eventParser.parseLogs(logs);
+
+        const events: ProgramEvent<IDL>[] = [];
+        for(let log of eventsGenerator) {
+            events.push(log as ProgramEvent<IDL>);
+        }
+
+        return events;
+    }
+
 }