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

package/dist/solana/swaps/SolanaSwapData.js

@@ -7,6 +7,8 @@ const base_1 = require("@atomiqlabs/base");
 const SwapTypeEnum_1 = require("./SwapTypeEnum");
 const buffer_1 = require("buffer");
 const spl_token_1 = require("@solana/spl-token");
+const Utils_1 = require("../../utils/Utils");
+const SolanaTokens_1 = require("../base/modules/SolanaTokens");
 const EXPIRY_BLOCKHEIGHT_THRESHOLD = new BN("1000000000");
 class SolanaSwapData extends base_1.SwapData {
     constructor(offererOrData, claimer, token, amount, paymentHash, sequence, expiry, nonce, confirmations, payOut, kind, payIn, offererAta, claimerAta, securityDeposit, claimerBounty, txoHash) {
@@ -91,7 +93,7 @@ class SolanaSwapData extends base_1.SwapData {
         };
     }
     getAmount() {
-        return this.amount;
+        return (0, Utils_1.toBigInt)(this.amount);
     }
     getToken() {
         return this.token.toString();
@@ -105,13 +107,13 @@ class SolanaSwapData extends base_1.SwapData {
     getExpiry() {
         if (this.expiry.lt(EXPIRY_BLOCKHEIGHT_THRESHOLD))
             return null;
-        return this.expiry;
+        return (0, Utils_1.toBigInt)(this.expiry);
     }
-    getConfirmations() {
+    getConfirmationsHint() {
         return this.confirmations;
     }
-    getEscrowNonce() {
-        return this.nonce;
+    getNonceHint() {
+        return (0, Utils_1.toBigInt)(this.nonce);
     }
     isPayIn() {
         return this.payIn;
@@ -119,26 +121,34 @@ class SolanaSwapData extends base_1.SwapData {
     isPayOut() {
         return this.payOut;
     }
-    getHash() {
-        return this.paymentHash;
+    getClaimHash() {
+        return (0, Utils_1.toClaimHash)(this.paymentHash, (0, Utils_1.toBigInt)(this.nonce), this.confirmations);
+    }
+    getEscrowHash() {
+        return (0, Utils_1.toEscrowHash)(this.paymentHash, this.sequence);
     }
     getSequence() {
-        return this.sequence;
+        return (0, Utils_1.toBigInt)(this.sequence);
+    }
+    getTxoHashHint() {
+        if (this.txoHash === "0000000000000000000000000000000000000000000000000000000000000000")
+            return null; //Txo hash opt-out flag
+        return this.txoHash;
     }
-    getTxoHash() {
+    getExtraData() {
         return this.txoHash;
     }
-    setTxoHash(txoHash) {
+    setExtraData(txoHash) {
         this.txoHash = txoHash;
     }
     getSecurityDeposit() {
-        return this.securityDeposit;
+        return (0, Utils_1.toBigInt)(this.securityDeposit);
     }
     getClaimerBounty() {
-        return this.claimerBounty;
+        return (0, Utils_1.toBigInt)(this.claimerBounty);
     }
     getTotalDeposit() {
-        return this.claimerBounty.lt(this.securityDeposit) ? this.securityDeposit : this.claimerBounty;
+        return (0, Utils_1.toBigInt)(this.claimerBounty.lt(this.securityDeposit) ? this.securityDeposit : this.claimerBounty);
     }
     toSwapDataStruct() {
         return {
@@ -246,6 +256,12 @@ class SolanaSwapData extends base_1.SwapData {
     isOfferer(address) {
         return this.offerer.equals(new web3_js_1.PublicKey(address));
     }
+    getDepositToken() {
+        return SolanaTokens_1.SolanaTokens.WSOL_ADDRESS.toString();
+    }
+    isDepositToken(token) {
+        return SolanaTokens_1.SolanaTokens.WSOL_ADDRESS.equals(new web3_js_1.PublicKey(token));
+    }
 }
 exports.SolanaSwapData = SolanaSwapData;
 base_1.SwapData.deserializers["sol"] = SolanaSwapData;

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

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import { SolanaSwapData } from "./SolanaSwapData";
-import * as BN from "bn.js";
 import { Connection, PublicKey, SendOptions } from "@solana/web3.js";
 import { SolanaBtcRelay } from "../btcrelay/SolanaBtcRelay";
 import { IStorageManager, SwapContract, ChainSwapType, IntermediaryReputationType, SwapCommitStatus, TransactionConfirmationOptions, SignatureData, RelaySynchronizer } from "@atomiqlabs/base";
@@ -39,12 +38,12 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     start(): Promise<void>;
     getClaimableDeposits(signer: string): Promise<{
         count: number;
-        totalValue: BN;
+        totalValue: bigint;
     }>;
     claimDeposits(signer: SolanaSigner): Promise<{
         txIds: string[];
         count: number;
-        totalValue: BN;
+        totalValue: bigint;
     }>;
     preFetchForInitSignatureVerification(data: SolanaPreFetchData): Promise<SolanaPreFetchVerification>;
     preFetchBlockDataForSignatures(): Promise<SolanaPreFetchData>;
@@ -92,7 +91,7 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      * @param signer
      * @param data
      */
-    isExpired(signer: string, data: SolanaSwapData): boolean;
+    isExpired(signer: string, data: SolanaSwapData): Promise<boolean>;
     /**
      * Checks if the swap is refundable by us, checks if we are offerer, if the swap is already expired & if the swap
      *  is still commited
@@ -106,9 +105,12 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      *
      * @param outputScript output script required to claim the swap
      * @param amount sats sent required to claim the swap
+     * @param confirmations
      * @param nonce swap nonce uniquely identifying the transaction to prevent replay attacks
      */
-    getHashForOnchain(outputScript: Buffer, amount: BN, nonce: BN): Buffer;
+    getHashForOnchain(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
+    getHashForHtlc(swapHash: Buffer): Buffer;
+    getHashForTxId(txId: string, confirmations: number): Buffer;
     /**
      * Gets the status of the specific swap, this also checks if we are offerer/claimer & checks for expiry (to see
      *  if swap is refundable)
@@ -120,96 +122,92 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     /**
      * Checks the status of the specific payment hash
      *
-     * @param paymentHash
+     * @param claimHash
      */
-    getPaymentHashStatus(paymentHash: string): Promise<SwapCommitStatus>;
+    getClaimHashStatus(claimHash: string): Promise<SwapCommitStatus>;
     /**
      * Returns the data committed for a specific payment hash, or null if no data is currently commited for
      *  the specific swap
      *
-     * @param paymentHashHex
+     * @param claimHashHex
      */
-    getCommitedData(paymentHashHex: string): Promise<SolanaSwapData>;
-    createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: BN, paymentHash: string, sequence: BN, expiry: BN, escrowNonce: BN, confirmations: number, payIn: boolean, payOut: boolean, securityDeposit: BN, claimerBounty: BN): Promise<SolanaSwapData>;
-    getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<BN>;
+    getCommitedData(claimHashHex: string): Promise<SolanaSwapData>;
+    createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: bigint, claimHash: string, sequence: bigint, expiry: bigint, payIn: boolean, payOut: boolean, securityDeposit: bigint, claimerBounty: bigint, depositToken?: string): Promise<SolanaSwapData>;
+    getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<bigint>;
     getIntermediaryData(address: string, token: string): Promise<{
-        balance: BN;
+        balance: bigint;
         reputation: IntermediaryReputationType;
     }>;
     getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
-    getIntermediaryBalance(address: PublicKey, token: PublicKey): Promise<BN>;
+    getIntermediaryBalance(address: PublicKey, token: PublicKey): Promise<bigint>;
     isValidAddress(address: string): boolean;
     getNativeCurrencyAddress(): string;
     txsClaimWithSecret(signer: string | SolanaSigner, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<SolanaTx[]>;
-    txsClaimWithTxData(signer: string | SolanaSigner, swapData: SolanaSwapData, blockheight: number, tx: {
+    txsClaimWithTxData(signer: string | SolanaSigner, swapData: SolanaSwapData, tx: {
         blockhash: string;
         confirmations: number;
         txid: string;
         hex: string;
-    }, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, feeRate?: string, storageAccHolder?: {
+        height: number;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, feeRate?: string, storageAccHolder?: {
         storageAcc: PublicKey;
     }): Promise<SolanaTx[] | null>;
-    txsRefund(swapData: SolanaSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<SolanaTx[]>;
-    txsRefundWithAuthorization(swapData: SolanaSwapData, { timeout, prefix, signature }: {
+    txsRefund(signer: string, swapData: SolanaSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<SolanaTx[]>;
+    txsRefundWithAuthorization(signer: string, swapData: SolanaSwapData, { timeout, prefix, signature }: {
         timeout: any;
         prefix: any;
         signature: any;
     }, check?: boolean, initAta?: boolean, feeRate?: string): Promise<SolanaTx[]>;
-    txsInitPayIn(swapData: SolanaSwapData, { timeout, prefix, signature }: {
-        timeout: any;
-        prefix: any;
-        signature: any;
-    }, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]>;
     txsInit(swapData: SolanaSwapData, { timeout, prefix, signature }: {
         timeout: any;
         prefix: any;
         signature: any;
-    }, txoHash?: Buffer, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]>;
-    txsWithdraw(signer: string, token: string, amount: BN, feeRate?: string): Promise<SolanaTx[]>;
-    txsDeposit(signer: string, token: string, amount: BN, feeRate?: string): Promise<SolanaTx[]>;
-    txsTransfer(signer: string, token: string, amount: BN, dstAddress: string, feeRate?: string): Promise<SolanaTx[]>;
+    }, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]>;
+    txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<SolanaTx[]>;
+    txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<SolanaTx[]>;
+    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]>;
     claimWithSecret(signer: SolanaSigner, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    claimWithTxData(signer: SolanaSigner, swapData: SolanaSwapData, blockheight: number, tx: {
+    claimWithTxData(signer: SolanaSigner, swapData: SolanaSwapData, tx: {
         blockhash: string;
         confirmations: number;
         txid: string;
         hex: string;
-    }, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+        height: number;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: SolanaBtcStoredHeader, synchronizer?: RelaySynchronizer<any, SolanaTx, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     refund(signer: SolanaSigner, swapData: SolanaSwapData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     refundWithAuthorization(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, check?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    initPayIn(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    init(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, txoHash?: Buffer, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    init(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     initAndClaimWithSecret(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, secret: string, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string[]>;
-    withdraw(signer: SolanaSigner, token: string, amount: BN, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    deposit(signer: SolanaSigner, token: string, amount: BN, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    transfer(signer: SolanaSigner, token: string, amount: BN, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    withdraw(signer: SolanaSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    deposit(signer: SolanaSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    transfer(signer: SolanaSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
     sendAndConfirm(signer: SolanaSigner, txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
     serializeTx(tx: SolanaTx): Promise<string>;
     deserializeTx(txData: string): Promise<SolanaTx>;
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-    getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
-    getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
+    getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, claimHash?: string): Promise<string>;
+    getInitFeeRate(offerer?: string, claimer?: string, token?: string, claimHash?: string): Promise<string>;
     getRefundFeeRate(swapData: SolanaSwapData): Promise<string>;
     getClaimFeeRate(signer: string, swapData: SolanaSwapData): Promise<string>;
-    getClaimFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
-    getRawClaimFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getClaimFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
+    getRawClaimFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<BN>;
+    getRawCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    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>;
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
     onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void;
@@ -219,4 +217,5 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     isValidToken(tokenIdentifier: string): boolean;
     randomAddress(): string;
     randomSigner(): SolanaSigner;
+    getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
 }