@atomiqlabs/chain-solana 7.3.8 → 8.0.0-beta.0

package/dist/solana/events/SolanaChainEvents.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaChainEvents = void 0;
 const fs = require("fs/promises");
@@ -32,25 +23,23 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
      *
      * @private
      */
-    getLastSignature() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const txt = (yield fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
-                const arr = txt.split(";");
-                if (arr.length < 2)
-                    return {
-                        signature: txt,
-                        slot: 0
-                    };
+    async getLastSignature() {
+        try {
+            const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
+            const arr = txt.split(";");
+            if (arr.length < 2)
                 return {
-                    signature: arr[0],
-                    slot: parseInt(arr[1])
+                    signature: txt,
+                    slot: 0
                 };
-            }
-            catch (e) {
-                return null;
-            }
-        });
+            return {
+                signature: arr[0],
+                slot: parseInt(arr[1])
+            };
+        }
+        catch (e) {
+            return null;
+        }
     }
     /**
      * Saves last signature & slot to the filesystem
@@ -86,28 +75,26 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
      * @private
      * @returns {boolean} whether the operation was successful
      */
-    fetchTxAndProcessEvent(signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const transaction = yield this.connection.getParsedTransaction(signature, {
-                    commitment: "confirmed",
-                    maxSupportedTransactionVersion: 0
-                });
-                if (transaction == null)
-                    return false;
-                const eventObject = this.getEventObjectFromTransaction(transaction);
-                if (eventObject == null)
-                    return true;
-                console.log("Instructions: ", eventObject.instructions);
-                console.log("Events: ", eventObject.events);
-                yield this.processEvent(eventObject);
-                return true;
-            }
-            catch (e) {
-                console.error(e);
+    async fetchTxAndProcessEvent(signature) {
+        try {
+            const transaction = await this.connection.getParsedTransaction(signature, {
+                commitment: "confirmed",
+                maxSupportedTransactionVersion: 0
+            });
+            if (transaction == null)
                 return false;
-            }
-        });
+            const eventObject = this.getEventObjectFromTransaction(transaction);
+            if (eventObject == null)
+                return true;
+            console.log("Instructions: ", eventObject.instructions);
+            console.log("Events: ", eventObject.events);
+            await this.processEvent(eventObject);
+            return true;
+        }
+        catch (e) {
+            console.error(e);
+            return false;
+        }
     }
     /**
      * Returns websocket event handler for specific event type
@@ -138,45 +125,41 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
      * @param lastProcessedSignature
      * @private
      */
-    getNewSignatures(lastProcessedSignature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let signatures = [];
-            let fetched = null;
-            while (fetched == null || fetched.length === this.logFetchLimit) {
-                if (signatures.length === 0) {
-                    fetched = yield this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
-                        until: lastProcessedSignature.signature,
-                        limit: this.logFetchLimit
-                    }, "confirmed");
-                    //Check if newest returned signature (index 0) is older than the latest signature's slot, this is a sanity check
-                    if (fetched.length > 0 && fetched[0].slot < lastProcessedSignature.slot) {
-                        console.log("[Solana Events POLL] Sanity check triggered, returned signature slot height is older than latest!");
-                        return;
-                    }
-                }
-                else {
-                    fetched = yield this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
-                        before: signatures[signatures.length - 1].signature,
-                        until: lastProcessedSignature.signature,
-                        limit: this.logFetchLimit
-                    }, "confirmed");
+    async getNewSignatures(lastProcessedSignature) {
+        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, {
+                    until: lastProcessedSignature.signature,
+                    limit: this.logFetchLimit
+                }, "confirmed");
+                //Check if newest returned signature (index 0) is older than the latest signature's slot, this is a sanity check
+                if (fetched.length > 0 && fetched[0].slot < lastProcessedSignature.slot) {
+                    console.log("[Solana Events POLL] Sanity check triggered, returned signature slot height is older than latest!");
+                    return;
                 }
-                signatures = signatures.concat(fetched);
             }
-            return signatures;
-        });
+            else {
+                fetched = await this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
+                    before: signatures[signatures.length - 1].signature,
+                    until: lastProcessedSignature.signature,
+                    limit: this.logFetchLimit
+                }, "confirmed");
+            }
+            signatures = signatures.concat(fetched);
+        }
+        return signatures;
     }
     /**
      * Gets single latest known signature
      *
      * @private
      */
-    getFirstSignature() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
-                limit: 1
-            }, "confirmed");
-        });
+    async getFirstSignature() {
+        return await this.connection.getSignaturesForAddress(this.solanaSwapProgram.program.programId, {
+            limit: 1
+        }, "confirmed");
     }
     /**
      * Processes signatures, fetches transactions & processes event through event handlers
@@ -185,78 +168,70 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
      * @private
      * @returns {Promise<{signature: string, slot: number}>} latest processed transaction signature and slot height
      */
