@atomiqlabs/chain-solana 12.0.13 → 12.0.15

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -1,209 +1,209 @@
-import {ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SwapEvent} from "@atomiqlabs/base";
-import {InitInstruction, SolanaSwapData} from "../swaps/SolanaSwapData";
-import {IdlEvents} from "@coral-xyz/anchor";
-import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
-import {
-    getLogger,
-    onceAsync, toEscrowHash, tryWithRetries
-} from "../../utils/Utils";
-import {Connection, ParsedTransactionWithMeta} from "@solana/web3.js";
-import {SwapTypeEnum} from "../swaps/SwapTypeEnum";
-import {
-    InstructionWithAccounts,
-    ProgramEvent
-} from "../program/modules/SolanaProgramEvents";
-import {SwapProgram} from "../swaps/programTypes";
-import {Buffer} from "buffer";
-
-export type EventObject = {
-    events: ProgramEvent<SwapProgram>[],
-    instructions: InstructionWithAccounts<SwapProgram>[],
-    blockTime: number,
-    signature: string
-};
-
-/**
- * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
- *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
- *  rely purely on events
- */
-export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
-
-    protected readonly listeners: EventListener<SolanaSwapData>[] = [];
-    protected readonly connection: Connection;
-    protected readonly solanaSwapProgram: SolanaSwapProgram;
-    protected eventListeners: number[] = [];
-    protected readonly logger = getLogger("SolanaChainEventsBrowser: ");
-
-    constructor(connection: Connection, solanaSwapContract: SolanaSwapProgram) {
-        this.connection = connection;
-        this.solanaSwapProgram = solanaSwapContract;
-    }
-
-    /**
-     * Fetches and parses transaction instructions
-     *
-     * @private
-     * @returns {Promise<InstructionWithAccounts<SwapProgram>[]>} array of parsed instructions
-     */
-    private async getTransactionInstructions(signature: string): Promise<InstructionWithAccounts<SwapProgram>[]> {
-        const transaction = await tryWithRetries<ParsedTransactionWithMeta>(async () => {
-            const res = await this.connection.getParsedTransaction(signature, {
-                commitment: "confirmed",
-                maxSupportedTransactionVersion: 0
-            });
-            if(res==null) throw new Error("Transaction not found!");
-            return res;
-        });
-        if(transaction==null) return null;
-        if(transaction.meta.err!=null) return null;
-        return this.solanaSwapProgram.Events.decodeInstructions(transaction.transaction.message);
-    }
-
-    /**
-     * Returns async getter for fetching on-demand initialize event swap data
-     *
-     * @param eventObject
-     * @param txoHash
-     * @private
-     * @returns {() => Promise<SolanaSwapData>} getter to be passed to InitializeEvent constructor
-     */
-    private getSwapDataGetter(eventObject: EventObject, txoHash: string): () => Promise<SolanaSwapData> {
-        return async () => {
-            if(eventObject.instructions==null) eventObject.instructions = await this.getTransactionInstructions(eventObject.signature);
-            if(eventObject.instructions==null) return null;
-
-            const initIx = eventObject.instructions.find(
-                ix => ix!=null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize")
-            ) as InitInstruction;
-            if(initIx == null) return null;
-
-            return SolanaSwapData.fromInstruction(initIx, txoHash);
-        }
-    }
-
-    protected parseInitializeEvent(data: IdlEvents<SwapProgram>["InitializeEvent"], eventObject: EventObject): InitializeEvent<SolanaSwapData> {
-        const paymentHash: string = Buffer.from(data.hash).toString("hex");
-        const txoHash: string = Buffer.from(data.txoHash).toString("hex");
-        const escrowHash = toEscrowHash(paymentHash, data.sequence);
-        this.logger.debug("InitializeEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
-            " txoHash: "+txoHash+" escrowHash: "+escrowHash);
-        return new InitializeEvent<SolanaSwapData>(
-            escrowHash,
-            SwapTypeEnum.toChainSwapType(data.kind),
-            onceAsync<SolanaSwapData>(this.getSwapDataGetter(eventObject, txoHash))
-        );
-    }
-
-    protected parseRefundEvent(data: IdlEvents<SwapProgram>["RefundEvent"]): RefundEvent<SolanaSwapData> {
-        const paymentHash: string = Buffer.from(data.hash).toString("hex");
-        const escrowHash = toEscrowHash(paymentHash, data.sequence);
-        this.logger.debug("RefundEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
-            " escrowHash: "+escrowHash);
-        return new RefundEvent<SolanaSwapData>(escrowHash);
-    }
-
-    protected parseClaimEvent(data: IdlEvents<SwapProgram>["ClaimEvent"]): ClaimEvent<SolanaSwapData> {
-        const secret: string = Buffer.from(data.secret).toString("hex");
-        const paymentHash: string = Buffer.from(data.hash).toString("hex");
-        const escrowHash = toEscrowHash(paymentHash, data.sequence);
-        this.logger.debug("ClaimEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
-            " secret: "+secret+" escrowHash: "+escrowHash);
-        return new ClaimEvent<SolanaSwapData>(escrowHash, secret);
-    }
-
-    /**
-     * Processes event as received from the chain, parses it & calls event listeners
-     *
-     * @param eventObject
-     * @protected
-     */
-    protected async processEvent(eventObject : EventObject) {
-        let parsedEvents: SwapEvent<SolanaSwapData>[] = eventObject.events.map(event => {
-            let parsedEvent: SwapEvent<SolanaSwapData>;
-            switch(event.name) {
-                case "ClaimEvent":
-                    parsedEvent = this.parseClaimEvent(event.data);
-                    break;
-                case "RefundEvent":
-                    parsedEvent = this.parseRefundEvent(event.data);
-                    break;
-                case "InitializeEvent":
-                    parsedEvent = this.parseInitializeEvent(event.data, eventObject);
-                    break;
-            }
-            (parsedEvent as any).meta = {
-                blockTime: eventObject.blockTime,
-                timestamp: eventObject.blockTime,
-                txId: eventObject.signature
-            };
-            return parsedEvent;
-        }).filter(parsedEvent => parsedEvent!=null);
-
-        for(let listener of this.listeners) {
-            await listener(parsedEvents);
-        }
-    }
-
-    /**
-     * Returns websocket event handler for specific event type
-     *
-     * @param name
-     * @protected
-     * @returns event handler to be passed to program's addEventListener function
-     */
-    protected getWsEventHandler<E extends "InitializeEvent" | "RefundEvent" | "ClaimEvent">(
-        name: E
-    ): (data: IdlEvents<SwapProgram>[E], slotNumber: number, signature: string) => void {
-        return (data: IdlEvents<SwapProgram>[E], slotNumber: number, signature: string) => {
-            this.logger.debug("wsEventHandler: Process signature: ", signature);
-
-            this.processEvent({
-                events: [{name, data: data as any}],
-                instructions: null, //Instructions will be fetched on-demand if required
-                blockTime: Math.floor(Date.now()/1000),
-                signature
-            }).then(() => true).catch(e => {
-                this.logger.error("wsEventHandler: Error when processing signature: "+signature, e);
-                return false;
-            });
-        };
-    }
-
-    /**
-     * Sets up event handlers listening for swap events over websocket
-     *
-     * @protected
-     */
-    protected setupWebsocket() {
-        const program = this.solanaSwapProgram.program;
-        this.eventListeners.push(program.addEventListener<"InitializeEvent">("InitializeEvent", this.getWsEventHandler("InitializeEvent")));
-        this.eventListeners.push(program.addEventListener<"ClaimEvent">("ClaimEvent", this.getWsEventHandler("ClaimEvent")));
-        this.eventListeners.push(program.addEventListener<"RefundEvent">("RefundEvent", this.getWsEventHandler("RefundEvent")));
-    }
-
-    init(): Promise<void> {
-        this.setupWebsocket();
-        return Promise.resolve();
-    }
-
-    async stop(): Promise<void> {
-        for(let num of this.eventListeners) {
-            await this.solanaSwapProgram.program.removeEventListener(num);
-        }
-        this.eventListeners = [];
-    }
-
-    registerListener(cbk: EventListener<SolanaSwapData>): void {
-        this.listeners.push(cbk);
-    }
-
-    unregisterListener(cbk: EventListener<SolanaSwapData>): boolean {
-        const index = this.listeners.indexOf(cbk);
-        if(index>=0) {
-            this.listeners.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-}
+import {ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SwapEvent} from "@atomiqlabs/base";
+import {InitInstruction, SolanaSwapData} from "../swaps/SolanaSwapData";
+import {IdlEvents} from "@coral-xyz/anchor";
+import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
+import {
+    getLogger,
+    onceAsync, toEscrowHash, tryWithRetries
+} from "../../utils/Utils";
+import {Connection, ParsedTransactionWithMeta} from "@solana/web3.js";
+import {SwapTypeEnum} from "../swaps/SwapTypeEnum";
+import {
+    InstructionWithAccounts,
+    ProgramEvent
+} from "../program/modules/SolanaProgramEvents";
+import {SwapProgram} from "../swaps/programTypes";
+import {Buffer} from "buffer";
+
+export type EventObject = {
+    events: ProgramEvent<SwapProgram>[],
+    instructions: InstructionWithAccounts<SwapProgram>[],
+    blockTime: number,
+    signature: string
+};
+
+/**
+ * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
+ *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
+ *  rely purely on events
+ */
+export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
+
+    protected readonly listeners: EventListener<SolanaSwapData>[] = [];
+    protected readonly connection: Connection;
+    protected readonly solanaSwapProgram: SolanaSwapProgram;
+    protected eventListeners: number[] = [];
+    protected readonly logger = getLogger("SolanaChainEventsBrowser: ");
+
+    constructor(connection: Connection, solanaSwapContract: SolanaSwapProgram) {
+        this.connection = connection;
+        this.solanaSwapProgram = solanaSwapContract;
+    }
+
+    /**
+     * Fetches and parses transaction instructions
+     *
+     * @private
+     * @returns {Promise<InstructionWithAccounts<SwapProgram>[]>} array of parsed instructions
+     */
+    private async getTransactionInstructions(signature: string): Promise<InstructionWithAccounts<SwapProgram>[]> {
+        const transaction = await tryWithRetries<ParsedTransactionWithMeta>(async () => {
+            const res = await this.connection.getParsedTransaction(signature, {
+                commitment: "confirmed",
+                maxSupportedTransactionVersion: 0
+            });
+            if(res==null) throw new Error("Transaction not found!");
+            return res;
+        });
+        if(transaction==null) return null;
+        if(transaction.meta.err!=null) return null;
+        return this.solanaSwapProgram.Events.decodeInstructions(transaction.transaction.message);
+    }
+
+    /**
+     * Returns async getter for fetching on-demand initialize event swap data
+     *
+     * @param eventObject
+     * @param txoHash
+     * @private
+     * @returns {() => Promise<SolanaSwapData>} getter to be passed to InitializeEvent constructor
+     */
+    private getSwapDataGetter(eventObject: EventObject, txoHash: string): () => Promise<SolanaSwapData> {
+        return async () => {
+            if(eventObject.instructions==null) eventObject.instructions = await this.getTransactionInstructions(eventObject.signature);
+            if(eventObject.instructions==null) return null;
+
+            const initIx = eventObject.instructions.find(
+                ix => ix!=null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize")
+            ) as InitInstruction;
+            if(initIx == null) return null;
+
+            return SolanaSwapData.fromInstruction(initIx, txoHash);
+        }
+    }
+
+    protected parseInitializeEvent(data: IdlEvents<SwapProgram>["InitializeEvent"], eventObject: EventObject): InitializeEvent<SolanaSwapData> {
+        const paymentHash: string = Buffer.from(data.hash).toString("hex");
+        const txoHash: string = Buffer.from(data.txoHash).toString("hex");
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("InitializeEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " txoHash: "+txoHash+" escrowHash: "+escrowHash);
+        return new InitializeEvent<SolanaSwapData>(
+            escrowHash,
+            SwapTypeEnum.toChainSwapType(data.kind),
+            onceAsync<SolanaSwapData>(this.getSwapDataGetter(eventObject, txoHash))
+        );
+    }
+
+    protected parseRefundEvent(data: IdlEvents<SwapProgram>["RefundEvent"]): RefundEvent<SolanaSwapData> {
+        const paymentHash: string = Buffer.from(data.hash).toString("hex");
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("RefundEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " escrowHash: "+escrowHash);
+        return new RefundEvent<SolanaSwapData>(escrowHash);
+    }
+
+    protected parseClaimEvent(data: IdlEvents<SwapProgram>["ClaimEvent"]): ClaimEvent<SolanaSwapData> {
+        const secret: string = Buffer.from(data.secret).toString("hex");
+        const paymentHash: string = Buffer.from(data.hash).toString("hex");
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("ClaimEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " secret: "+secret+" escrowHash: "+escrowHash);
+        return new ClaimEvent<SolanaSwapData>(escrowHash, secret);
+    }
+
+    /**
+     * Processes event as received from the chain, parses it & calls event listeners
+     *
+     * @param eventObject
+     * @protected
+     */
+    protected async processEvent(eventObject : EventObject) {
+        let parsedEvents: SwapEvent<SolanaSwapData>[] = eventObject.events.map(event => {
+            let parsedEvent: SwapEvent<SolanaSwapData>;
+            switch(event.name) {
+                case "ClaimEvent":
+                    parsedEvent = this.parseClaimEvent(event.data);
+                    break;
+                case "RefundEvent":
+                    parsedEvent = this.parseRefundEvent(event.data);
+                    break;
+                case "InitializeEvent":
+                    parsedEvent = this.parseInitializeEvent(event.data, eventObject);
+                    break;
+            }
+            (parsedEvent as any).meta = {
+                blockTime: eventObject.blockTime,
+                timestamp: eventObject.blockTime,
+                txId: eventObject.signature
+            };
+            return parsedEvent;
+        }).filter(parsedEvent => parsedEvent!=null);
+
+        for(let listener of this.listeners) {
+            await listener(parsedEvents);
+        }
+    }
+
+    /**
+     * Returns websocket event handler for specific event type
+     *
+     * @param name
+     * @protected
+     * @returns event handler to be passed to program's addEventListener function
+     */
+    protected getWsEventHandler<E extends "InitializeEvent" | "RefundEvent" | "ClaimEvent">(
+        name: E
+    ): (data: IdlEvents<SwapProgram>[E], slotNumber: number, signature: string) => void {
+        return (data: IdlEvents<SwapProgram>[E], slotNumber: number, signature: string) => {
+            this.logger.debug("wsEventHandler: Process signature: ", signature);
+
+            this.processEvent({
+                events: [{name, data: data as any}],
+                instructions: null, //Instructions will be fetched on-demand if required
+                blockTime: Math.floor(Date.now()/1000),
+                signature
+            }).then(() => true).catch(e => {
+                this.logger.error("wsEventHandler: Error when processing signature: "+signature, e);
+                return false;
+            });
+        };
+    }
+
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @protected
+     */
+    protected setupWebsocket() {
+        const program = this.solanaSwapProgram.program;
+        this.eventListeners.push(program.addEventListener<"InitializeEvent">("InitializeEvent", this.getWsEventHandler("InitializeEvent")));
+        this.eventListeners.push(program.addEventListener<"ClaimEvent">("ClaimEvent", this.getWsEventHandler("ClaimEvent")));
+        this.eventListeners.push(program.addEventListener<"RefundEvent">("RefundEvent", this.getWsEventHandler("RefundEvent")));
+    }
+
+    init(): Promise<void> {
+        this.setupWebsocket();
+        return Promise.resolve();
+    }
+
+    async stop(): Promise<void> {
+        for(let num of this.eventListeners) {
+            await this.solanaSwapProgram.program.removeEventListener(num);
+        }
+        this.eventListeners = [];
+    }
+
+    registerListener(cbk: EventListener<SolanaSwapData>): void {
+        this.listeners.push(cbk);
+    }
+
+    unregisterListener(cbk: EventListener<SolanaSwapData>): boolean {
+        const index = this.listeners.indexOf(cbk);
+        if(index>=0) {
+            this.listeners.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+}

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;
+    }
+
 }