@nosana/kit 0.1.7 → 1.0.2

package/dist/programs/JobsProgram.js

@@ -1,7 +1,7 @@
 import { BaseProgram } from './BaseProgram.js';
-import { generateKeyPairSigner, parseBase64RpcAccount } from 'gill';
+import { generateKeyPairSigner, parseBase64RpcAccount, } from 'gill';
 import { ErrorCodes, NosanaError } from '../index.js';
-import * as programClient from "../generated_clients/jobs/index.js";
+import * as programClient from '../generated_clients/jobs/index.js';
 import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import bs58 from 'bs58';
 import { IPFS } from '../ipfs/IPFS.js';
@@ -65,8 +65,8 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-   * Fetch a run account by address
-   */
+     * Fetch a run account by address
+     */
     async market(addr) {
         try {
             const marketAccount = await this.client.fetchMarketAccount(this.sdk.solana.rpc, addr);
@@ -79,18 +79,17 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-   * Fetch multiple job accounts by address
-   */
+     * Fetch multiple job accounts by address
+     */
     async multiple(addresses, checkRuns = false) {
         try {
             const jobAccounts = await this.client.fetchAllJobAccount(this.sdk.solana.rpc, addresses);
-            ;
-            const jobs = jobAccounts.map(jobAccount => (this.transformJobAccount(jobAccount)));
+            const jobs = jobAccounts.map((jobAccount) => this.transformJobAccount(jobAccount));
             if (checkRuns) {
                 const runs = await this.runs();
-                jobs.forEach(job => {
+                jobs.forEach((job) => {
                     if (job.state === JobState.QUEUED) {
-                        const run = runs.find(run => run.job === job.address);
+                        const run = runs.find((run) => run.job === job.address);
                         if (run) {
                             job.state = JobState.RUNNING;
                             job.timeStart = run.time;
@@ -107,8 +106,8 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-    * Fetch all job accounts
-    */
+     * Fetch all job accounts
+     */
     async all(filters, checkRuns = false) {
         try {
             const extraGPAFilters = [];
@@ -118,7 +117,7 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(208),
                             bytes: bs58.encode(Buffer.from([filters.state])),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
@@ -127,7 +126,7 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(176),
                             bytes: filters.project.toString(),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
@@ -136,7 +135,7 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(104),
                             bytes: filters.node.toString(),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
@@ -145,20 +144,20 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(72),
                             bytes: filters.market.toString(),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
             }
             const getProgramAccountsResponse = await this.sdk.solana.rpc
                 .getProgramAccounts(this.getProgramId(), {
-                encoding: "base64",
+                encoding: 'base64',
                 filters: [
                     {
                         memcmp: {
                             offset: BigInt(0),
                             bytes: bs58.encode(Buffer.from(programClient.JOB_ACCOUNT_DISCRIMINATOR)),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     },
                     ...extraGPAFilters,
@@ -179,9 +178,9 @@ export class JobsProgram extends BaseProgram {
                 .filter((account) => account !== null);
             if (checkRuns) {
                 const runs = await this.runs();
-                jobs.forEach(job => {
+                jobs.forEach((job) => {
                     if (job.state === JobState.QUEUED) {
-                        const run = runs.find(run => run.job === job.address);
+                        const run = runs.find((run) => run.job === job.address);
                         if (run) {
                             job.state = JobState.RUNNING;
                             job.timeStart = run.time;
@@ -198,8 +197,8 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-    * Fetch all run accounts
-    */
+     * Fetch all run accounts
+     */
     async runs(filters) {
         try {
             const extraGPAFilters = [];
@@ -209,7 +208,7 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(40),
                             bytes: filters.node.toString(),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
@@ -218,20 +217,20 @@ export class JobsProgram extends BaseProgram {
                         memcmp: {
                             offset: BigInt(8),
                             bytes: filters.job.toString(),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     });
                 }
             }
             const getProgramAccountsResponse = await this.sdk.solana.rpc
                 .getProgramAccounts(this.getProgramId(), {
-                encoding: "base64",
+                encoding: 'base64',
                 filters: [
                     {
                         memcmp: {
                             offset: BigInt(0),
                             bytes: bs58.encode(Buffer.from(programClient.RUN_ACCOUNT_DISCRIMINATOR)),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     },
                 ],
@@ -257,19 +256,19 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-    * Fetch all market accounts
-    */
+     * Fetch all market accounts
+     */
     async markets() {
         try {
             const getProgramAccountsResponse = await this.sdk.solana.rpc
                 .getProgramAccounts(this.getProgramId(), {
-                encoding: "base64",
+                encoding: 'base64',
                 filters: [
                     {
                         memcmp: {
                             offset: BigInt(0),
                             bytes: bs58.encode(Buffer.from(programClient.MARKET_ACCOUNT_DISCRIMINATOR)),
-                            encoding: "base58",
+                            encoding: 'base58',
                         },
                     },
                 ],
@@ -305,7 +304,7 @@ export class JobsProgram extends BaseProgram {
         const [associatedTokenAddress] = await findAssociatedTokenPda({
             mint: this.sdk.config.programs.nosTokenAddress,
             owner: this.sdk.wallet.address,
-            tokenProgram: TOKEN_PROGRAM_ADDRESS
+            tokenProgram: TOKEN_PROGRAM_ADDRESS,
         });
         try {
             const staticAccounts = await this.getStaticAccounts();
@@ -315,17 +314,14 @@ export class JobsProgram extends BaseProgram {
                 market: params.market,
                 run: runKey,
                 user: associatedTokenAddress,
-                vault: await this.sdk.solana.pda([
-                    params.market,
-                    this.sdk.config.programs.nosTokenAddress,
-                ], staticAccounts.jobsProgram),
+                vault: await this.sdk.solana.pda([params.market, this.sdk.config.programs.nosTokenAddress], staticAccounts.jobsProgram),
                 payer: this.sdk.wallet,
                 rewardsReflection: staticAccounts.rewardsReflection,
                 rewardsVault: staticAccounts.rewardsVault,
                 authority: this.sdk.wallet,
                 rewardsProgram: staticAccounts.rewardsProgram,
                 ipfsJob: bs58.decode(params.ipfsHash).subarray(2),
-                timeout: params.timeout
+                timeout: params.timeout,
             });
             return instruction;
         }
@@ -336,32 +332,32 @@ export class JobsProgram extends BaseProgram {
         }
     }
     /**
-   * Monitor program account updates using callback functions
-   * Uses WebSocket subscriptions with automatic restart on failure
-   *
-   * @example
-   * ```typescript
-   * // Example: Monitor job accounts and save to file
-   * const stopMonitoring = await jobsProgram.monitor({
-   *   onJobAccount: async (jobAccount) => {
-   *     console.log('Job updated:', jobAccount.address.toString());
-   *     // Save to database, file, or process as needed
-   *   },
-   *   onRunAccount: async (runAccount) => {
-   *     console.log('Run updated:', runAccount.address.toString());
-   *   },
-   *   onError: async (error, accountType) => {
-   *     console.error('Error processing account:', error, accountType);
-   *   }
-   * });
-   *
-   * // Stop monitoring when done
-   * stopMonitoring();
-   * ```
-   *
-   * @param options Configuration options for monitoring
-   * @returns A function to stop monitoring
-   */
+     * Monitor program account updates using callback functions
+     * Uses WebSocket subscriptions with automatic restart on failure
+     *
+     * @example
+     * ```typescript
+     * // Example: Monitor job accounts and save to file
+     * const stopMonitoring = await jobsProgram.monitor({
+     *   onJobAccount: async (jobAccount) => {
+     *     console.log('Job updated:', jobAccount.address.toString());
+     *     // Save to database, file, or process as needed
+     *   },
+     *   onRunAccount: async (runAccount) => {
+     *     console.log('Run updated:', runAccount.address.toString());
+     *   },
+     *   onError: async (error, accountType) => {
+     *     console.error('Error processing account:', error, accountType);
+     *   }
+     * });
+     *
+     * // Stop monitoring when done
+     * stopMonitoring();
+     * ```
+     *
+     * @param options Configuration options for monitoring
+     * @returns A function to stop monitoring
+     */
     async monitor(options = {}) {
         const { onJobAccount, onMarketAccount, onRunAccount, onError } = options;
         const programId = this.getProgramId();
@@ -397,13 +393,13 @@ export class JobsProgram extends BaseProgram {
                         }
                         if (isMonitoring) {
                             this.sdk.logger.info('Retrying WebSocket subscription in 5 seconds...');
-                            await new Promise(resolve => setTimeout(resolve, 5000));
+                            await new Promise((resolve) => setTimeout(resolve, 5000));
                         }
                     }
                 }
             };
             // Start the subscription loop
-            startSubscription().catch(error => {
+            startSubscription().catch((error) => {
                 this.sdk.logger.error(`Failed to start subscription loop: ${error}`);
             });
             this.sdk.logger.info(`Successfully started monitoring job program account updates`);
@@ -464,7 +460,7 @@ export class JobsProgram extends BaseProgram {
         }
     }
     transformJobAccount(jobAccount) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { discriminator: _, ...jobAccountData } = jobAccount.data;
         const converted = convertBigIntToNumber(jobAccountData);
         return {
@@ -476,7 +472,7 @@ export class JobsProgram extends BaseProgram {
         };
     }
     transformRunAccount(runAccount) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { discriminator: _, ...runAccountData } = runAccount.data;
         return {
             address: runAccount.address,
@@ -484,7 +480,7 @@ export class JobsProgram extends BaseProgram {
         };
     }
     transformMarketAccount(marketAccount) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { discriminator: _, ...marketAccountData } = marketAccount.data;
         const converted = convertBigIntToNumber(marketAccountData);
         return {

package/dist/programs/StakeProgram.d.ts

@@ -0,0 +1,29 @@
+import { BaseProgram } from './BaseProgram.js';
+import { Address, Account } from 'gill';
+import { NosanaClient } from '../index.js';
+import * as programClient from '../generated_clients/staking/index.js';
+import { ConvertTypesForDb } from '../utils/index.js';
+export type Stake = ConvertTypesForDb<programClient.StakeAccountArgs> & {
+    address: Address;
+};
+export declare class StakeProgram extends BaseProgram {
+    readonly client: typeof programClient;
+    constructor(sdk: NosanaClient);
+    protected getProgramId(): Address;
+    /**
+     * Fetch a stake account by address
+     */
+    get(addr: Address): Promise<Stake>;
+    /**
+     * Fetch multiple stake accounts by address
+     */
+    multiple(addresses: Address[]): Promise<Stake[]>;
+    /**
+     * Fetch all stake accounts
+     */
+    all(): Promise<Stake[]>;
+    /**
+     * Transform stake account to include address and convert BigInt to numbers
+     */
+    transformStakeAccount(stakeAccount: Account<programClient.StakeAccount>): Stake;
+}

package/dist/programs/StakeProgram.js

@@ -0,0 +1,91 @@
+import { BaseProgram } from './BaseProgram.js';
+import { parseBase64RpcAccount } from 'gill';
+import * as programClient from '../generated_clients/staking/index.js';
+import { convertBigIntToNumber } from '../utils/index.js';
+import bs58 from 'bs58';
+export class StakeProgram extends BaseProgram {
+    constructor(sdk) {
+        super(sdk);
+        this.client = programClient;
+    }
+    getProgramId() {
+        return this.sdk.config.programs.stakeAddress;
+    }
+    /**
+     * Fetch a stake account by address
+     */
+    async get(addr) {
+        try {
+            const stakeAccount = await this.client.fetchStakeAccount(this.sdk.solana.rpc, addr);
+            const stake = this.transformStakeAccount(stakeAccount);
+            return stake;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch stake ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch multiple stake accounts by address
+     */
+    async multiple(addresses) {
+        try {
+            const stakeAccounts = await this.client.fetchAllStakeAccount(this.sdk.solana.rpc, addresses);
+            const stakes = stakeAccounts.map((stakeAccount) => this.transformStakeAccount(stakeAccount));
+            return stakes;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch stakes ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch all stake accounts
+     */
+    async all() {
+        try {
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: 'base64',
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58.encode(Buffer.from(this.client.STAKE_ACCOUNT_DISCRIMINATOR)),
+                            encoding: 'base58',
+                        },
+                    },
+                ],
+            })
+                .send();
+            const stakes = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const stakeAccount = programClient.decodeStakeAccount(parseBase64RpcAccount(result.pubkey, result.account));
+                    return this.transformStakeAccount(stakeAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode stake ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            return stakes;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all stakes ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Transform stake account to include address and convert BigInt to numbers
+     */
+    transformStakeAccount(stakeAccount) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { discriminator: _, ...stakeAccountData } = stakeAccount.data;
+        return {
+            address: stakeAccount.address,
+            ...convertBigIntToNumber(stakeAccountData),
+        };
+    }
+}

package/dist/services/NosService.d.ts

@@ -0,0 +1,48 @@
+import { Address } from 'gill';
+import { NosanaClient } from '../index.js';
+export interface TokenAccount {
+    pubkey: Address;
+    owner: Address;
+    mint: Address;
+    amount: bigint;
+    decimals: number;
+}
+export interface TokenAccountWithBalance extends TokenAccount {
+    uiAmount: number;
+}
+export declare class NosService {
+    private readonly sdk;
+    constructor(sdk: NosanaClient);
+    /**
+     * Get the NOS token mint address for the current network
+     */
+    private getNosTokenMint;
+    /**
+     * Retrieve all token accounts for all NOS token holders
+     * Uses a single RPC call to fetch all accounts holding the NOS token
+     *
+     * @param options - Optional configuration
+     * @param options.includeZeroBalance - Whether to include accounts with zero balance (default: false)
+     * @param options.excludePdaAccounts - Whether to exclude PDA (Program Derived Address) accounts owned by smart contracts (default: false)
+     * @returns Array of token accounts with their balances
+     */
+    getAllTokenHolders(options?: {
+        includeZeroBalance?: boolean;
+        excludePdaAccounts?: boolean;
+    }): Promise<TokenAccountWithBalance[]>;
+    /**
+     * Retrieve the NOS token account for a specific owner address
+     *
+     * @param owner - The owner address to query
+     * @returns The token account with balance, or null if no account exists
+     */
+    getTokenAccountForAddress(owner: string | Address): Promise<TokenAccountWithBalance | null>;
+    /**
+     * Get the NOS token balance for a specific owner address
+     * Convenience method that returns just the balance
+     *
+     * @param owner - The owner address to query
+     * @returns The token balance as a UI amount (with decimals), or 0 if no account exists
+     */
+    getBalance(owner: string | Address): Promise<number>;
+}

package/dist/services/NosService.js

@@ -0,0 +1,134 @@
+import { address } from 'gill';
+import { NosanaError, ErrorCodes } from '../errors/NosanaError.js';
+import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+// Offset of mint address in token account data structure
+const MINT_OFFSET = 0;
+export class NosService {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get the NOS token mint address for the current network
+     */
+    getNosTokenMint() {
+        return this.sdk.config.programs.nosTokenAddress;
+    }
+    /**
+     * Retrieve all token accounts for all NOS token holders
+     * Uses a single RPC call to fetch all accounts holding the NOS token
+     *
+     * @param options - Optional configuration
+     * @param options.includeZeroBalance - Whether to include accounts with zero balance (default: false)
+     * @param options.excludePdaAccounts - Whether to exclude PDA (Program Derived Address) accounts owned by smart contracts (default: false)
+     * @returns Array of token accounts with their balances
+     */
+    async getAllTokenHolders(options) {
+        try {
+            const nosMint = this.getNosTokenMint();
+            this.sdk.logger.debug(`Fetching all NOS token holders for mint: ${nosMint}`);
+            // Use getProgramAccounts to fetch all token accounts for the NOS mint
+            const accounts = await this.sdk.solana.rpc
+                .getProgramAccounts(TOKEN_PROGRAM_ADDRESS, {
+                encoding: 'jsonParsed',
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(MINT_OFFSET),
+                            bytes: nosMint.toString(),
+                            encoding: 'base58',
+                        },
+                    },
+                ],
+            })
+                .send();
+            this.sdk.logger.info(`Found ${accounts.length} NOS token accounts`);
+            // Parse the response
+            const allAccounts = accounts.map((accountInfo) => {
+                const parsed = accountInfo.account.data.parsed.info;
+                return {
+                    pubkey: accountInfo.pubkey,
+                    owner: parsed.owner,
+                    mint: parsed.mint,
+                    amount: BigInt(parsed.tokenAmount.amount),
+                    decimals: parsed.tokenAmount.decimals,
+                    uiAmount: parsed.tokenAmount.uiAmount ?? 0,
+                };
+            });
+            // Apply filters
+            const includeZeroBalance = options?.includeZeroBalance ?? false;
+            const excludePdaAccounts = options?.excludePdaAccounts ?? false;
+            let filteredAccounts = allAccounts;
+            // Filter out zero balance accounts unless explicitly included
+            if (!includeZeroBalance) {
+                filteredAccounts = filteredAccounts.filter((account) => account.uiAmount > 0);
+            }
+            // Filter out PDA accounts (where token account equals owner, indicating smart contract ownership)
+            if (excludePdaAccounts) {
+                const beforePdaFilter = filteredAccounts.length;
+                filteredAccounts = filteredAccounts.filter((account) => account.pubkey !== account.owner);
+                const pdaCount = beforePdaFilter - filteredAccounts.length;
+                this.sdk.logger.debug(`Filtered out ${pdaCount} PDA accounts`);
+            }
+            const filterInfo = [];
+            if (!includeZeroBalance)
+                filterInfo.push('excluding zero balances');
+            if (excludePdaAccounts)
+                filterInfo.push('excluding PDA accounts');
+            const filterText = filterInfo.length > 0 ? ` (${filterInfo.join(', ')})` : '';
+            this.sdk.logger.info(`Returning ${filteredAccounts.length} NOS token holders${filterText}`);
+            return filteredAccounts;
+        }
+        catch (error) {
+            this.sdk.logger.error(`Failed to fetch NOS token holders: ${error}`);
+            throw new NosanaError('Failed to fetch NOS token holders', ErrorCodes.RPC_ERROR, error);
+        }
+    }
+    /**
+     * Retrieve the NOS token account for a specific owner address
+     *
+     * @param owner - The owner address to query
+     * @returns The token account with balance, or null if no account exists
+     */
+    async getTokenAccountForAddress(owner) {
+        try {
+            const ownerAddr = typeof owner === 'string' ? address(owner) : owner;
+            const nosMint = this.getNosTokenMint();
+            this.sdk.logger.debug(`Fetching NOS token account for owner: ${ownerAddr}`);
+            // Use getTokenAccountsByOwner to fetch token accounts for this owner filtered by NOS mint
+            const response = await this.sdk.solana.rpc
+                .getTokenAccountsByOwner(ownerAddr, { mint: nosMint }, { encoding: 'jsonParsed' })
+                .send();
+            if (response.value.length === 0) {
+                this.sdk.logger.debug(`No NOS token account found for owner: ${ownerAddr}`);
+                return null;
+            }
+            // Typically there should only be one token account per owner per mint
+            const accountInfo = response.value[0];
+            const parsed = accountInfo.account.data.parsed.info;
+            this.sdk.logger.info(`Found NOS token account for owner ${ownerAddr}: balance = ${parsed.tokenAmount.uiAmount}`);
+            return {
+                pubkey: accountInfo.pubkey,
+                owner: parsed.owner,
+                mint: parsed.mint,
+                amount: BigInt(parsed.tokenAmount.amount),
+                decimals: parsed.tokenAmount.decimals,
+                uiAmount: parsed.tokenAmount.uiAmount ?? 0,
+            };
+        }
+        catch (error) {
+            this.sdk.logger.error(`Failed to fetch NOS token account for owner: ${error}`);
+            throw new NosanaError('Failed to fetch NOS token account', ErrorCodes.RPC_ERROR, error);
+        }
+    }
+    /**
+     * Get the NOS token balance for a specific owner address
+     * Convenience method that returns just the balance
+     *
+     * @param owner - The owner address to query
+     * @returns The token balance as a UI amount (with decimals), or 0 if no account exists
+     */
+    async getBalance(owner) {
+        const account = await this.getTokenAccountForAddress(owner);
+        return account ? account.uiAmount : 0;
+    }
+}

package/dist/{solana/SolanaUtils.d.ts → services/SolanaService.d.ts}

@@ -1,10 +1,10 @@
 import { Address, SolanaClient, Signature, IInstruction, TransactionMessageWithBlockhashLifetime, CompilableTransactionMessage, FullySignedTransaction, TransactionWithBlockhashLifetime } from 'gill';
 import { NosanaClient } from '../index.js';
-export declare class SolanaUtils {
+export declare class SolanaService {
     private readonly sdk;
-    readonly rpc: SolanaClient["rpc"];
-    readonly rpcSubscriptions: SolanaClient["rpcSubscriptions"];
-    readonly sendAndConfirmTransaction: SolanaClient["sendAndConfirmTransaction"];
+    readonly rpc: SolanaClient['rpc'];
+    readonly rpcSubscriptions: SolanaClient['rpcSubscriptions'];
+    readonly sendAndConfirmTransaction: SolanaClient['sendAndConfirmTransaction'];
     constructor(sdk: NosanaClient);
     pda(seeds: Array<Address | string>, programId: Address): Promise<Address>;
     getBalance(addressStr: string | Address): Promise<bigint>;
@@ -25,5 +25,5 @@ export declare class SolanaUtils {
      * @param instructionsOrTransaction Single instruction, array of instructions, or pre-built transaction
      * @returns The transaction signature
      */
-    send(instructionsOrTransaction: IInstruction | IInstruction[] | CompilableTransactionMessage & TransactionMessageWithBlockhashLifetime | FullySignedTransaction & TransactionWithBlockhashLifetime): Promise<Signature>;
+    send(instructionsOrTransaction: IInstruction | IInstruction[] | (CompilableTransactionMessage & TransactionMessageWithBlockhashLifetime) | (FullySignedTransaction & TransactionWithBlockhashLifetime)): Promise<Signature>;
 }