-    processSignatures(signatures) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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];
-                    if (signaturePromise != null) {
-                        const result = yield signaturePromise;
-                        delete this.signaturesProcessing[txSignature.signature];
-                        if (result) {
-                            lastSuccessfulSignature = txSignature;
-                            continue;
-                        }
-                    }
-                    console.log("[Solana Events POLL] Process signature: ", txSignature);
-                    const processPromise = this.fetchTxAndProcessEvent(txSignature.signature);
-                    this.signaturesProcessing[txSignature.signature] = processPromise;
-                    const result = yield processPromise;
-                    if (!result)
-                        throw new Error("Failed to process signature: " + txSignature);
-                    lastSuccessfulSignature = txSignature;
+    async processSignatures(signatures) {
+        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];
+                if (signaturePromise != null) {
+                    const result = await signaturePromise;
                     delete this.signaturesProcessing[txSignature.signature];
+                    if (result) {
+                        lastSuccessfulSignature = txSignature;
+                        continue;
+                    }
                 }
+                console.log("[Solana Events POLL] Process signature: ", txSignature);
+                const processPromise = this.fetchTxAndProcessEvent(txSignature.signature);
+                this.signaturesProcessing[txSignature.signature] = processPromise;
+                const result = await processPromise;
+                if (!result)
+                    throw new Error("Failed to process signature: " + txSignature);
+                lastSuccessfulSignature = txSignature;
+                delete this.signaturesProcessing[txSignature.signature];
             }
-            catch (e) {
-                console.error(e);
-            }
-            return lastSuccessfulSignature;
-        });
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return lastSuccessfulSignature;
     }
     /**
      * Polls for new events & processes them
      *
      * @private
      */
-    checkEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const lastSignature = yield this.getLastSignature();
-            let signatures = lastSignature == null ? yield this.getFirstSignature() : yield this.getNewSignatures(lastSignature);
-            let lastSuccessfulSignature = yield this.processSignatures(signatures);
-            if (lastSuccessfulSignature != null) {
-                yield this.saveLastSignature(lastSuccessfulSignature.signature, lastSuccessfulSignature.slot);
-            }
-        });
+    async checkEvents() {
+        const lastSignature = await this.getLastSignature();
+        let signatures = lastSignature == null ? await this.getFirstSignature() : await this.getNewSignatures(lastSignature);
+        let lastSuccessfulSignature = await this.processSignatures(signatures);
+        if (lastSuccessfulSignature != null) {
+            await this.saveLastSignature(lastSuccessfulSignature.signature, lastSuccessfulSignature.slot);
+        }
     }
-    setupHttpPolling() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.stopped = false;
-            let func;
-            func = () => __awaiter(this, void 0, void 0, function* () {
-                yield this.checkEvents().catch(e => {
-                    console.error("Failed to fetch Sol log");
-                    console.error(e);
-                });
-                if (this.stopped)
-                    return;
-                this.timeout = setTimeout(func, this.logFetchInterval);
+    async setupHttpPolling() {
+        this.stopped = false;
+        let func;
+        func = async () => {
+            await this.checkEvents().catch(e => {
+                console.error("Failed to fetch Sol log");
+                console.error(e);
             });
-            yield func();
-        });
+            if (this.stopped)
+                return;
+            this.timeout = setTimeout(func, this.logFetchInterval);
+        };
+        await func();
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield fs.mkdir(this.directory);
-            }
-            catch (e) { }
-            yield this.setupHttpPolling();
-            this.setupWebsocket();
-        });
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+        await this.setupHttpPolling();
+        this.setupWebsocket();
     }
     stop() {
         this.stopped = true;

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
@@ -36,23 +27,21 @@ class SolanaChainEventsBrowser {
      * @private
      * @returns {Promise<InstructionWithAccounts<SwapProgram>[]>} array of parsed instructions
      */
-    getTransactionInstructions(signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield (0, Utils_1.tryWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                const res = yield 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);
+    async getTransactionInstructions(signature) {
+        const transaction = await (0, Utils_1.tryWithRetries)(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);
     }
     /**
      * Converts initialize instruction data into {SolanaSwapData}
@@ -83,33 +72,39 @@ class SolanaChainEventsBrowser {
      * @returns {() => Promise<SolanaSwapData>} getter to be passed to InitializeEvent constructor
      */
     getSwapDataGetter(eventObject, txoHash) {
-        return () => __awaiter(this, void 0, void 0, function* () {
+        return async () => {
             if (eventObject.instructions == null)
-                eventObject.instructions = yield this.getTransactionInstructions(eventObject.signature);
+                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"));
             if (initIx == null)
                 return null;
             return this.instructionToSwapData(initIx, txoHash);
-        });
+        };
     }
     parseInitializeEvent(data, eventObject) {
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
         const txoHash = buffer_1.Buffer.from(data.txoHash).toString("hex");
-        this.logger.debug("InitializeEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10) + " txoHash: " + txoHash);
-        return new base_1.InitializeEvent(paymentHash, data.sequence, txoHash, SwapTypeEnum_1.SwapTypeEnum.toChainSwapType(data.kind), (0, Utils_1.onceAsync)(this.getSwapDataGetter(eventObject, txoHash)));
+        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)));
     }
     parseRefundEvent(data) {
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
-        this.logger.debug("RefundEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10));
-        return new base_1.RefundEvent(paymentHash, data.sequence);
+        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);
     }
     parseClaimEvent(data) {
         const secret = buffer_1.Buffer.from(data.secret).toString("hex");
         const paymentHash = buffer_1.Buffer.from(data.hash).toString("hex");
-        this.logger.debug("ClaimEvent paymentHash: " + paymentHash + " sequence: " + data.sequence.toString(10) + " secret: " + secret);
-        return new base_1.ClaimEvent(paymentHash, data.sequence, secret);
+        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);
     }
     /**
      * Processes event as received from the chain, parses it & calls event listeners
@@ -117,31 +112,29 @@ class SolanaChainEventsBrowser {
      * @param eventObject
      * @protected
      */
