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

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

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import { SolanaSwapModule } from "../SolanaSwapModule";
 import { SolanaSwapData } from "../SolanaSwapData";
-import * as BN from "bn.js";
 import { SolanaTx } from "../../base/modules/SolanaTransactions";
 import { Buffer } from "buffer";
 import { SolanaSigner } from "../../wallet/SolanaSigner";
@@ -75,9 +74,9 @@ export declare class SwapRefund extends SolanaSwapModule {
      * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
      *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
      */
-    getRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
 }

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

@@ -1,25 +1,17 @@
 "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.SwapRefund = void 0;
 const SolanaSwapModule_1 = require("../SolanaSwapModule");
 const createHash = require("create-hash");
 const tweetnacl_1 = require("tweetnacl");
 const base_1 = require("@atomiqlabs/base");
-const BN = require("bn.js");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const SolanaAction_1 = require("../../base/SolanaAction");
 const Utils_1 = require("../../../utils/Utils");
 const buffer_1 = require("buffer");
+const SolanaTokens_1 = require("../../base/modules/SolanaTokens");
+const BN = require("bn.js");
 class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
     /**
      * Action for generic Refund instruction
@@ -29,30 +21,37 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      * @constructor
      * @private
      */
-    Refund(swapData, refundAuthTimeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accounts = {
-                offerer: swapData.offerer,
-                claimer: swapData.claimer,
-                escrowState: this.root.SwapEscrowState(buffer_1.Buffer.from(swapData.paymentHash, "hex")),
-                claimerUserData: !swapData.payOut ? this.root.SwapUserVault(swapData.claimer, swapData.token) : null,
-                ixSysvar: refundAuthTimeout != null ? web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY : null
-            };
-            const useTimeout = refundAuthTimeout != null ? refundAuthTimeout : new BN(0);
-            if (swapData.isPayIn()) {
-                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.offerer);
-                return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, yield this.program.methods
-                    .offererRefundPayIn(useTimeout)
-                    .accounts(Object.assign(Object.assign({}, accounts), { offererAta: ata, vault: this.root.SwapVault(swapData.token), vaultAuthority: this.root.SwapVaultAuthority, tokenProgram: spl_token_1.TOKEN_PROGRAM_ID }))
-                    .instruction(), SwapRefund.CUCosts.REFUND_PAY_OUT);
-            }
-            else {
-                return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, yield this.program.methods
-                    .offererRefund(useTimeout)
-                    .accounts(Object.assign(Object.assign({}, accounts), { offererUserData: this.root.SwapUserVault(swapData.offerer, swapData.token) }))
-                    .instruction(), SwapRefund.CUCosts.REFUND);
-            }
-        });
+    async Refund(swapData, refundAuthTimeout) {
+        const accounts = {
+            offerer: swapData.offerer,
+            claimer: swapData.claimer,
+            escrowState: this.root.SwapEscrowState(buffer_1.Buffer.from(swapData.paymentHash, "hex")),
+            claimerUserData: !swapData.payOut ? this.root.SwapUserVault(swapData.claimer, swapData.token) : null,
+            ixSysvar: refundAuthTimeout != null ? web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY : null
+        };
+        const useTimeout = refundAuthTimeout != null ? refundAuthTimeout : 0n;
+        if (swapData.isPayIn()) {
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(swapData.token, swapData.offerer);
+            return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, await this.program.methods
+                .offererRefundPayIn((0, Utils_1.toBN)(useTimeout))
+                .accounts({
+                ...accounts,
+                offererAta: ata,
+                vault: this.root.SwapVault(swapData.token),
+                vaultAuthority: this.root.SwapVaultAuthority,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            })
+                .instruction(), SwapRefund.CUCosts.REFUND_PAY_OUT);
+        }
+        else {
+            return new SolanaAction_1.SolanaAction(swapData.offerer, this.root, await this.program.methods
+                .offererRefund((0, Utils_1.toBN)(useTimeout))
+                .accounts({
+                ...accounts,
+                offererUserData: this.root.SwapUserVault(swapData.offerer, swapData.token)
+            })
+                .instruction(), SwapRefund.CUCosts.REFUND);
+        }
     }
     /**
      * Action for refunding with signature, adds the Ed25519 verify instruction
@@ -64,16 +63,14 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      * @constructor
      * @private
      */
