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

package/dist/solana/SolanaChains.d.ts

@@ -1,4 +1,10 @@
 export declare const SolanaChains: {
+    readonly 2: {
+        readonly addresses: {
+            readonly swapContract: "11111111111111111111111111111111";
+            readonly btcRelayContract: "11111111111111111111111111111111";
+        };
+    };
     readonly 1: {
         readonly addresses: {
             readonly swapContract: "4hfUykhqmD7ZRvNh1HuzVKEY7ToENixtdUKZspNDCrEM";

package/dist/solana/SolanaChains.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaChains = void 0;
 const base_1 = require("@atomiqlabs/base");
 exports.SolanaChains = {
+    //TODO: Not deployed yet
+    [base_1.BitcoinNetwork.TESTNET4]: {
+        addresses: {
+            swapContract: "11111111111111111111111111111111",
+            btcRelayContract: "11111111111111111111111111111111"
+        }
+    },
     [base_1.BitcoinNetwork.TESTNET]: {
         addresses: {
             swapContract: "4hfUykhqmD7ZRvNh1HuzVKEY7ToENixtdUKZspNDCrEM",

package/dist/solana/chain/modules/SolanaFees.js

@@ -107,7 +107,6 @@ class SolanaFees {
         });
         if (request.ok) {
             const parsedResponse = await request.json();
-            // console.log(parsedResponse);
             return parsedResponse.result;
         }
         throw new Error(await request.text());

package/dist/solana/events/SolanaChainEvents.js

@@ -98,13 +98,11 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
             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);
+            this.logger.error("fetchTxAndProcessEvent(): Error fetching transaction and processing event, signature: " + signature, e);
             return false;
         }
     }
@@ -121,14 +119,14 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
                 return;
             if (this.isSignatureProcessed(signature))
                 return;
-            console.log("[Solana Events WebSocket] Process signature: ", signature);
+            this.logger.debug("getWsEventHandler(" + name + "): Process signature: ", signature);
             this.signaturesProcessing[signature] = this.processEvent({
                 events: [{ name, data: data }],
                 instructions: null,
                 blockTime: Math.floor(Date.now() / 1000),
                 signature
             }).then(() => true).catch(e => {
-                console.error(e);
+                this.logger.error("getWsEventHandler(" + name + "): Error processing signature: " + signature, e);
                 return false;
             });
         };
@@ -150,7 +148,7 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
                 }, "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!");
+                    this.logger.debug("getNewSignatures(): Sanity check triggered, returned signature slot height is older than latest!");
                     return;
                 }
             }
@@ -198,7 +196,7 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
                         continue;
                     }
                 }
-                console.log("[Solana Events POLL] Process signature: ", txSignature);
+                this.logger.debug("processSignatures(): Process signature: ", txSignature);
                 const processPromise = this.fetchTxAndProcessEvent(txSignature.signature);
                 this.signaturesProcessing[txSignature.signature] = processPromise;
                 const result = await processPromise;
@@ -210,7 +208,7 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
             }
         }
         catch (e) {
-            console.error(e);
+            this.logger.error("processSignatures(): Failed processing signatures: ", e);
         }
         return lastSuccessfulSignature;
     }
@@ -232,8 +230,7 @@ class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrow
         let func;
         func = async () => {
             await this.checkEvents().catch(e => {
-                console.error("Failed to fetch Sol log");
-                console.error(e);
+                this.logger.error("setupHttpPolling(): Failed to fetch Solana log: ", e);
             });
             if (this.stopped)
                 return;

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -153,7 +153,7 @@ class SolanaChainEventsBrowser {
                 blockTime: Math.floor(Date.now() / 1000),
                 signature
             }).then(() => true).catch(e => {
-                console.error(e);
+                this.logger.error("wsEventHandler: Error when processing signature: " + signature, e);
                 return false;
             });
         };

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

@@ -1,7 +1,7 @@
 import { SolanaEvents } from "../../chain/modules/SolanaEvents";
 import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
 import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
