@atomiqlabs/chain-solana 8.0.2 → 9.0.0-beta.0

package/src/solana/{base → chain}/SolanaAction.ts

@@ -1,13 +1,13 @@
 import {PublicKey, Signer, Transaction, TransactionInstruction} from "@solana/web3.js";
 import {SolanaTx} from "./modules/SolanaTransactions";
-import {SolanaBase} from "./SolanaBase";
+import {SolanaChainInterface} from "./SolanaChainInterface";
 
 
 export class SolanaAction {
 
     computeBudget: number;
     readonly mainSigner: PublicKey;
-    private readonly root: SolanaBase;
+    private readonly root: SolanaChainInterface;
     private readonly instructions: TransactionInstruction[];
     private feeRate: string;
     private readonly signers: Signer[];
@@ -15,7 +15,7 @@ export class SolanaAction {
 
     constructor(
         mainSigner: PublicKey,
-        root: SolanaBase,
+        root: SolanaChainInterface,
         instructions: TransactionInstruction[] | TransactionInstruction = [],
         computeBudget: number = 0,
         feeRate?: string,

package/src/solana/chain/SolanaChainInterface.ts

@@ -0,0 +1,175 @@
+import {Connection, Keypair, PublicKey, SendOptions} from "@solana/web3.js";
+import {SolanaFees} from "./modules/SolanaFees";
+import {SolanaBlocks} from "./modules/SolanaBlocks";
+import {SolanaSlots} from "./modules/SolanaSlots";
+import {SolanaTokens} from "./modules/SolanaTokens";
+import {SolanaTransactions, SolanaTx} from "./modules/SolanaTransactions";
+import {SolanaSignatures} from "./modules/SolanaSignatures";
+import {SolanaEvents} from "./modules/SolanaEvents";
+import {getLogger} from "../../utils/Utils";
+import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
+import {SolanaAddresses} from "./modules/SolanaAddresses";
+import {SolanaSigner} from "../wallet/SolanaSigner";
+import {Buffer} from "buffer";
+import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
+
+export type SolanaRetryPolicy = {
+    maxRetries?: number,
+    delay?: number,
+    exponential?: boolean,
+    transactionResendInterval?: number
+}
+
+export class SolanaChainInterface implements ChainInterface<
+    SolanaTx,
+    SolanaSigner,
+    "SOLANA"
+> {
+    readonly chainId = "SOLANA";
+
+    public readonly SLOT_TIME = 400;
+    public readonly TX_SLOT_VALIDITY = 151;
+
+    readonly connection: Connection;
+    readonly retryPolicy: SolanaRetryPolicy;
+
+    public readonly Blocks: SolanaBlocks;
+    public Fees: SolanaFees;
+    public readonly Slots: SolanaSlots;
+    public readonly Tokens: SolanaTokens;
+    public readonly Transactions: SolanaTransactions;
+    public readonly Signatures: SolanaSignatures;
+    public readonly Events: SolanaEvents;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        connection: Connection,
+        retryPolicy?: SolanaRetryPolicy,
+        solanaFeeEstimator: SolanaFees = new SolanaFees(connection)
+    ) {
+        this.connection = connection;
+        this.retryPolicy = retryPolicy;
+
+        this.Blocks = new SolanaBlocks(this);
+        this.Fees = solanaFeeEstimator;
+        this.Slots = new SolanaSlots(this);
+        this.Tokens = new SolanaTokens(this);
+        this.Transactions = new SolanaTransactions(this);
+        this.Signatures = new SolanaSignatures(this);
+        this.Events = new SolanaEvents(this);
+    }
+
+    async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
+        const token = new PublicKey(tokenAddress);
+        const publicKey = new PublicKey(signer);
+
+        let { balance } = await this.Tokens.getTokenBalance(publicKey, token);
+        if(token.equals(SolanaTokens.WSOL_ADDRESS)) {
+            const accountRentExemptCost = 1000000n;
+            balance = balance - accountRentExemptCost;
+            if(balance < 0n) balance = 0n;
+        }
+        this.logger.debug("getBalance(): token balance, token: "+token.toBase58()+" balance: "+balance.toString(10));
+        return balance;
+    }
+
+    isValidAddress(address: string): boolean {
+        return SolanaAddresses.isValidAddress(address);
+    }
+
+    getNativeCurrencyAddress(): string {
+        return this.Tokens.getNativeCurrencyAddress().toString();
+    }
+
+    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]> {
+        return this.Tokens.txsTransfer(new PublicKey(signer), new PublicKey(token), amount, new PublicKey(dstAddress), feeRate);
+    }
+
+    async transfer(
+        signer: SolanaSigner,
+        token: string,
+        amount: bigint,
+        dstAddress: string,
+        txOptions?: TransactionConfirmationOptions
+    ): Promise<string> {
+        const txs = await this.Tokens.txsTransfer(signer.getPublicKey(), new PublicKey(token), amount, new PublicKey(dstAddress), txOptions?.feeRate);
+        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        return txId;
+    }
+
+
+    ////////////////////////////////////////////
+    //// Transactions
+    sendAndConfirm(
+        signer: SolanaSigner,
+        txs: SolanaTx[],
+        waitForConfirmation?: boolean,
+        abortSignal?: AbortSignal,
+        parallel?: boolean,
+        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
+    ): Promise<string[]> {
+        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
+    }
+
+    serializeTx(tx: SolanaTx): Promise<string> {
+        return this.Transactions.serializeTx(tx);
+    }
+
+    deserializeTx(txData: string): Promise<SolanaTx> {
+        return this.Transactions.deserializeTx(txData);
+    }
+
+    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxIdStatus(txId);
+    }
+
+    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxStatus(tx);
+    }
+
+
+    ///////////////////////////////////
+    //// Callbacks & handlers
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
+        return true;
+    }
+
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
+
+    onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void {
+        this.Transactions.onBeforeTxSigned(callback);
+    }
+
+    offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean {
+        return this.Transactions.offBeforeTxSigned(callback);
+    }
+
+    onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void {
+        this.Transactions.onSendTransaction(callback);
+    }
+
+    offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean {
+        return this.Transactions.offSendTransaction(callback);
+    }
+
+    isValidToken(tokenIdentifier: string): boolean {
+        try {
+            new PublicKey(tokenIdentifier);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    randomAddress(): string {
+        return Keypair.generate().publicKey.toString();
+    }
+
+    randomSigner(): SolanaSigner {
+        const keypair = Keypair.generate();
+        const wallet = new SolanaKeypairWallet(keypair);
+        return new SolanaSigner(wallet, keypair);
+    }
+
+}

package/src/solana/{base → chain}/SolanaModule.ts

@@ -1,17 +1,17 @@
 import {Connection} from "@solana/web3.js";
-import {SolanaBase, SolanaRetryPolicy} from "./SolanaBase";
+import {SolanaChainInterface, SolanaRetryPolicy} from "./SolanaChainInterface";
 import {getLogger} from "../../utils/Utils";
 
 export class SolanaModule {
 
     protected readonly connection: Connection;
     protected readonly retryPolicy: SolanaRetryPolicy;
-    protected readonly root: SolanaBase;
+    protected readonly root: SolanaChainInterface;
 
     protected readonly logger = getLogger(this.constructor.name+": ");
 
     constructor(
-        root: SolanaBase
+        root: SolanaChainInterface
     ) {
         this.connection = root.connection;
         this.retryPolicy = root.retryPolicy;

package/src/solana/{base → chain}/modules/SolanaAddresses.ts

@@ -1,8 +1,7 @@
-import {SolanaModule} from "../SolanaModule";
 import {PublicKey} from "@solana/web3.js";
 
 
-export class SolanaAddresses extends SolanaModule {
+export class SolanaAddresses {
 
     ///////////////////
     //// Address utils
@@ -11,7 +10,7 @@ export class SolanaAddresses extends SolanaModule {
      *
      * @param address
      */
-    isValidAddress(address: string): boolean {
+    static isValidAddress(address: string): boolean {
         try {
             return PublicKey.isOnCurve(address);
         } catch (e) {

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -180,7 +180,6 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
                     break;
             }
             (parsedEvent as any).meta = {
-                blockTime: eventObject.blockTime,
                 timestamp: eventObject.blockTime,
                 txId: eventObject.signature
             };

package/src/solana/program/SolanaProgramBase.ts

@@ -1,36 +1,39 @@
 import {AnchorProvider, Idl, Program} from "@coral-xyz/anchor";
-import {SolanaFees} from "../base/modules/SolanaFees";
-import {SolanaBase, SolanaRetryPolicy} from "../base/SolanaBase";
+import {SolanaFees} from "../chain/modules/SolanaFees";
+import {SolanaChainInterface, SolanaRetryPolicy} from "../chain/SolanaChainInterface";
 import {SolanaProgramEvents} from "./modules/SolanaProgramEvents";
 import {Connection, Keypair, PublicKey} from "@solana/web3.js";
 import {sha256} from "@noble/hashes/sha2";
 import {Buffer} from "buffer";
 import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
+import {getLogger} from "../../utils/Utils";
 
 /**
  * Base class providing program specific utilities
  */
-export class SolanaProgramBase<T extends Idl> extends SolanaBase {
+export class SolanaProgramBase<T extends Idl> {
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
 
     program: Program<T>;
 
     public readonly Events: SolanaProgramEvents<T>;
+    public readonly Chain: SolanaChainInterface;
 
     constructor(
-        connection: Connection,
+        chainInterface: SolanaChainInterface,
         programIdl: any,
-        programAddress?: string,
-        retryPolicy?: SolanaRetryPolicy,
-        solanaFeeEstimator: SolanaFees = new SolanaFees(connection)
+        programAddress?: string
     ) {
-        super(connection, retryPolicy, solanaFeeEstimator);
+        this.Chain = chainInterface;
+
         this.program = new Program<T>(
             programIdl as any,
             programAddress || programIdl.metadata.address,
-            new AnchorProvider(connection, new SolanaKeypairWallet(Keypair.generate()), {})
+            new AnchorProvider(chainInterface.connection, new SolanaKeypairWallet(Keypair.generate()), {})
         );
 
-        this.Events = new SolanaProgramEvents(this);
+        this.Events = new SolanaProgramEvents(chainInterface, this);
     }
 
     /**

package/src/solana/program/SolanaProgramModule.ts

@@ -0,0 +1,16 @@
+import {SolanaModule} from "../chain/SolanaModule";
+import {Idl} from "@coral-xyz/anchor";
+import {SolanaProgramBase} from "./SolanaProgramBase";
+import {SolanaChainInterface} from "../chain/SolanaChainInterface";
+
+
+export class SolanaProgramModule<IDL extends Idl> extends SolanaModule {
+
+    protected readonly program: SolanaProgramBase<IDL>;
+
+    constructor(chainInterface: SolanaChainInterface, program: SolanaProgramBase<IDL>) {
+        super(chainInterface);
+        this.program = program;
+    }
+
+}

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

@@ -1,8 +1,9 @@
-import {SolanaEvents} from "../../base/modules/SolanaEvents";
+import {SolanaEvents} from "../../chain/modules/SolanaEvents";
 import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlTypes, Instruction} from "@coral-xyz/anchor";
 import {IdlField, IdlInstruction} from "@coral-xyz/anchor/dist/cjs/idl";
 import {ConfirmedSignatureInfo, ParsedMessage, PartiallyDecodedInstruction, 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;
 type ArgsTuple<A extends IdlField[], Defined> = {
@@ -25,16 +26,16 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
 
     private readonly programCoder: BorshCoder;
     private readonly eventParser: EventParser;
-    readonly root: SolanaProgramBase<any>;
+    private readonly program: SolanaProgramBase<IDL>;
     private readonly nameMappedInstructions: {[name: string]: IdlInstruction};
 
-    constructor(root: SolanaProgramBase<IDL>) {
-        super(root);
-        this.root = root;
-        this.programCoder = new BorshCoder(root.program.idl);
-        this.eventParser = new EventParser(root.program.programId, this.programCoder);
+    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>) {
+        super(chain);
+        this.program = program;
+        this.programCoder = new BorshCoder(program.program.idl);
+        this.eventParser = new EventParser(program.program.programId, this.programCoder);
         this.nameMappedInstructions = {};
-        for(let ix of root.program.idl.instructions) {
+        for(let ix of program.program.idl.instructions) {
             this.nameMappedInstructions[ix.name] = ix;
         }
     }
@@ -94,7 +95,7 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
         const instructions: InstructionWithAccounts<IDL>[] = [];
 
         for(let _ix of transactionMessage.instructions) {
-            if(!_ix.programId.equals(this.root.program.programId)) {
+            if(!_ix.programId.equals(this.program.program.programId)) {
                 instructions.push(null);
                 continue;
             }

package/src/solana/swaps/SolanaSwapData.ts

@@ -7,7 +7,7 @@ import {SwapTypeEnum} from "./SwapTypeEnum";
 import {Buffer} from "buffer";
 import {getAssociatedTokenAddressSync} from "@solana/spl-token";
 import {toBigInt, toClaimHash, toEscrowHash} from "../../utils/Utils";
-import {SolanaTokens} from "../base/modules/SolanaTokens";
+import {SolanaTokens} from "../chain/modules/SolanaTokens";
 
 const EXPIRY_BLOCKHEIGHT_THRESHOLD = new BN("1000000000");
 

package/src/solana/swaps/SolanaSwapModule.ts

@@ -1,17 +1,17 @@
-import {SolanaModule} from "../base/SolanaModule";
 import {SolanaSwapProgram} from "./SolanaSwapProgram";
 import {Program} from "@coral-xyz/anchor";
 import {SwapProgram} from "./programTypes";
+import {SolanaProgramModule} from "../program/SolanaProgramModule";
+import {SolanaChainInterface} from "../chain/SolanaChainInterface";
 
-export class SolanaSwapModule extends SolanaModule {
+export class SolanaSwapModule extends SolanaProgramModule<SwapProgram> {
 
-    readonly root: SolanaSwapProgram;
-    readonly program: Program<SwapProgram>;
+    protected readonly program: SolanaSwapProgram;
+    protected readonly swapProgram: Program<SwapProgram>;
 
-    constructor(root: SolanaSwapProgram) {
-        super(root);
-        this.root = root;
-        this.program = root.program;
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram) {
+        super(chainInterface, program);
+        this.swapProgram = program.program;
     }
 
 }