-    RefundWithSignature(swapData, timeout, prefix, signature) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root, web3_js_1.Ed25519Program.createInstructionWithPublicKey({
-                message: this.getRefundMessage(swapData, prefix, timeout),
-                publicKey: swapData.claimer.toBuffer(),
-                signature: signature
-            }), 0, null, null, true);
-            action.addAction(yield this.Refund(swapData, new BN(timeout)));
-            return action;
-        });
+    async RefundWithSignature(swapData, timeout, prefix, signature) {
+        const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root, web3_js_1.Ed25519Program.createInstructionWithPublicKey({
+            message: this.getRefundMessage(swapData, prefix, timeout),
+            publicKey: swapData.claimer.toBuffer(),
+            signature: signature
+        }), 0, null, null, true);
+        action.addAction(await this.Refund(swapData, BigInt(timeout)));
+        return action;
     }
     /**
      * Gets the message to be signed as a refund authorization
@@ -102,7 +99,7 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      */
     shouldUnwrap(swapData) {
         return swapData.isPayIn() &&
-            swapData.token.equals(this.root.Tokens.WSOL_ADDRESS) &&
+            swapData.token.equals(SolanaTokens_1.SolanaTokens.WSOL_ADDRESS) &&
             swapData.offerer.equals(swapData.offerer);
     }
     signSwapRefund(signer, swapData, authorizationTimeout) {
@@ -123,9 +120,9 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
     isSignatureValid(swapData, timeout, prefix, signature) {
         if (prefix !== "refund")
             throw new base_1.SignatureVerificationError("Invalid prefix");
-        const expiryTimestamp = new BN(timeout);
-        const currentTimestamp = new BN(Math.floor(Date.now() / 1000));
-        const isExpired = expiryTimestamp.sub(currentTimestamp).lt(new BN(this.root.authGracePeriod));
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.root.authGracePeriod);
         if (isExpired)
             throw new base_1.SignatureVerificationError("Authorization expired!");
         const signatureBuffer = buffer_1.Buffer.from(signature, "hex");
@@ -143,31 +140,29 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      * @param initAta should initialize ATA if it doesn't exist
      * @param feeRate fee rate to be used for the transactions
      */
-    txsRefund(swapData, check, initAta, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (check && !(yield (0, Utils_1.tryWithRetries)(() => this.root.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy))) {
-                throw new base_1.SwapDataVerificationError("Not refundable yet!");
-            }
-            const shouldInitAta = swapData.isPayIn() && !(yield this.root.Tokens.ataExists(swapData.offererAta));
-            if (shouldInitAta && !initAta)
-                throw new base_1.SwapDataVerificationError("ATA not initialized");
-            if (feeRate == null)
-                feeRate = yield this.root.getRefundFeeRate(swapData);
-            const shouldUnwrap = this.shouldUnwrap(swapData);
-            const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root);
-            if (shouldInitAta) {
-                const initAction = this.root.Tokens.InitAta(swapData.offerer, swapData.offerer, swapData.token, swapData.offererAta);
-                if (initAction == null)
-                    throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
-                action.addAction(initAction);
-            }
-            action.add(yield this.Refund(swapData));
-            if (shouldUnwrap)
-                action.add(this.root.Tokens.Unwrap(swapData.offerer));
-            this.logger.debug("txsRefund(): creating claim transaction, swap: " + swapData.getHash() +
-                " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap);
-            return [yield action.tx(feeRate)];
-        });
+    async txsRefund(swapData, check, initAta, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.root.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        const shouldInitAta = swapData.isPayIn() && !await this.root.Tokens.ataExists(swapData.offererAta);
+        if (shouldInitAta && !initAta)
+            throw new base_1.SwapDataVerificationError("ATA not initialized");
+        if (feeRate == null)
+            feeRate = await this.root.getRefundFeeRate(swapData);
+        const shouldUnwrap = this.shouldUnwrap(swapData);
+        const action = new SolanaAction_1.SolanaAction(swapData.offerer, this.root);
+        if (shouldInitAta) {
+            const initAction = this.root.Tokens.InitAta(swapData.offerer, swapData.offerer, swapData.token, swapData.offererAta);
+            if (initAction == null)
+                throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
+            action.addAction(initAction);
+        }
+        action.add(await this.Refund(swapData));
+        if (shouldUnwrap)
+            action.add(this.root.Tokens.Unwrap(swapData.offerer));
+        this.logger.debug("txsRefund(): creating claim transaction, swap: " + swapData.getClaimHash() +
+            " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap);
+        return [await action.tx(feeRate)];
     }
     /**
      * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
@@ -180,34 +175,32 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      * @param initAta should initialize ATA if it doesn't exist
      * @param feeRate fee rate to be used for the transactions
      */
-    txsRefundWithAuthorization(swapData, timeout, prefix, signature, check, initAta, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (check && !(yield (0, Utils_1.tryWithRetries)(() => this.root.isCommited(swapData), this.retryPolicy))) {
-                throw new base_1.SwapDataVerificationError("Not correctly committed");
-            }
-            yield (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-            const shouldInitAta = swapData.isPayIn() && !(yield this.root.Tokens.ataExists(swapData.offererAta));
-            if (shouldInitAta && !initAta)
-                throw new base_1.SwapDataVerificationError("ATA not initialized");
-            if (feeRate == null)
-                feeRate = yield this.root.getRefundFeeRate(swapData);
-            console.log("[SolanaSwapProgram] txsRefundsWithAuthorization: feeRate: ", feeRate);
-            const signatureBuffer = buffer_1.Buffer.from(signature, "hex");
-            const shouldUnwrap = this.shouldUnwrap(swapData);
-            const action = yield this.RefundWithSignature(swapData, timeout, prefix, signatureBuffer);
-            if (shouldInitAta) {
-                const initAction = this.root.Tokens.InitAta(swapData.offerer, swapData.offerer, swapData.token, swapData.offererAta);
-                if (initAction == null)
-                    throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
-                action.addAction(initAction, 1); //Need to add it after the Ed25519 verify IX, but before the actual refund IX
-            }
-            if (shouldUnwrap)
-                action.add(this.root.Tokens.Unwrap(swapData.offerer));
-            this.logger.debug("txsRefundWithAuthorization(): creating claim transaction, swap: " + swapData.getHash() +
-                " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap +
-                " auth expiry: " + timeout + " signature: " + signature);
-            return [yield action.tx(feeRate)];
-        });
+    async txsRefundWithAuthorization(swapData, timeout, prefix, signature, check, initAta, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.root.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        const shouldInitAta = swapData.isPayIn() && !await this.root.Tokens.ataExists(swapData.offererAta);
+        if (shouldInitAta && !initAta)
+            throw new base_1.SwapDataVerificationError("ATA not initialized");
+        if (feeRate == null)
+            feeRate = await this.root.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);
+        if (shouldInitAta) {
+            const initAction = this.root.Tokens.InitAta(swapData.offerer, swapData.offerer, swapData.token, swapData.offererAta);
+            if (initAction == null)
+                throw new base_1.SwapDataVerificationError("Invalid claimer token account address");
+            action.addAction(initAction, 1); //Need to add it after the Ed25519 verify IX, but before the actual refund IX
+        }
+        if (shouldUnwrap)
+            action.add(this.root.Tokens.Unwrap(swapData.offerer));
+        this.logger.debug("txsRefundWithAuthorization(): creating claim transaction, swap: " + swapData.getClaimHash() +
+            " initializingAta: " + shouldInitAta + " unwrapping: " + shouldUnwrap +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [await action.tx(feeRate)];
     }
     getRefundFeeRate(swapData) {
         const accounts = [];
@@ -238,22 +231,19 @@ class SwapRefund extends SolanaSwapModule_1.SolanaSwapModule {
      * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
      *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
      */
-    getRefundFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new BN(swapData == null || swapData.payIn ? this.root.Tokens.SPL_ATA_RENT_EXEMPT : 0).add(yield this.getRawRefundFee(swapData, feeRate));
-        });
+    async getRefundFee(swapData, feeRate) {
+        return BigInt(swapData == null || swapData.payIn ? SolanaTokens_1.SolanaTokens.SPL_ATA_RENT_EXEMPT : 0) +
+            await this.getRawRefundFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData, feeRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (swapData == null)
-                return new BN(10000);
-            feeRate = feeRate || (yield this.getRefundFeeRate(swapData));
-            const computeBudget = swapData.payIn ? SwapRefund.CUCosts.REFUND_PAY_OUT : SwapRefund.CUCosts.REFUND;
-            return new BN(10000).add(this.root.Fees.getPriorityFee(computeBudget, feeRate));
-        });
+    async getRawRefundFee(swapData, feeRate) {
+        if (swapData == null)
+            return 10000n;
+        feeRate = feeRate || await this.getRefundFeeRate(swapData);
+        const computeBudget = swapData.payIn ? SwapRefund.CUCosts.REFUND_PAY_OUT : SwapRefund.CUCosts.REFUND;
+        return 10000n + this.root.Fees.getPriorityFee(computeBudget, feeRate);
     }
 }
 exports.SwapRefund = SwapRefund;