-import { ParsedMessage, PublicKey } from "@solana/web3.js";
+import { ConfirmedSignatureInfo, ParsedMessage, 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;
@@ -41,7 +41,7 @@ export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
      * @param abortSignal
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
      */
-    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number): Promise<T>;
+    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number): Promise<T>;
     /**
      * 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)

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

@@ -46,7 +46,7 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
                 for (let event of await this.getEvents(data.signature)) {
                     if (abortSignal != null)
                         abortSignal.throwIfAborted();
-                    const result = await processor(event);
+                    const result = await processor(event, data);
                     if (result != null)
                         return result;
                 }

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

@@ -2,7 +2,7 @@
 import { SolanaSwapData } from "./SolanaSwapData";
 import { PublicKey } from "@solana/web3.js";
 import { SolanaBtcRelay } from "../btcrelay/SolanaBtcRelay";
-import { IStorageManager, SwapContract, ChainSwapType, IntermediaryReputationType, SwapCommitStatus, TransactionConfirmationOptions, SignatureData, RelaySynchronizer } from "@atomiqlabs/base";
+import { IStorageManager, SwapContract, ChainSwapType, IntermediaryReputationType, TransactionConfirmationOptions, SignatureData, RelaySynchronizer, SwapCommitState, SwapCommitStateType } from "@atomiqlabs/base";
 import { SolanaBtcStoredHeader } from "../btcrelay/headers/SolanaBtcStoredHeader";
 import { SwapProgram } from "./programTypes";
 import { SolanaChainInterface } from "../chain/SolanaChainInterface";
@@ -47,7 +47,7 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     preFetchForInitSignatureVerification(data: SolanaPreFetchData): Promise<SolanaPreFetchVerification>;
     preFetchBlockDataForSignatures(): Promise<SolanaPreFetchData>;
     getInitSignature(signer: SolanaSigner, swapData: SolanaSwapData, authorizationTimeout: number, preFetchedBlockData?: SolanaPreFetchData, feeRate?: string): Promise<SignatureData>;
-    isValidInitAuthorization(swapData: SolanaSwapData, { timeout, prefix, signature }: {
+    isValidInitAuthorization(signer: string, swapData: SolanaSwapData, { timeout, prefix, signature }: {
         timeout: any;
         prefix: any;
         signature: any;
@@ -117,13 +117,13 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      * @param signer
      * @param data
      */
-    getCommitStatus(signer: string, data: SolanaSwapData): Promise<SwapCommitStatus>;
+    getCommitStatus(signer: string, data: SolanaSwapData): Promise<SwapCommitState>;
     /**
      * Checks the status of the specific payment hash
      *
      * @param claimHash
      */
-    getClaimHashStatus(claimHash: string): Promise<SwapCommitStatus>;
+    getClaimHashStatus(claimHash: string): Promise<SwapCommitStateType>;
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
      *  the specific swap
@@ -155,7 +155,7 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
         prefix: any;
         signature: any;
     }, check?: boolean, initAta?: boolean, feeRate?: string): Promise<SolanaTx[]>;