-    processEvent(eventObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let parsedEvents = eventObject.events.map(event => {
-                let parsedEvent;
-                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.meta = {
-                    timestamp: eventObject.blockTime,
-                    txId: eventObject.signature
-                };
-                return parsedEvent;
-            }).filter(parsedEvent => parsedEvent != null);
-            for (let listener of this.listeners) {
-                yield listener(parsedEvents);
+    async processEvent(eventObject) {
+        let parsedEvents = eventObject.events.map(event => {
+            let parsedEvent;
+            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.meta = {
+                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
@@ -179,13 +172,11 @@ class SolanaChainEventsBrowser {
         this.setupWebsocket();
         return Promise.resolve();
     }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let num of this.eventListeners) {
-                yield this.solanaSwapProgram.program.removeEventListener(num);
-            }
-            this.eventListeners = [];
-        });
+    async stop() {
+        for (let num of this.eventListeners) {
+            await this.solanaSwapProgram.program.removeEventListener(num);
+        }
+        this.eventListeners = [];
     }
     registerListener(cbk) {
         this.listeners.push(cbk);

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaProgramEvents = void 0;
 const SolanaEvents_1 = require("../../base/modules/SolanaEvents");
@@ -29,18 +20,16 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
      * @param signature
      * @private
      */
-    getEvents(signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = yield this.connection.getTransaction(signature, {
-                commitment: "confirmed",
-                maxSupportedTransactionVersion: 0
-            });
-            if (tx.meta.err)
-                return [];
-            const events = this.parseLogs(tx.meta.logMessages);
-            events.reverse();
-            return events;
+    async getEvents(signature) {
+        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
@@ -52,17 +41,17 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
      */
     findInEvents(topicKey, processor, abortSignal, logBatchSize) {
-        return this.findInSignatures(topicKey, (signatures) => __awaiter(this, void 0, void 0, function* () {
+        return this.findInSignatures(topicKey, async (signatures) => {
             for (let data of signatures) {
-                for (let event of yield this.getEvents(data.signature)) {
+                for (let event of await this.getEvents(data.signature)) {
                     if (abortSignal != null)
                         abortSignal.throwIfAborted();
-                    const result = yield processor(event);
+                    const result = await processor(event);
                     if (result != null)
                         return result;
                 }
             }
-        }), abortSignal, logBatchSize);
+        }, abortSignal, logBatchSize);
     }
     /**
      * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array

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

@@ -28,22 +28,24 @@ export declare class SolanaSwapData extends SwapData {
     getClaimer(): string;
     setClaimer(newClaimer: string): void;
     serialize(): any;
-    getAmount(): BN;
+    getAmount(): bigint;
     getToken(): string;
     isToken(token: string): boolean;
     getType(): ChainSwapType;
-    getExpiry(): BN;
-    getConfirmations(): number;
-    getEscrowNonce(): BN;
+    getExpiry(): bigint;
+    getConfirmationsHint(): number;
+    getNonceHint(): bigint;
     isPayIn(): boolean;
     isPayOut(): boolean;
-    getHash(): string;
-    getSequence(): BN;
-    getTxoHash(): string;
-    setTxoHash(txoHash: string): void;
-    getSecurityDeposit(): BN;
-    getClaimerBounty(): BN;
-    getTotalDeposit(): BN;
+    getClaimHash(): string;
+    getEscrowHash(): string;
+    getSequence(): bigint;
+    getTxoHashHint(): string;
+    getExtraData(): string;
+    setExtraData(txoHash: string): void;
+    getSecurityDeposit(): bigint;
+    getClaimerBounty(): bigint;
+    getTotalDeposit(): bigint;
     toSwapDataStruct(): IdlTypes<SwapProgram>["SwapData"];
     correctPDA(account: IdlAccounts<SwapProgram>["escrowState"]): boolean;
     equals(other: SolanaSwapData): boolean;
@@ -52,4 +54,6 @@ export declare class SolanaSwapData extends SwapData {
     static kindToType(value: number): ChainSwapType;
     isClaimer(address: string): boolean;
     isOfferer(address: string): boolean;
+    getDepositToken(): string;
+    isDepositToken(token: string): boolean;
 }