package/dist/utils/Utils.d.ts

@@ -1,4 +1,5 @@
 import { PublicKey, Transaction } from "@solana/web3.js";
+import * as BN from "bn.js";
 export declare function timeoutPromise(timeoutMillis: number, abortSignal?: AbortSignal): Promise<void>;
 export declare function onceAsync<T>(executor: () => Promise<T>): () => Promise<T>;
 export declare function getLogger(prefix: string): {
@@ -41,3 +42,12 @@ export declare class SolanaTxUtils {
      */
     static getTxSize(tx: Transaction, feePayer: PublicKey): number;
 }
+export declare function toClaimHash(paymentHash: string, nonce: bigint, confirmations: number): string;
+export declare function fromClaimHash(claimHash: string): {
+    paymentHash: string;
+    nonce: BN;
+    confirmations: number;
+};
+export declare function toEscrowHash(paymentHash: string, sequence: BN): string;
+export declare function toBN(value: bigint): BN;
+export declare function toBigInt(value: BN): bigint;

package/dist/utils/Utils.js

@@ -1,16 +1,10 @@
 "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.SolanaTxUtils = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
+exports.toBigInt = exports.toBN = exports.toEscrowHash = exports.fromClaimHash = exports.toClaimHash = exports.SolanaTxUtils = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
 const web3_js_1 = require("@solana/web3.js");
+const BN = require("bn.js");
+const buffer_1 = require("buffer");
+const createHash = require("create-hash");
 function timeoutPromise(timeoutMillis, abortSignal) {
     return new Promise((resolve, reject) => {
         const timeout = setTimeout(resolve, timeoutMillis);
@@ -45,32 +39,30 @@ function getLogger(prefix) {
 }
 exports.getLogger = getLogger;
 const logger = getLogger("Utils: ");
-function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        retryPolicy = retryPolicy || {};
-        retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
-        retryPolicy.delay = retryPolicy.delay || 500;
-        retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
-        let err = null;
-        for (let i = 0; i < retryPolicy.maxRetries; i++) {
-            try {
-                const resp = yield func();
-                return resp;
-            }
-            catch (e) {
-                if (errorAllowed != null && errorAllowed(e))
-                    throw e;
-                err = e;
-                logger.error("tryWithRetries(): error on try number: " + i, e);
-            }
-            if (abortSignal != null && abortSignal.aborted)
-                throw new Error("Aborted");
-            if (i !== retryPolicy.maxRetries - 1) {
-                yield timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
-            }
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            const resp = await func();
+            return resp;
         }
-        throw err;
-    });
+        catch (e) {
+            if (errorAllowed != null && errorAllowed(e))
+                throw e;
+            err = e;
+            logger.error("tryWithRetries(): error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw new Error("Aborted");
+        if (i !== retryPolicy.maxRetries - 1) {
+            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
 }
 exports.tryWithRetries = tryWithRetries;
 class SolanaTxUtils {
@@ -141,3 +133,38 @@ exports.SolanaTxUtils = SolanaTxUtils;
 // COMPACT ARRAY
 SolanaTxUtils.LOW_VALUE = 127; // 0x7f
 SolanaTxUtils.HIGH_VALUE = 16383; // 0x3fff
+function toClaimHash(paymentHash, nonce, confirmations) {
+    return paymentHash +
+        nonce.toString(16).padStart(16, "0") +
+        confirmations.toString(16).padStart(4, "0");
+}
+exports.toClaimHash = toClaimHash;
+function fromClaimHash(claimHash) {
+    if (claimHash.length !== 84)
+        throw new Error("Claim hash invalid length: " + claimHash.length);
+    return {
+        paymentHash: claimHash.slice(0, 64),
+        nonce: new BN(claimHash.slice(64, 80), "hex"),
+        confirmations: parseInt(claimHash.slice(80, 84), 16)
+    };
+}
+exports.fromClaimHash = fromClaimHash;
+function toEscrowHash(paymentHash, sequence) {
+    return createHash("sha256").update(buffer_1.Buffer.concat([
+        buffer_1.Buffer.from(paymentHash, "hex"),
+        sequence.toArrayLike(buffer_1.Buffer, "be", 8)
+    ])).digest().toString("hex");
+}
+exports.toEscrowHash = toEscrowHash;
+function toBN(value) {
+    if (value == null)
+        return null;
+    return new BN(value.toString(10));
+}
+exports.toBN = toBN;
+function toBigInt(value) {
+    if (value == null)
+        return null;
+    return BigInt(value.toString(10));
+}
+exports.toBigInt = toBigInt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-solana",
-  "version": "7.3.8",
+  "version": "8.0.0-beta.0",
   "description": "Solana specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,18 +22,21 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "7.2.2",
-    "@coral-xyz/anchor": "0.29.0",
-    "@solana/spl-token": "0.3.9",
-    "@solana/web3.js": "1.95.2",
+    "@atomiqlabs/base": "8.0.0-beta.0",
     "bn.js": "5.2.1",
+    "bs58": "4.0.1",
     "buffer": "6.0.3",
     "create-hash": "1.2.0",
     "randombytes": "2.1.0",
     "tweetnacl": "1.0.3"
   },
+  "peerDependencies": {
+    "@coral-xyz/anchor": "^0.29.0",
+    "@solana/spl-token": "^0.3.9",
+    "@solana/web3.js": "^1.95.2"
+  },
   "devDependencies": {
-    "@types/bn.js": "5.1.5",
+    "@types/bn.js": "5.1.6",
     "@types/node": "18.15.11",
     "typescript": "4.9.5"
   }

package/src/index.ts

@@ -31,5 +31,6 @@ export * from "./solana/wallet/SolanaKeypairWallet";
 export * from "./solana/wallet/SolanaSigner";
 
 export * from "./solana/SolanaChainType";
+export * from "./solana/SolanaInitializer";
 
 export * from "./utils/Utils";

package/src/solana/SolanaChains.ts

@@ -0,0 +1,16 @@
+import {BitcoinNetwork} from "@atomiqlabs/base";
+
+export const SolanaChains = {
+    [BitcoinNetwork.TESTNET]: {
+        addresses: {
+            swapContract: "4hfUykhqmD7ZRvNh1HuzVKEY7ToENixtdUKZspNDCrEM",
+            btcRelayContract: "3KHSHFpEK6bsjg3bqcxQ9qssJYtRCMi2S9TYVe4q6CQc"
+        }
+    },
+    [BitcoinNetwork.MAINNET]: {
+        addresses: {
+            swapContract: "4hfUykhqmD7ZRvNh1HuzVKEY7ToENixtdUKZspNDCrEM",
+            btcRelayContract: "3KHSHFpEK6bsjg3bqcxQ9qssJYtRCMi2S9TYVe4q6CQc"
+        }
+    }
+} as const;

package/src/solana/SolanaInitializer.ts

@@ -0,0 +1,98 @@
+import {
+    BaseTokenType,
+    BitcoinNetwork,
+    BitcoinRpc,
+    ChainData,
+    ChainInitializer,
+    IStorageManager,
+    StorageObject
+} from "@atomiqlabs/base";
+import {Connection} from "@solana/web3.js";
+import {StoredDataAccount} from "./swaps/modules/SolanaDataAccount";
+import {SolanaRetryPolicy} from "./base/SolanaBase";
+import {SolanaFees} from "./base/modules/SolanaFees";
+import {SolanaChainType} from "./SolanaChainType";
+import {SolanaBtcRelay} from "./btcrelay/SolanaBtcRelay";
+import {SolanaChains} from "./SolanaChains";
+import {SolanaSwapProgram} from "./swaps/SolanaSwapProgram";
+import {SolanaChainEventsBrowser} from "./events/SolanaChainEventsBrowser";
+import {SolanaSwapData} from "./swaps/SolanaSwapData";
+
+const chainId = "SOLANA" as const;
+
+export type SolanaAssetsType = BaseTokenType<"WBTC" | "USDC" | "USDT" | "SOL" | "BONK">;
+const SolanaAssets: SolanaAssetsType = {
+    WBTC: {
+        address: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh",
+        decimals: 8
+    },
+    USDC: {
+        address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        decimals: 6
+    },
+    USDT: {
+        address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+        decimals: 6
+    },
+    SOL: {
+        address: "So11111111111111111111111111111111111111112",
+        decimals: 9
+    },
+    BONK: {
+        address: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
+        decimals: 5
+    }
+} as const;
+
+export type SolanaSwapperOptions = {
+    rpcUrl: string | Connection,
+    dataAccountStorage?: IStorageManager<StoredDataAccount>,
+    retryPolicy?: SolanaRetryPolicy,
+
+    btcRelayContract?: string,
+    swapContract?: string,
+
+    fees?: SolanaFees
+};
+
+export function initializeSolana(
+    options: SolanaSwapperOptions,
+    bitcoinRpc: BitcoinRpc<any>,
+    network: BitcoinNetwork,
+    storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>
+): ChainData<SolanaChainType> {
+    const connection = typeof(options.rpcUrl)==="string" ?
+        new Connection(options.rpcUrl) :
+        options.rpcUrl;
+
+    const Fees = options.fees ?? new SolanaFees(connection, 200000, 4, 100);
+    const btcRelay = new SolanaBtcRelay(connection, bitcoinRpc, options.btcRelayContract ?? SolanaChains[network].addresses.btcRelayContract, Fees);
+    const swapContract = new SolanaSwapProgram(
+        connection,
+        btcRelay,
+        options.dataAccountStorage || storageCtor("solAccounts"),
+        options.swapContract ?? SolanaChains[network].addresses.swapContract,
+        options.retryPolicy ?? {transactionResendInterval: 1000},
+        Fees
+    );
+    const chainEvents = new SolanaChainEventsBrowser(connection, swapContract);
+
+    return {
+        chainId,
+        btcRelay,
+        swapContract,
+        chainEvents,
+        swapDataConstructor: SolanaSwapData,
+        //These are defined here to keep the data from old SolLightning-sdk, not needed for other chains
+        storagePrefix: "SOLv4-"+network+"-"
+    };
+}
+
+export type SolanaInitializerType = ChainInitializer<SolanaSwapperOptions, SolanaChainType, SolanaAssetsType>;
+export const SolanaInitializer: SolanaInitializerType = {
+    chainId,
+    chainType: null as SolanaChainType,
+    initializer: initializeSolana,
+    tokens: SolanaAssets,
+    options: null as SolanaSwapperOptions
+} as const;

package/src/solana/base/SolanaBase.ts

@@ -1,5 +1,4 @@
-import {Connection, Signer} from "@solana/web3.js";
-import {AnchorProvider} from "@coral-xyz/anchor";
+import {Connection} from "@solana/web3.js";
 import {SolanaFees} from "./modules/SolanaFees";
 import {SolanaBlocks} from "./modules/SolanaBlocks";
 import {SolanaSlots} from "./modules/SolanaSlots";

package/src/solana/base/modules/SolanaEvents.ts

@@ -1,6 +1,5 @@
 import {SolanaModule} from "../SolanaModule";
 import {ConfirmedSignatureInfo, PublicKey} from "@solana/web3.js";
-import {log} from "node:util";
 
 export class SolanaEvents extends SolanaModule {