-    txsInit(swapData: SolanaSwapData, { timeout, prefix, signature }: {
+    txsInit(sender: string, swapData: SolanaSwapData, { timeout, prefix, signature }: {
         timeout: any;
         prefix: any;
         signature: any;
@@ -185,18 +185,18 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    getCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    getRawCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    getRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    getRawRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
 }

package/dist/solana/swaps/SolanaSwapProgram.js

@@ -67,8 +67,8 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     getInitSignature(signer, swapData, authorizationTimeout, preFetchedBlockData, feeRate) {
         return this.Init.signSwapInitialization(signer, swapData, authorizationTimeout, preFetchedBlockData, feeRate);
     }
-    isValidInitAuthorization(swapData, { timeout, prefix, signature }, feeRate, preFetchedData) {
-        return this.Init.isSignatureValid(swapData, timeout, prefix, signature, feeRate, preFetchedData);
+    isValidInitAuthorization(signer, swapData, { timeout, prefix, signature }, feeRate, preFetchedData) {
+        return this.Init.isSignatureValid(signer, swapData, timeout, prefix, signature, feeRate, preFetchedData);
     }
     getInitAuthorizationExpiry(swapData, { timeout, prefix, signature }, preFetchedData) {
         return this.Init.getSignatureExpiry(timeout, signature, preFetchedData);
@@ -186,34 +186,49 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         if (escrowState != null) {
             if (data.correctPDA(escrowState)) {
                 if (data.isOfferer(signer) && isExpired)
-                    return base_1.SwapCommitStatus.REFUNDABLE;
-                return base_1.SwapCommitStatus.COMMITED;
+                    return { type: base_1.SwapCommitStateType.REFUNDABLE };
+                return { type: base_1.SwapCommitStateType.COMMITED };
             }
             if (data.isOfferer(signer) && isExpired)
-                return base_1.SwapCommitStatus.EXPIRED;
-            return base_1.SwapCommitStatus.NOT_COMMITED;
+                return { type: base_1.SwapCommitStateType.EXPIRED };
+            return { type: base_1.SwapCommitStateType.NOT_COMMITED };
         }
         //Check if paid or what
-        const status = await this.Events.findInEvents(escrowStateKey, async (event) => {
+        const status = await this.Events.findInEvents(escrowStateKey, async (event, info) => {
             if (event.name === "ClaimEvent") {
                 if (!event.data.sequence.eq(data.sequence))
                     return null;
-                return base_1.SwapCommitStatus.PAID;
+                return {
+                    type: base_1.SwapCommitStateType.PAID,
+                    getClaimTxId: () => Promise.resolve(info.signature),
+                    getTxBlock: async () => {
+                        return {
+                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
+                            blockTime: info.blockTime
+                        };
+                    }
+                };
             }
             if (event.name === "RefundEvent") {
                 if (!event.data.sequence.eq(data.sequence))
                     return null;
-                if (isExpired)
-                    return base_1.SwapCommitStatus.EXPIRED;
-                return base_1.SwapCommitStatus.NOT_COMMITED;
+                return {
+                    type: isExpired ? base_1.SwapCommitStateType.EXPIRED : base_1.SwapCommitStateType.NOT_COMMITED,
+                    getRefundTxId: () => Promise.resolve(info.signature),
+                    getTxBlock: async () => {
+                        return {
+                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
+                            blockTime: info.blockTime
+                        };
+                    }
+                };
             }
         });
         if (status != null)
             return status;
-        if (isExpired) {
-            return base_1.SwapCommitStatus.EXPIRED;
-        }
-        return base_1.SwapCommitStatus.NOT_COMMITED;
+        if (isExpired)
+            return { type: base_1.SwapCommitStateType.EXPIRED };
+        return { type: base_1.SwapCommitStateType.NOT_COMMITED };
     }
     /**
      * Checks the status of the specific payment hash
@@ -227,9 +242,9 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         //Start fetching events before checking escrow PDA, this call is used when quoting, so saving 100ms here helps a lot!
         const eventsPromise = this.Events.findInEvents(escrowStateKey, async (event) => {
             if (event.name === "ClaimEvent")
-                return base_1.SwapCommitStatus.PAID;
+                return base_1.SwapCommitStateType.PAID;
             if (event.name === "RefundEvent")
-                return base_1.SwapCommitStatus.NOT_COMMITED;
+                return base_1.SwapCommitStateType.NOT_COMMITED;
         }, abortController.signal).catch(e => {
             abortController.abort(e);
             return null;
@@ -238,14 +253,14 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         abortController.signal.throwIfAborted();
         if (escrowState != null) {
             abortController.abort();
-            return base_1.SwapCommitStatus.COMMITED;
+            return base_1.SwapCommitStateType.COMMITED;
         }
         //Check if paid or what
         const eventsStatus = await eventsPromise;
         abortController.signal.throwIfAborted();
         if (eventsStatus != null)
             return eventsStatus;
-        return base_1.SwapCommitStatus.NOT_COMMITED;
+        return base_1.SwapCommitStateType.NOT_COMMITED;
     }
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
@@ -313,11 +328,15 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             throw new Error("Only offerer can refund on Solana");
         return this.Refund.txsRefundWithAuthorization(swapData, timeout, prefix, signature, check, initAta, feeRate);
     }
-    txsInit(swapData, { timeout, prefix, signature }, skipChecks, feeRate) {
+    txsInit(sender, swapData, { timeout, prefix, signature }, skipChecks, feeRate) {
         if (swapData.isPayIn()) {
+            if (!swapData.isOfferer(sender))
+                throw new Error("Only offerer can create payIn=true swap");
             return this.Init.txsInitPayIn(swapData, timeout, prefix, signature, skipChecks, feeRate);
         }
         else {
+            if (!swapData.isClaimer(sender))
+                throw new Error("Only claimer can create payIn=false swap");
             return this.Init.txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate);
         }
     }
@@ -367,14 +386,14 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             if (!signer.getPublicKey().equals(swapData.claimer))
                 throw new Error("Invalid signer provided!");
         }
-        const result = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
+        const result = await this.txsInit(signer.getAddress(), swapData, signature, skipChecks, txOptions?.feeRate);
         const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return txSignature;
     }
     async initAndClaimWithSecret(signer, swapData, signature, secret, skipChecks, txOptions) {
         if (!signer.getPublicKey().equals(swapData.claimer))
             throw new Error("Invalid signer provided!");
-        const txsCommit = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
+        const txsCommit = await this.txsInit(signer.getAddress(), swapData, signature, skipChecks, txOptions?.feeRate);
         const txsClaim = await this.Claim.txsClaimWithSecret(signer.getPublicKey(), swapData, secret, true, false, txOptions?.feeRate, true);
         return await this.Chain.sendAndConfirm(signer, txsCommit.concat(txsClaim), txOptions?.waitForConfirmation, txOptions?.abortSignal);
     }
@@ -413,25 +432,25 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData, feeRate) {
+    getCommitFee(signer, swapData, feeRate) {
         return this.Init.getInitFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData, feeRate) {
+    getRawCommitFee(signer, swapData, feeRate) {
         return this.Init.getRawInitFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(swapData, feeRate) {
+    getRefundFee(signer, swapData, feeRate) {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData, feeRate) {
+    getRawRefundFee(signer, swapData, feeRate) {
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
     getExtraData(outputScript, amount, confirmations, nonce) {

package/dist/solana/swaps/modules/SwapInit.d.ts

@@ -135,6 +135,7 @@ export declare class SwapInit extends SolanaSwapModule {
     /**
      * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
      *
+     * @param sender
      * @param swapData
      * @param timeout
      * @param prefix
@@ -143,7 +144,7 @@ export declare class SwapInit extends SolanaSwapModule {
      * @param preFetchedData
      * @public
      */
-    isSignatureValid(swapData: SolanaSwapData, timeout: string, prefix: string, signature: string, feeRate?: string, preFetchedData?: SolanaPreFetchVerification): Promise<Buffer>;
+    isSignatureValid(sender: string, swapData: SolanaSwapData, timeout: string, prefix: string, signature: string, feeRate?: string, preFetchedData?: SolanaPreFetchVerification): Promise<Buffer>;
     /**
      * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
      *

package/dist/solana/swaps/modules/SwapInit.js

@@ -257,6 +257,7 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
     /**
      * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
      *
+     * @param sender
      * @param swapData
      * @param timeout
      * @param prefix
@@ -265,8 +266,15 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      * @param preFetchedData
      * @public
      */
-    async isSignatureValid(swapData, timeout, prefix, signature, feeRate, preFetchedData) {
-        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+    async isSignatureValid(sender, swapData, timeout, prefix, signature, feeRate, preFetchedData) {
+        if (swapData.isPayIn()) {
+            if (!swapData.isOfferer(sender))
+                throw new base_1.SignatureVerificationError("Sender needs to be offerer in payIn=true swaps");
+        }
+        else {
+            if (!swapData.isClaimer(sender))
+                throw new base_1.SignatureVerificationError("Sender needs to be claimer in payIn=false swaps");
+        }
         const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
         if (!swapData.isPayIn() && await this.program.isExpired(sender.toString(), swapData)) {
             throw new base_1.SignatureVerificationError("Swap will expire too soon!");
@@ -288,7 +296,7 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
         if (slotsLeft < 0)
             throw new base_1.SignatureVerificationError("Authorization expired!");
         const txToSign = await this.getTxToSign(swapData, timeout, feeRate);
-        txToSign.feePayer = sender;
+        txToSign.feePayer = new web3_js_1.PublicKey(sender);
         txToSign.recentBlockhash = blockhash;
         txToSign.addSignature(signer, buffer_1.Buffer.from(signatureString, "hex"));
         this.logger.debug("isSignatureValid(): Signed tx: ", txToSign);
@@ -353,10 +361,10 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
     async txsInitPayIn(swapData, timeout, prefix, signature, skipChecks, feeRate) {
         if (!skipChecks) {
             const [_, payStatus] = await Promise.all([
-                (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
+                (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData.getOfferer(), swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
                 (0, Utils_1.tryWithRetries)(() => this.program.getClaimHashStatus(swapData.getClaimHash()), this.retryPolicy)
             ]);
-            if (payStatus !== base_1.SwapCommitStatus.NOT_COMMITED)
+            if (payStatus !== base_1.SwapCommitStateType.NOT_COMMITED)
                 throw new base_1.SwapDataVerificationError("Invoice already being paid for or paid");
         }
         const [slotNumber, signatureStr] = signature.split(";");
@@ -393,7 +401,7 @@ class SwapInit extends SolanaSwapModule_1.SolanaSwapModule {
      */
     async txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate) {
         if (!skipChecks) {
-            await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+            await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData.getClaimer(), swapData, timeout, prefix, signature, feeRate), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
         }
         const [slotNumber, signatureStr] = signature.split(";");
         const block = await (0, Utils_1.tryWithRetries)(() => this.root.Blocks.getParsedBlock(parseInt(slotNumber)), this.retryPolicy);

package/dist/solana/swaps/modules/SwapRefund.js

@@ -185,7 +185,6 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
             throw new base_1.SwapDataVerificationError("ATA not initialized");
         if (feeRate == null)
             feeRate = await this.program.getRefundFeeRate(swapData);
-        console.log("[SolanaSwapProgram] txsRefundsWithAuthorization: feeRate: ", feeRate);
         const signatureBuffer = buffer_1.Buffer.from(signature, "hex");
         const shouldUnwrap = this.shouldUnwrap(swapData);
         const action = await this.RefundWithSignature(swapData, timeout, prefix, signatureBuffer);

package/dist/utils/Utils.js

@@ -31,10 +31,10 @@ function onceAsync(executor) {
 exports.onceAsync = onceAsync;
 function getLogger(prefix) {
     return {
-        debug: (msg, ...args) => console.debug(prefix + msg, ...args),
-        info: (msg, ...args) => console.info(prefix + msg, ...args),
-        warn: (msg, ...args) => console.warn(prefix + msg, ...args),
-        error: (msg, ...args) => console.error(prefix + msg, ...args)
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
     };
 }
 exports.getLogger = getLogger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-solana",
-  "version": "9.0.0",
+  "version": "10.0.0-dev.3",
   "description": "Solana specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^9.0.0",
+    "@atomiqlabs/base": "^10.0.0-dev.2",
     "@noble/hashes": "^1.7.1",
     "bn.js": "5.2.1",
     "bs58": "4.0.1",

package/src/solana/SolanaChains.ts

@@ -1,6 +1,13 @@
 import {BitcoinNetwork} from "@atomiqlabs/base";
 
 export const SolanaChains = {
+    //TODO: Not deployed yet
+    [BitcoinNetwork.TESTNET4]: {
+        addresses: {
+            swapContract: "11111111111111111111111111111111",
+            btcRelayContract: "11111111111111111111111111111111"
+        }
+    },
     [BitcoinNetwork.TESTNET]: {
         addresses: {
             swapContract: "4hfUykhqmD7ZRvNh1HuzVKEY7ToENixtdUKZspNDCrEM",

package/src/solana/chain/modules/SolanaFees.ts

@@ -157,7 +157,6 @@ export class SolanaFees {
 
         if(request.ok) {
             const parsedResponse = await request.json();
-            // console.log(parsedResponse);
             return parsedResponse.result;
         }
 

package/src/solana/events/SolanaChainEvents.ts

@@ -125,13 +125,10 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
             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);
+            this.logger.error("fetchTxAndProcessEvent(): Error fetching transaction and processing event, signature: "+signature, e);
             return false;
         }
     }
@@ -150,7 +147,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
             if(this.signaturesProcessing[signature]!=null) return;
             if(this.isSignatureProcessed(signature)) return;
 
-            console.log("[Solana Events WebSocket] Process signature: ", signature);
+            this.logger.debug("getWsEventHandler("+name+"): Process signature: ", signature);
 
             this.signaturesProcessing[signature] = this.processEvent({
                 events: [{name, data: data as any}],
@@ -158,7 +155,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
                 blockTime: Math.floor(Date.now()/1000),
                 signature
             }).then(() => true).catch(e => {
-                console.error(e);
+                this.logger.error("getWsEventHandler("+name+"): Error processing signature: "+signature, e);
                 return false;
             });
         };
@@ -182,7 +179,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
                 }, "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!");
+                    this.logger.debug("getNewSignatures(): Sanity check triggered, returned signature slot height is older than latest!");
                     return;
                 }
             } else {
@@ -236,7 +233,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
                     }
                 }
 
-                console.log("[Solana Events POLL] Process signature: ", txSignature);
+                this.logger.debug("processSignatures(): Process signature: ", txSignature);
 
                 const processPromise: Promise<boolean> = this.fetchTxAndProcessEvent(txSignature.signature);
                 this.signaturesProcessing[txSignature.signature] = processPromise;
@@ -248,7 +245,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
                 delete this.signaturesProcessing[txSignature.signature];
             }
         } catch (e) {
-            console.error(e);
+            this.logger.error("processSignatures(): Failed processing signatures: ", e);
         }
         return lastSuccessfulSignature;
     }
@@ -276,8 +273,7 @@ export class SolanaChainEvents extends SolanaChainEventsBrowser {
         let func;
         func = async () => {
             await this.checkEvents().catch(e => {
-                console.error("Failed to fetch Sol log");
-                console.error(e);
+                this.logger.error("setupHttpPolling(): Failed to fetch Solana log: ", e);
             });
             if(this.stopped) return;
             this.timeout = setTimeout(func, this.logFetchInterval);

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -211,7 +211,7 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
                 blockTime: Math.floor(Date.now()/1000),
                 signature
             }).then(() => true).catch(e => {
-                console.error(e);
+                this.logger.error("wsEventHandler: Error when processing signature: "+signature, e);
                 return false;
             });
         };

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

@@ -70,7 +70,7 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
      */
     public findInEvents<T>(
         topicKey: PublicKey,
-        processor: (event: ProgramEvent<IDL>) => Promise<T>,
+        processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>,
         abortSignal?: AbortSignal,
         logBatchSize?: number
     ): Promise<T> {
@@ -78,7 +78,7 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
             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);
+                    const result: T = await processor(event, data);
                     if(result!=null) return result;
                 }
             }

package/src/solana/swaps/SolanaSwapProgram.ts

@@ -1,23 +1,29 @@
 import {SolanaSwapData} from "./SolanaSwapData";
 import {IdlAccounts} from "@coral-xyz/anchor";
 import {
-    Connection,
     PublicKey,
 } from "@solana/web3.js";
 import {sha256} from "@noble/hashes/sha2";
 import {SolanaBtcRelay} from "../btcrelay/SolanaBtcRelay";
 import * as programIdl from "./programIdl.json";
 import {
-    IStorageManager, SwapContract, ChainSwapType, IntermediaryReputationType,
-    SwapCommitStatus, TransactionConfirmationOptions, SignatureData, RelaySynchronizer, BigIntBufferUtils
+    IStorageManager,
+    SwapContract,
+    ChainSwapType,
+    IntermediaryReputationType,
+    TransactionConfirmationOptions,
+    SignatureData,
+    RelaySynchronizer,
+    BigIntBufferUtils,
+    SwapCommitState,
+    SwapCommitStateType, SwapNotCommitedState, SwapExpiredState, SwapPaidState
 } from "@atomiqlabs/base";
 import {SolanaBtcStoredHeader} from "../btcrelay/headers/SolanaBtcStoredHeader";
 import {
     getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
-import {SolanaFees} from "../chain/modules/SolanaFees";
 import {SwapProgram} from "./programTypes";
-import {SolanaChainInterface, SolanaRetryPolicy} from "../chain/SolanaChainInterface";
+import {SolanaChainInterface} from "../chain/SolanaChainInterface";
 import {SolanaProgramBase} from "../program/SolanaProgramBase";
 import {SolanaTx} from "../chain/modules/SolanaTransactions";
 import {SwapInit, SolanaPreFetchData, SolanaPreFetchVerification} from "./modules/SwapInit";
@@ -118,8 +124,8 @@ export class SolanaSwapProgram
         return this.Init.signSwapInitialization(signer, swapData, authorizationTimeout, preFetchedBlockData, feeRate);
     }
 
-    isValidInitAuthorization(swapData: SolanaSwapData, {timeout, prefix, signature}, feeRate?: string, preFetchedData?: SolanaPreFetchVerification): Promise<Buffer> {
-        return this.Init.isSignatureValid(swapData, timeout, prefix, signature, feeRate, preFetchedData);
+    isValidInitAuthorization(signer: string, swapData: SolanaSwapData, {timeout, prefix, signature}, feeRate?: string, preFetchedData?: SolanaPreFetchVerification): Promise<Buffer> {
+        return this.Init.isSignatureValid(signer, swapData, timeout, prefix, signature, feeRate, preFetchedData);
     }
 
     getInitAuthorizationExpiry(swapData: SolanaSwapData, {timeout, prefix, signature}, preFetchedData?: SolanaPreFetchVerification): Promise<number> {
@@ -245,7 +251,7 @@ export class SolanaSwapProgram
      * @param signer
      * @param data
      */
-    async getCommitStatus(signer: string, data: SolanaSwapData): Promise<SwapCommitStatus> {
+    async getCommitStatus(signer: string, data: SolanaSwapData): Promise<SwapCommitState> {
         const escrowStateKey = this.SwapEscrowState(Buffer.from(data.paymentHash, "hex"));
         const [escrowState, isExpired] = await Promise.all([
             this.program.account.escrowState.fetchNullable(escrowStateKey) as Promise<IdlAccounts<SwapProgram>["escrowState"]>,
@@ -254,32 +260,47 @@ export class SolanaSwapProgram
 
         if(escrowState!=null) {
             if(data.correctPDA(escrowState)) {
-                if(data.isOfferer(signer) && isExpired) return SwapCommitStatus.REFUNDABLE;
-                return SwapCommitStatus.COMMITED;
+                if(data.isOfferer(signer) && isExpired) return {type: SwapCommitStateType.REFUNDABLE};
+                return {type: SwapCommitStateType.COMMITED};
             }
 
-            if(data.isOfferer(signer) && isExpired) return SwapCommitStatus.EXPIRED;
-            return SwapCommitStatus.NOT_COMMITED;
+            if(data.isOfferer(signer) && isExpired) return {type: SwapCommitStateType.EXPIRED};
+            return {type: SwapCommitStateType.NOT_COMMITED};
         }
 
         //Check if paid or what
-        const status = await this.Events.findInEvents(escrowStateKey, async (event) => {
+        const status: SwapNotCommitedState | SwapExpiredState | SwapPaidState = await this.Events.findInEvents(escrowStateKey, async (event, info) => {
             if(event.name==="ClaimEvent") {
                 if(!event.data.sequence.eq(data.sequence)) return null;
-                return SwapCommitStatus.PAID;
+                return {
+                    type: SwapCommitStateType.PAID,
+                    getClaimTxId: () => Promise.resolve(info.signature),
+                    getTxBlock: async () => {
+                        return {
+                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
+                            blockTime: info.blockTime
+                        };
+                    }
+                }
             }
             if(event.name==="RefundEvent") {
                 if(!event.data.sequence.eq(data.sequence)) return null;
-                if(isExpired) return SwapCommitStatus.EXPIRED;
-                return SwapCommitStatus.NOT_COMMITED;
+                return {
+                    type: isExpired ? SwapCommitStateType.EXPIRED : SwapCommitStateType.NOT_COMMITED,
+                    getRefundTxId: () => Promise.resolve(info.signature),
+                    getTxBlock: async () => {
+                        return {
+                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
+                            blockTime: info.blockTime
+                        };
+                    }
+                };
             }
         });
         if(status!=null) return status;
 
-        if(isExpired) {
-            return SwapCommitStatus.EXPIRED;
-        }
-        return SwapCommitStatus.NOT_COMMITED;
+        if(isExpired) return {type: SwapCommitStateType.EXPIRED};
+        return {type: SwapCommitStateType.NOT_COMMITED};
     }
 
     /**
@@ -287,15 +308,15 @@ export class SolanaSwapProgram
      *
      * @param claimHash
      */
-    async getClaimHashStatus(claimHash: string): Promise<SwapCommitStatus> {
+    async getClaimHashStatus(claimHash: string): Promise<SwapCommitStateType> {
         const {paymentHash} = fromClaimHash(claimHash);
         const escrowStateKey = this.SwapEscrowState(Buffer.from(paymentHash, "hex"));
         const abortController = new AbortController();
 
         //Start fetching events before checking escrow PDA, this call is used when quoting, so saving 100ms here helps a lot!
         const eventsPromise = this.Events.findInEvents(escrowStateKey, async (event) => {
-            if(event.name==="ClaimEvent") return SwapCommitStatus.PAID;
-            if(event.name==="RefundEvent") return SwapCommitStatus.NOT_COMMITED;
+            if(event.name==="ClaimEvent") return SwapCommitStateType.PAID;
+            if(event.name==="RefundEvent") return SwapCommitStateType.NOT_COMMITED;
         }, abortController.signal).catch(e => {
             abortController.abort(e)
             return null;
@@ -305,7 +326,7 @@ export class SolanaSwapProgram
         abortController.signal.throwIfAborted();
         if(escrowState!=null) {
             abortController.abort();
-            return SwapCommitStatus.COMMITED;
+            return SwapCommitStateType.COMMITED;
         }
 
         //Check if paid or what
@@ -313,7 +334,7 @@ export class SolanaSwapProgram
         abortController.signal.throwIfAborted();
         if(eventsStatus!=null) return eventsStatus;
 
-        return SwapCommitStatus.NOT_COMMITED;
+        return SwapCommitStateType.NOT_COMMITED;
     }
 
     /**
@@ -445,10 +466,12 @@ export class SolanaSwapProgram
         return this.Refund.txsRefundWithAuthorization(swapData,timeout,prefix,signature,check,initAta,feeRate);
     }
 
-    txsInit(swapData: SolanaSwapData, {timeout, prefix, signature}, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]> {
+    txsInit(sender: string, swapData: SolanaSwapData, {timeout, prefix, signature}, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]> {
         if(swapData.isPayIn()) {
+            if(!swapData.isOfferer(sender)) throw new Error("Only offerer can create payIn=true swap");
             return this.Init.txsInitPayIn(swapData, timeout, prefix, signature, skipChecks, feeRate);
         } else {
+            if(!swapData.isClaimer(sender)) throw new Error("Only claimer can create payIn=false swap");
             return this.Init.txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate);
         }
     }
@@ -548,7 +571,7 @@ export class SolanaSwapProgram
             if(!signer.getPublicKey().equals(swapData.claimer)) throw new Error("Invalid signer provided!");
         }
 
-        const result = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
+        const result = await this.txsInit(signer.getAddress(), swapData, signature, skipChecks, txOptions?.feeRate);
 
         const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
@@ -565,7 +588,7 @@ export class SolanaSwapProgram
     ): Promise<string[]> {
         if(!signer.getPublicKey().equals(swapData.claimer)) throw new Error("Invalid signer provided!");
 
-        const txsCommit = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
+        const txsCommit = await this.txsInit(signer.getAddress(), swapData, signature, skipChecks, txOptions?.feeRate);
         const txsClaim = await this.Claim.txsClaimWithSecret(signer.getPublicKey(), swapData, secret, true, false, txOptions?.feeRate, true);
 
         return await this.Chain.sendAndConfirm(signer, txsCommit.concat(txsClaim), txOptions?.waitForConfirmation, txOptions?.abortSignal);
@@ -634,28 +657,28 @@ export class SolanaSwapProgram
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getInitFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRawCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getRawInitFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRawRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
 

package/src/solana/swaps/modules/SwapInit.ts

@@ -1,5 +1,9 @@
 import {ParsedAccountsModeBlockResponse, PublicKey, SystemProgram, Transaction} from "@solana/web3.js";
-import {SignatureVerificationError, SwapCommitStatus, SwapDataVerificationError} from "@atomiqlabs/base";
+import {
+    SignatureVerificationError,
+    SwapCommitStateType,
+    SwapDataVerificationError
+} from "@atomiqlabs/base";
 import {SolanaSwapData} from "../SolanaSwapData";
 import {SolanaAction} from "../../chain/SolanaAction";
 import {
@@ -335,6 +339,7 @@ export class SwapInit extends SolanaSwapModule {
     /**
      * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
      *
+     * @param sender
      * @param swapData
      * @param timeout
      * @param prefix
@@ -344,6 +349,7 @@ export class SwapInit extends SolanaSwapModule {
      * @public
      */
     public async isSignatureValid(
+        sender: string,
         swapData: SolanaSwapData,
         timeout: string,
         prefix: string,
@@ -351,7 +357,12 @@ export class SwapInit extends SolanaSwapModule {
         feeRate?: string,
         preFetchedData?: SolanaPreFetchVerification
     ): Promise<Buffer> {
-        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        if(swapData.isPayIn()) {
+            if(!swapData.isOfferer(sender)) throw new SignatureVerificationError("Sender needs to be offerer in payIn=true swaps");
+        } else {
+            if(!swapData.isClaimer(sender)) throw new SignatureVerificationError("Sender needs to be claimer in payIn=false swaps");
+        }
+
         const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
 
         if(!swapData.isPayIn() && await this.program.isExpired(sender.toString(), swapData)) {
@@ -377,7 +388,7 @@ export class SwapInit extends SolanaSwapModule {
         if(slotsLeft<0) throw new SignatureVerificationError("Authorization expired!");
 
         const txToSign = await this.getTxToSign(swapData, timeout, feeRate);
-        txToSign.feePayer = sender;
+        txToSign.feePayer = new PublicKey(sender);
         txToSign.recentBlockhash = blockhash;
         txToSign.addSignature(signer, Buffer.from(signatureString, "hex"));
         this.logger.debug("isSignatureValid(): Signed tx: ",txToSign);
@@ -466,12 +477,12 @@ export class SwapInit extends SolanaSwapModule {
         if(!skipChecks) {
             const [_, payStatus] = await Promise.all([
                 tryWithRetries(
-                    () => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate),
+                    () => this.isSignatureValid(swapData.getOfferer(), swapData, timeout, prefix, signature, feeRate),
                     this.retryPolicy, (e) => e instanceof SignatureVerificationError
                 ),
                 tryWithRetries(() => this.program.getClaimHashStatus(swapData.getClaimHash()), this.retryPolicy)
             ]);
-            if(payStatus!==SwapCommitStatus.NOT_COMMITED) throw new SwapDataVerificationError("Invoice already being paid for or paid");
+            if(payStatus!==SwapCommitStateType.NOT_COMMITED) throw new SwapDataVerificationError("Invoice already being paid for or paid");
         }
 
         const [slotNumber, signatureStr] = signature.split(";");
@@ -522,7 +533,7 @@ export class SwapInit extends SolanaSwapModule {
     public async txsInit(swapData: SolanaSwapData, timeout: string, prefix: string, signature: string, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]> {
         if(!skipChecks) {
             await tryWithRetries(
-                () => this.isSignatureValid(swapData, timeout, prefix, signature, feeRate),
+                () => this.isSignatureValid(swapData.getClaimer(), swapData, timeout, prefix, signature, feeRate),
                 this.retryPolicy,
                 (e) => e instanceof SignatureVerificationError
             );

package/src/solana/swaps/modules/SwapRefund.ts

@@ -249,7 +249,6 @@ export class SwapRefund extends SolanaSwapModule {
         if(shouldInitAta && !initAta) throw new SwapDataVerificationError("ATA not initialized");
 
         if(feeRate==null) feeRate = await this.program.getRefundFeeRate(swapData);
-        console.log("[SolanaSwapProgram] txsRefundsWithAuthorization: feeRate: ", feeRate);
 
         const signatureBuffer = Buffer.from(signature, "hex");
 

package/src/utils/Utils.ts

@@ -28,10 +28,10 @@ export function onceAsync<T>(executor: () => Promise<T>): () => Promise<T> {
 
 export function getLogger(prefix: string) {
     return {
-        debug: (msg, ...args) => console.debug(prefix+msg, ...args),
-        info: (msg, ...args) => console.info(prefix+msg, ...args),
-        warn: (msg, ...args) => console.warn(prefix+msg, ...args),
-        error: (msg, ...args) => console.error(prefix+msg, ...args)
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix+msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix+msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 1) && console.warn(prefix+msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 0) && console.error(prefix+msg, ...args)
     };
 }