@atomiqlabs/chain-solana 13.3.0 → 13.5.6

package/dist/solana/events/SolanaChainEventsBrowser.d.ts

@@ -4,7 +4,7 @@ import { IdlEvents } from "@coral-xyz/anchor";
 import { SolanaSwapProgram } from "../swaps/SolanaSwapProgram";
 import { Connection } from "@solana/web3.js";
 import { InstructionWithAccounts, ProgramEvent } from "../program/modules/SolanaProgramEvents";
-import { SwapProgram } from "../swaps/programTypes";
+import { SwapProgram } from "../swaps/v1/programTypes";
 /**
  * Parsed event payload grouped by originating transaction metadata.
  *
@@ -17,11 +17,11 @@ export type EventObject = {
     signature: string;
 };
 /**
- * Current cursor of Solana event listener state.
+ * Legacy current cursor of Solana event listener state.
  *
  * @category Events
  */
-export type SolanaEventListenerState = {
+export type SolanaLegacyEventListenerState = {
     /**
      * Last processed transaction's signature
      */
@@ -31,6 +31,14 @@ export type SolanaEventListenerState = {
      */
     slot: number;
 };
+/**
+ * Current cursor of Solana event listener state.
+ *
+ * @category Events
+ */
+export type SolanaEventListenerState = {
+    [version: string]: SolanaLegacyEventListenerState | null;
+};
 /**
  * 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
@@ -38,7 +46,7 @@ export type SolanaEventListenerState = {
  *
  * @category Events
  */
-export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData, SolanaEventListenerState> {
+export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData, SolanaLegacyEventListenerState | SolanaEventListenerState> {
     /**
      * @internal
      */
@@ -50,11 +58,17 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
     /**
      * @internal
      */
-    protected readonly solanaSwapProgram: SolanaSwapProgram;
+    protected readonly contractVersions: {
+        [version: string]: {
+            swapContract: SolanaSwapProgram;
+        };
+    };
     /**
      * @internal
      */
-    protected eventListeners: number[];
+    protected eventListeners: {
+        [version: string]: number[];
+    };
     /**
      * @internal
      */
@@ -62,21 +76,24 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
         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; /**
-         * @internal
-         */
+        error: (msg: string, ...args: any[]) => false | void;
     };
     private readonly logFetchLimit;
     private signaturesProcessing;
     private processedSignatures;
     private processedSignaturesIndex;
-    constructor(connection: Connection, solanaSwapContract: SolanaSwapProgram, logFetchLimit?: number);
+    constructor(connection: Connection, contractVersions: SolanaSwapProgram | {
+        [version: string]: {
+            swapContract: SolanaSwapProgram;
+        };
+    }, logFetchLimit?: number);
     private addProcessedSignature;
     private isSignatureProcessed;
     /**
      * Parses EventObject from the transaction
      *
      * @param transaction
+     * @param version
      * @private
      * @returns {EventObject} parsed event object
      */
@@ -85,6 +102,7 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      * Fetches transaction from the RPC, parses it to even object & processes it through event handler
      *
      * @param signature
+     * @param version
      * @private
      * @returns {boolean} whether the operation was successful
      */
@@ -101,6 +119,7 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      *
      * @param eventObject
      * @param txoHash
+     * @param version
      * @private
      * @returns {() => Promise<SolanaSwapData>} getter to be passed to InitializeEvent constructor
      */
@@ -108,30 +127,32 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
     /**
      * @internal
      */
-    protected parseInitializeEvent(data: IdlEvents<SwapProgram>["InitializeEvent"], eventObject: EventObject): InitializeEvent<SolanaSwapData>;
+    protected parseInitializeEvent(data: IdlEvents<SwapProgram>["InitializeEvent"], eventObject: EventObject, version: string): InitializeEvent<SolanaSwapData>;
     /**
      * @internal
      */
-    protected parseRefundEvent(data: IdlEvents<SwapProgram>["RefundEvent"]): RefundEvent<SolanaSwapData>;
+    protected parseRefundEvent(data: IdlEvents<SwapProgram>["RefundEvent"], version: string): RefundEvent<SolanaSwapData>;
     /**
      * @internal
      */
-    protected parseClaimEvent(data: IdlEvents<SwapProgram>["ClaimEvent"]): ClaimEvent<SolanaSwapData>;
+    protected parseClaimEvent(data: IdlEvents<SwapProgram>["ClaimEvent"], version: string): ClaimEvent<SolanaSwapData>;
     /**
      * Processes event as received from the chain, parses it & calls event listeners
      *
      * @param eventObject
+     * @param version
      * @internal
      */
-    protected processEvent(eventObject: EventObject): Promise<void>;
+    protected processEvent(eventObject: EventObject, version: string): Promise<void>;
     /**
      * Returns websocket event handler for specific event type
      *
      * @param name
+     * @param version
      * @internal
      * @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;
+    protected getWsEventHandler<E extends "InitializeEvent" | "RefundEvent" | "ClaimEvent">(name: E, version: string): (data: IdlEvents<SwapProgram>[E], slotNumber: number, signature: string) => void;
     /**
      * Sets up event handlers listening for swap events over websocket
      *
@@ -142,6 +163,7 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      * Gets all the new signatures from the last processed signature
      *
      * @param lastProcessedSignature
+     * @param version
      * @private
      */
     private getNewSignatures;
@@ -155,6 +177,7 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      * Processes signatures, fetches transactions & processes event through event handlers
      *
      * @param signatures
+     * @param version
      * @private
      * @returns {Promise<{signature: string, slot: number}>} latest processed transaction signature and slot height
      */
@@ -162,7 +185,7 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
     /**
      * @inheritDoc
      */
-    poll(lastSignature?: SolanaEventListenerState): Promise<SolanaEventListenerState | null>;
+    poll(lastSignature?: SolanaLegacyEventListenerState | SolanaEventListenerState): Promise<SolanaEventListenerState>;
     /**
      * @inheritDoc
      */

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -3,11 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
 const SolanaSwapData_1 = require("../swaps/SolanaSwapData");
+const SolanaSwapProgram_1 = require("../swaps/SolanaSwapProgram");
 const Utils_1 = require("../../utils/Utils");
 const SwapTypeEnum_1 = require("../swaps/SwapTypeEnum");
 const buffer_1 = require("buffer");
 const LOG_FETCH_LIMIT = 500;
-const PROCESSED_SIGNATURES_BACKLOG = 100;
+const PROCESSED_SIGNATURES_BACKLOG = 500;
+function toNewEventListenerState(obj) {
+    if (obj == null)
+        return undefined;
+    if (obj.slot != null || obj.signature != null)
+        return { "v1": obj };
+    return obj;
+}
 /**
  * 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
@@ -16,7 +24,7 @@ const PROCESSED_SIGNATURES_BACKLOG = 100;
  * @category Events
  */
 class SolanaChainEventsBrowser {
-    constructor(connection, solanaSwapContract, logFetchLimit) {
+    constructor(connection, contractVersions, logFetchLimit) {
         /**
          * @internal
          */
@@ -24,7 +32,7 @@ class SolanaChainEventsBrowser {
         /**
          * @internal
          */
-        this.eventListeners = [];
+        this.eventListeners = {};
         /**
          * @internal
          */
@@ -33,33 +41,39 @@ class SolanaChainEventsBrowser {
         this.processedSignatures = [];
         this.processedSignaturesIndex = 0;
         this.connection = connection;
-        this.solanaSwapProgram = solanaSwapContract;
+        if (contractVersions instanceof SolanaSwapProgram_1.SolanaSwapProgram) {
+            this.contractVersions = { [contractVersions.version]: { swapContract: contractVersions } };
+        }
+        else {
+            this.contractVersions = contractVersions;
+        }
         this.logFetchLimit = logFetchLimit ?? LOG_FETCH_LIMIT;
     }
-    addProcessedSignature(signature) {
-        this.processedSignatures[this.processedSignaturesIndex] = signature;
+    addProcessedSignature(signature, version) {
+        this.processedSignatures[this.processedSignaturesIndex] = signature + "-" + version;
         this.processedSignaturesIndex += 1;
         if (this.processedSignaturesIndex >= PROCESSED_SIGNATURES_BACKLOG)
             this.processedSignaturesIndex = 0;
     }
-    isSignatureProcessed(signature) {
-        return this.processedSignatures.includes(signature);
+    isSignatureProcessed(signature, version) {
+        return this.processedSignatures.includes(signature + "-" + version);
     }
     /**
      * Parses EventObject from the transaction
      *
      * @param transaction
+     * @param version
      * @private
      * @returns {EventObject} parsed event object
      */
-    getEventObjectFromTransaction(transaction) {
+    getEventObjectFromTransaction(transaction, version) {
         const signature = transaction.transaction.signatures[0];
         if (transaction.meta == null)
             throw new Error(`Transaction 'meta' not found for Solana tx: ${signature}`);
         if (transaction.meta.err != null || transaction.meta.logMessages == null)
             return null;
-        const instructions = this.solanaSwapProgram._Events.decodeInstructions(transaction.transaction.message);
-        const events = this.solanaSwapProgram._Events.parseLogs(transaction.meta.logMessages);
+        const instructions = this.contractVersions[version].swapContract._Events.decodeInstructions(transaction.transaction.message);
+        const events = this.contractVersions[version].swapContract._Events.parseLogs(transaction.meta.logMessages);
         return {
             instructions,
             events,
@@ -71,10 +85,11 @@ class SolanaChainEventsBrowser {
      * Fetches transaction from the RPC, parses it to even object & processes it through event handler
      *
      * @param signature
+     * @param version
      * @private
      * @returns {boolean} whether the operation was successful
      */
-    async fetchTxAndProcessEvent(signature) {
+    async fetchTxAndProcessEvent(signature, version) {
         try {
             const transaction = await this.connection.getParsedTransaction(signature, {
                 commitment: "confirmed",
@@ -82,10 +97,10 @@ class SolanaChainEventsBrowser {
             });
             if (transaction == null)
                 return false;
-            const eventObject = this.getEventObjectFromTransaction(transaction);
+            const eventObject = this.getEventObjectFromTransaction(transaction, version);
             if (eventObject == null)
                 return true;
-            await this.processEvent(eventObject);
+            await this.processEvent(eventObject, version);
             return true;
         }
         catch (e) {
@@ -99,7 +114,7 @@ class SolanaChainEventsBrowser {
      * @private
      * @returns {Promise<(InstructionWithAccounts<SwapProgram> | null)[] | null>} array of parsed instructions
      */
-    async getTransactionInstructions(signature) {
+    async getTransactionInstructions(signature, version) {
         const transaction = await (0, Utils_1.tryWithRetries)(async () => {
             const res = await this.connection.getParsedTransaction(signature, {
                 commitment: "confirmed",
@@ -113,20 +128,21 @@ class SolanaChainEventsBrowser {
             throw new Error("Transaction 'meta' not found!");
         if (transaction.meta.err != null)
             return null;
-        return this.solanaSwapProgram._Events.decodeInstructions(transaction.transaction.message);
+        return this.contractVersions[version].swapContract._Events.decodeInstructions(transaction.transaction.message);
     }
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
      * @param eventObject
      * @param txoHash
+     * @param version
      * @private
      * @returns {() => Promise<SolanaSwapData>} getter to be passed to InitializeEvent constructor
      */
-    getSwapDataGetter(eventObject, txoHash) {
+    getSwapDataGetter(eventObject, txoHash, version) {
         return async () => {
             if (eventObject.instructions == null) {
-                const ixs = await this.getTransactionInstructions(eventObject.signature);
+                const ixs = await this.getTransactionInstructions(eventObject.signature, version);
                 if (ixs == null)
                     return null;
                 eventObject.instructions = ixs;
@@ -134,59 +150,60 @@ class SolanaChainEventsBrowser {
             const initIx = eventObject.instructions.find(ix => ix != null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize"));
             if (initIx == null)
                 return null;
-            return SolanaSwapData_1.SolanaSwapData.fromInstruction(this.solanaSwapProgram.program.programId, initIx, txoHash);
+            return SolanaSwapData_1.SolanaSwapData.fromInstruction(this.contractVersions[version].swapContract.program.programId, version, initIx, txoHash);
         };
     }
     /**
      * @internal
      */
-    parseInitializeEvent(data, eventObject) {
+    parseInitializeEvent(data, eventObject, version) {
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
         const txoHash = buffer_1.Buffer.from(data.txoHash).toString("hex");
         const escrowHash = (0, Utils_1.toEscrowHash)(paymentHash, data.sequence);
         this.logger.debug("InitializeEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10) +
             " txoHash: " + txoHash + " escrowHash: " + escrowHash);
-        return new base_1.InitializeEvent(escrowHash, SwapTypeEnum_1.SwapTypeEnum.toChainSwapType(data.kind), (0, Utils_1.onceAsync)(this.getSwapDataGetter(eventObject, txoHash)));
+        return new base_1.InitializeEvent(escrowHash, SwapTypeEnum_1.SwapTypeEnum.toChainSwapType(data.kind), (0, Utils_1.onceAsync)(this.getSwapDataGetter(eventObject, txoHash, version)), version);
     }
     /**
      * @internal
      */
-    parseRefundEvent(data) {
+    parseRefundEvent(data, version) {
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
         const escrowHash = (0, Utils_1.toEscrowHash)(paymentHash, data.sequence);
         this.logger.debug("RefundEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10) +
             " escrowHash: " + escrowHash);
-        return new base_1.RefundEvent(escrowHash);
+        return new base_1.RefundEvent(escrowHash, version);
     }
     /**
      * @internal
      */
-    parseClaimEvent(data) {
+    parseClaimEvent(data, version) {
         const secret = buffer_1.Buffer.from(data.secret).toString("hex");
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
         const escrowHash = (0, Utils_1.toEscrowHash)(paymentHash, data.sequence);
         this.logger.debug("ClaimEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10) +
             " secret: " + secret + " escrowHash: " + escrowHash);
-        return new base_1.ClaimEvent(escrowHash, secret);
+        return new base_1.ClaimEvent(escrowHash, secret, version);
     }
     /**
      * Processes event as received from the chain, parses it & calls event listeners
      *
      * @param eventObject
+     * @param version
      * @internal
      */
-    async processEvent(eventObject) {
+    async processEvent(eventObject, version) {
         let parsedEvents = eventObject.events.map(event => {
             let parsedEvent;
             switch (event.name) {
                 case "ClaimEvent":
-                    parsedEvent = this.parseClaimEvent(event.data);
+                    parsedEvent = this.parseClaimEvent(event.data, version);
                     break;
                 case "RefundEvent":
-                    parsedEvent = this.parseRefundEvent(event.data);
+                    parsedEvent = this.parseRefundEvent(event.data, version);
                     break;
                 case "InitializeEvent":
-                    parsedEvent = this.parseInitializeEvent(event.data, eventObject);
+                    parsedEvent = this.parseInitializeEvent(event.data, eventObject, version);
                     break;
             }
             if (parsedEvent == null)
@@ -206,21 +223,22 @@ class SolanaChainEventsBrowser {
      * Returns websocket event handler for specific event type
      *
      * @param name
+     * @param version
      * @internal
      * @returns event handler to be passed to program's addEventListener function
      */
-    getWsEventHandler(name) {
+    getWsEventHandler(name, version) {
         return (data, slotNumber, signature) => {
-            if (this.signaturesProcessing[signature] != null)
+            if (this.signaturesProcessing[signature + "-" + version] != null)
                 return;
-            if (this.isSignatureProcessed(signature))
+            if (this.isSignatureProcessed(signature, version))
                 return;
             this.logger.debug("getWsEventHandler(" + name + "): Process signature: ", signature);
-            this.signaturesProcessing[signature] = this.processEvent({
+            this.signaturesProcessing[signature + "-" + version] = this.processEvent({
                 events: [{ name, data: data }],
                 blockTime: Math.floor(Date.now() / 1000),
                 signature
-            }).then(() => true).catch(e => {
+            }, version).then(() => true).catch(e => {
                 this.logger.error("getWsEventHandler(" + name + "): Error processing signature: " + signature, e);
                 return false;
             });
@@ -232,23 +250,28 @@ class SolanaChainEventsBrowser {
      * @internal
      */
     setupWebsocket() {
-        const program = this.solanaSwapProgram.program;
-        this.eventListeners.push(program.addEventListener("InitializeEvent", this.getWsEventHandler("InitializeEvent")));
-        this.eventListeners.push(program.addEventListener("ClaimEvent", this.getWsEventHandler("ClaimEvent")));
-        this.eventListeners.push(program.addEventListener("RefundEvent", this.getWsEventHandler("RefundEvent")));
+        var _a;
+        for (let version in this.contractVersions) {
+            const program = this.contractVersions[version].swapContract.program;
+            const eventListeners = (_a = this.eventListeners)[version] ?? (_a[version] = []);
+            eventListeners.push(program.addEventListener("InitializeEvent", this.getWsEventHandler("InitializeEvent", version)));
+            eventListeners.push(program.addEventListener("ClaimEvent", this.getWsEventHandler("ClaimEvent", version)));
+            eventListeners.push(program.addEventListener("RefundEvent", this.getWsEventHandler("RefundEvent", version)));
+        }
     }
     /**
      * Gets all the new signatures from the last processed signature
      *
      * @param lastProcessedSignature
+     * @param version
      * @private
      */
-    async getNewSignatures(lastProcessedSignature) {
+    async getNewSignatures(lastProcessedSignature, version) {
         let signatures = [];
         let fetched = null;
         while (fetched == null || fetched.length === this.logFetchLimit) {
             if (signatures.length === 0) {
-                fetched = await this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
+                fetched = await this.connection.getSignaturesForAddress(this.contractVersions[version].swapContract.program.programId, {
                     until: lastProcessedSignature.signature,
                     limit: this.logFetchLimit
                 }, "confirmed");
@@ -259,7 +282,7 @@ class SolanaChainEventsBrowser {
                 }
             }
             else {
-                fetched = await this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
+                fetched = await this.connection.getSignaturesForAddress(this.contractVersions[version].swapContract.program.programId, {
                     before: signatures[signatures.length - 1].signature,
                     until: lastProcessedSignature.signature,
                     limit: this.logFetchLimit
@@ -274,8 +297,8 @@ class SolanaChainEventsBrowser {
      *
      * @private
      */
-    async getFirstSignature() {
-        return await this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
+    async getFirstSignature(version) {
+        return await this.connection.getSignaturesForAddress(this.contractVersions[version].swapContract.program.programId, {
             limit: 1
         }, "confirmed");
     }
@@ -283,34 +306,35 @@ class SolanaChainEventsBrowser {
      * Processes signatures, fetches transactions & processes event through event handlers
      *
      * @param signatures
+     * @param version
      * @private
      * @returns {Promise<{signature: string, slot: number}>} latest processed transaction signature and slot height
      */
-    async processSignatures(signatures) {
+    async processSignatures(signatures, version) {
         let lastSuccessfulSignature = null;
         try {
             for (let i = signatures.length - 1; i >= 0; i--) {
                 const txSignature = signatures[i];
                 //Check if signature is already being processed by the
-                const signaturePromise = this.signaturesProcessing[txSignature.signature];
+                const signaturePromise = this.signaturesProcessing[txSignature.signature + "-" + version];
                 if (signaturePromise != null) {
                     const result = await signaturePromise;
-                    delete this.signaturesProcessing[txSignature.signature];
+                    delete this.signaturesProcessing[txSignature.signature + "-" + version];
                     if (result) {
                         lastSuccessfulSignature = txSignature;
-                        this.addProcessedSignature(txSignature.signature);
+                        this.addProcessedSignature(txSignature.signature, version);
                         continue;
                     }
                 }
                 this.logger.debug("processSignatures(): Process signature: ", txSignature);
-                const processPromise = this.fetchTxAndProcessEvent(txSignature.signature);
-                this.signaturesProcessing[txSignature.signature] = processPromise;
+                const processPromise = this.fetchTxAndProcessEvent(txSignature.signature, version);
+                this.signaturesProcessing[txSignature.signature + "-" + version] = processPromise;
                 const result = await processPromise;
                 if (!result)
                     throw new Error("Failed to process signature: " + txSignature);
                 lastSuccessfulSignature = txSignature;
-                this.addProcessedSignature(txSignature.signature);
-                delete this.signaturesProcessing[txSignature.signature];
+                this.addProcessedSignature(txSignature.signature, version);
+                delete this.signaturesProcessing[txSignature.signature + "-" + version];
             }
         }
         catch (e) {
@@ -322,13 +346,22 @@ class SolanaChainEventsBrowser {
      * @inheritDoc
      */
     async poll(lastSignature) {
-        let signatures = lastSignature == null
-            ? await this.getFirstSignature()
-            : await this.getNewSignatures(lastSignature);
-        if (signatures == null)
-            return lastSignature ?? null;
-        let lastSuccessfulSignature = await this.processSignatures(signatures);
-        return lastSuccessfulSignature ?? lastSignature ?? null;
+        const _lastSignature = toNewEventListenerState(lastSignature);
+        const result = {};
+        for (let version in this.contractVersions) {
+            const lastSignature = _lastSignature?.[version];
+            let signatures = lastSignature == null
+                ? await this.getFirstSignature(version)
+                : await this.getNewSignatures(lastSignature, version);
+            if (signatures == null) {
+                result[version] = lastSignature ?? null;
+            }
+            else {
+                let lastSuccessfulSignature = await this.processSignatures(signatures, version);
+                result[version] = lastSuccessfulSignature ?? lastSignature ?? null;
+            }
+        }
+        return result;
     }
     /**
      * @inheritDoc
@@ -343,10 +376,12 @@ class SolanaChainEventsBrowser {
      * @inheritDoc
      */
     async stop() {
-        for (let num of this.eventListeners) {
-            await this.solanaSwapProgram.program.removeEventListener(num);
+        for (let version in this.eventListeners) {
+            for (let num of this.eventListeners[version]) {
+                await this.contractVersions[version].swapContract.program.removeEventListener(num);
+            }
         }
-        this.eventListeners = [];
+        this.eventListeners = {};
     }
     /**
      * @inheritDoc

package/dist/solana/swaps/SolanaSwapData.d.ts

@@ -1,13 +1,15 @@
 import { PublicKey } from "@solana/web3.js";
 import * as BN from "bn.js";
 import { ChainSwapType, SwapData } from "@atomiqlabs/base";
-import { SwapProgram } from "./programTypes";
+import { SwapProgram } from "./v1/programTypes";
 import { IdlAccounts, IdlTypes } from "@coral-xyz/anchor";
 import { Serialized } from "../../utils/Utils";
 import { SingleInstructionWithAccounts } from "../program/modules/SolanaProgramEvents";
-export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
+import { SwapProgramV2 } from "./v2/programTypes";
+export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3] | SwapProgramV2["instructions"][2 | 3], SwapProgram>;
 export type SolanaSwapDataCtorArgs = {
     programId: PublicKey;
+    version: "v1" | "v2";
     offerer: PublicKey;
     claimer: PublicKey;
     token: PublicKey;
@@ -25,6 +27,7 @@ export type SolanaSwapDataCtorArgs = {
     securityDeposit: BN;
     claimerBounty: BN;
     txoHash?: string;
+    offererInitializer?: boolean;
 };
 export declare function isSerializedData(obj: any): obj is ({
     type: "sol";
@@ -39,6 +42,10 @@ export declare class SolanaSwapData extends SwapData {
      * Program ID for which this swap data was created
      */
     programId: PublicKey;
+    /**
+     * Program version for which this swap was created
+     */
+    version: "v1" | "v2";
     /**
      * Offerer address funding the swap.
      */
@@ -107,6 +114,10 @@ export declare class SolanaSwapData extends SwapData {
      * Optional txo hash hint.
      */
     txoHash?: string;
+    /**
+     * Optional flag whether the offerer is the initializer for V2 swap data
+     */
+    offererInitializer?: boolean;
     /**
      * Creates swap data from structured constructor arguments.
      *
@@ -232,7 +243,7 @@ export declare class SolanaSwapData extends SwapData {
      *
      * @param account Escrow account data fetched from chain
      */
-    correctPDA(account: IdlAccounts<SwapProgram>["escrowState"]): boolean;
+    correctPDA(account: IdlAccounts<SwapProgram | SwapProgramV2>["escrowState"]): boolean;
     /**
      * @inheritDoc
      */
@@ -241,18 +252,20 @@ export declare class SolanaSwapData extends SwapData {
      * Converts initialize instruction data into {@link SolanaSwapData}.
      *
      * @param programId
+     * @param version
      * @param initIx Decoded initialize instruction
      * @param txoHash Parsed txo hash hint from initialize event
      * @returns Converted and parsed swap data
      */
-    static fromInstruction(programId: PublicKey, initIx: InitInstruction, txoHash: string): SolanaSwapData;
+    static fromInstruction(programId: PublicKey, version: "v1" | "v2", initIx: InitInstruction, txoHash: string): SolanaSwapData;
     /**
      * Deserializes swap data from an on-chain escrow account state.
      *
      * @param programId
+     * @param version
      * @param account Escrow account state as returned by Anchor
      */
-    static fromEscrowState(programId: PublicKey, account: IdlAccounts<SwapProgram>["escrowState"]): SolanaSwapData;
+    static fromEscrowState(programId: PublicKey, version: "v1" | "v2", account: IdlAccounts<SwapProgram | SwapProgramV2>["escrowState"]): SolanaSwapData;
     /**
      * Converts abstract swap type to Solana program kind discriminator.
      *
@@ -286,3 +299,35 @@ export declare class SolanaSwapData extends SwapData {
      */
     getEscrowStruct(): any;
 }
+export declare class SolanaSwapDataV1 extends SolanaSwapData {
+    /**
+     * Creates swap data from structured constructor arguments.
+     *
+     * @param args Swap data fields
+     */
+    constructor(args: SolanaSwapDataCtorArgs);
+    /**
+     * Deserializes swap data from serialized storage representation.
+     *
+     * @param data Serialized swap data from {@link SolanaSwapData.serialize}
+     */
+    constructor(data: {
+        type: "sol";
+    } & Serialized<SolanaSwapData>);
+}
+export declare class SolanaSwapDataV2 extends SolanaSwapData {
+    /**
+     * Creates swap data from structured constructor arguments.
+     *
+     * @param args Swap data fields
+     */
+    constructor(args: SolanaSwapDataCtorArgs);
+    /**
+     * Deserializes swap data from serialized storage representation.
+     *
+     * @param data Serialized swap data from {@link SolanaSwapData.serialize}
+     */
+    constructor(data: {
+        type: "sol";
+    } & Serialized<SolanaSwapData>);
+}