@nosana/kit 0.1.1

package/dist/programs/JobsProgram.js

@@ -0,0 +1,611 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsProgram = void 0;
+const BaseProgram_js_1 = require("./BaseProgram.js");
+const gill_1 = require("gill");
+const index_js_1 = require("../index.js");
+const programClient = __importStar(require("../generated_clients/jobs/index.js"));
+const token_1 = require("@solana-program/token");
+const bs58_1 = __importDefault(require("bs58"));
+const IPFS_js_1 = require("../ipfs/IPFS.js");
+const index_js_2 = require("../utils/index.js");
+class JobsProgram extends BaseProgram_js_1.BaseProgram {
+    constructor(sdk) {
+        super(sdk);
+        this.client = programClient;
+    }
+    getProgramId() {
+        return this.sdk.config.programs.jobsAddress;
+    }
+    /**
+     * Fetch a job account by address
+     */
+    async get(addr, checkRun = true) {
+        try {
+            const jobAccount = await this.client.fetchJobAccount(this.sdk.solana.rpc, addr);
+            const job = this.transformJobAccount(jobAccount);
+            if (checkRun && job.state === 0) {
+                // If job is queued, check if there is a run account for the job
+                const runs = await this.runs({ job: job.address });
+                if (runs.length > 0) {
+                    const run = runs[0];
+                    job.state = 1;
+                    job.timeStart = run.time;
+                    job.node = run.node;
+                }
+            }
+            return job;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch job ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch a run account by address
+     */
+    async run(addr) {
+        try {
+            const runAccount = await this.client.fetchRunAccount(this.sdk.solana.rpc, addr);
+            const run = this.transformRunAccount(runAccount);
+            return run;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch run ${err}`);
+            throw err;
+        }
+    }
+    /**
+   * Fetch a run account by address
+   */
+    async market(addr) {
+        try {
+            const marketAccount = await this.client.fetchMarketAccount(this.sdk.solana.rpc, addr);
+            const market = this.transformMarketAccount(marketAccount);
+            return market;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch market ${err}`);
+            throw err;
+        }
+    }
+    /**
+   * 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)));
+            if (checkRuns) {
+                const runs = await this.runs();
+                jobs.forEach(job => {
+                    if (job.state === 0) {
+                        const run = runs.find(run => run.job === job.address);
+                        if (run) {
+                            job.state = 1;
+                            job.timeStart = run.time;
+                            job.node = run.node;
+                        }
+                    }
+                });
+            }
+            return jobs;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch job ${err}`);
+            throw err;
+        }
+    }
+    /**
+    * Fetch all job accounts
+    */
+    async all(filters, checkRuns = false) {
+        try {
+            const extraGPAFilters = [];
+            if (filters) {
+                if (typeof filters.state === 'number') {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(208),
+                            bytes: bs58_1.default.encode(Buffer.from([filters.state])),
+                            encoding: "base58",
+                        },
+                    });
+                }
+                if (filters.project) {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(176),
+                            bytes: filters.project.toString(),
+                            encoding: "base58",
+                        },
+                    });
+                }
+                if (filters.node) {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(104),
+                            bytes: filters.node.toString(),
+                            encoding: "base58",
+                        },
+                    });
+                }
+                if (filters.market) {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(72),
+                            bytes: filters.market.toString(),
+                            encoding: "base58",
+                        },
+                    });
+                }
+            }
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: "base64",
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58_1.default.encode(Buffer.from(programClient.JOB_ACCOUNT_DISCRIMINATOR)),
+                            encoding: "base58",
+                        },
+                    },
+                    ...extraGPAFilters,
+                ],
+            })
+                .send();
+            const jobs = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const jobAccount = programClient.decodeJobAccount((0, gill_1.parseBase64RpcAccount)(result.pubkey, result.account));
+                    return this.transformJobAccount(jobAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode job ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            if (checkRuns) {
+                const runs = await this.runs();
+                jobs.forEach(job => {
+                    if (job.state === 0) {
+                        const run = runs.find(run => run.job === job.address);
+                        if (run) {
+                            job.state = 1;
+                            job.timeStart = run.time;
+                            job.node = run.node;
+                        }
+                    }
+                });
+            }
+            return jobs;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all jobs ${err}`);
+            throw err;
+        }
+    }
+    /**
+    * Fetch all run accounts
+    */
+    async runs(filters) {
+        try {
+            const extraGPAFilters = [];
+            if (filters) {
+                if (filters.node) {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(40),
+                            bytes: filters.node.toString(),
+                            encoding: "base58",
+                        },
+                    });
+                }
+                if (filters.job) {
+                    extraGPAFilters.push({
+                        memcmp: {
+                            offset: BigInt(8),
+                            bytes: filters.job.toString(),
+                            encoding: "base58",
+                        },
+                    });
+                }
+            }
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: "base64",
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58_1.default.encode(Buffer.from(programClient.RUN_ACCOUNT_DISCRIMINATOR)),
+                            encoding: "base58",
+                        },
+                    },
+                ],
+            })
+                .send();
+            const runAccounts = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const runAccount = programClient.decodeRunAccount((0, gill_1.parseBase64RpcAccount)(result.pubkey, result.account));
+                    return this.transformRunAccount(runAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode run ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            return runAccounts;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all runs ${err}`);
+            throw err;
+        }
+    }
+    /**
+    * Fetch all market accounts
+    */
+    async markets() {
+        try {
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: "base64",
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58_1.default.encode(Buffer.from(programClient.MARKET_ACCOUNT_DISCRIMINATOR)),
+                            encoding: "base58",
+                        },
+                    },
+                ],
+            })
+                .send();
+            const marketAccounts = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const marketAccount = programClient.decodeMarketAccount((0, gill_1.parseBase64RpcAccount)(result.pubkey, result.account));
+                    return this.transformMarketAccount(marketAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode market ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            return marketAccounts;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all markets ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Post a new job to the marketplace
+     * @param params Parameters for listing a job
+     * @returns The transaction signature
+     */
+    async post(params) {
+        if (!this.sdk.config.wallet) {
+            throw new index_js_1.NosanaError('No wallet found', index_js_1.ErrorCodes.NO_WALLET);
+        }
+        const jobKey = await (0, gill_1.generateKeyPairSigner)();
+        const runKey = await (0, gill_1.generateKeyPairSigner)();
+        const [associatedTokenAddress] = await (0, token_1.findAssociatedTokenPda)({
+            mint: this.sdk.config.programs.nosTokenAddress,
+            owner: this.sdk.config.wallet.signer.address,
+            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS
+        });
+        try {
+            const staticAccounts = await this.getStaticAccounts();
+            // Create the list instruction
+            const instruction = this.client.getListInstruction({
+                job: jobKey,
+                market: params.market,
+                run: runKey,
+                user: associatedTokenAddress,
+                vault: await this.sdk.solana.pda([
+                    params.market,
+                    this.sdk.config.programs.nosTokenAddress,
+                ], staticAccounts.jobsProgram),
+                payer: this.sdk.config.wallet.signer,
+                rewardsReflection: staticAccounts.rewardsReflection,
+                rewardsVault: staticAccounts.rewardsVault,
+                authority: this.sdk.config.wallet.signer,
+                rewardsProgram: staticAccounts.rewardsProgram,
+                ipfsJob: bs58_1.default.decode(params.ipfsHash).subarray(2),
+                timeout: params.timeout
+            });
+            if (params.instructionOnly)
+                return instruction;
+            // Create the transaction
+            const transaction = (0, gill_1.createTransaction)({
+                instructions: [instruction],
+                feePayer: this.sdk.config.wallet.signer,
+                latestBlockhash: await this.sdk.solana.getLatestBlockhash(),
+                version: 0,
+            });
+            // Sign the transaction with all required signers
+            const signedTransaction = await (0, gill_1.signTransactionMessageWithSigners)(transaction);
+            // Get the transaction signature for logging
+            const signature = (0, gill_1.getSignatureFromTransaction)(signedTransaction);
+            // Log the transaction explorer link
+            const explorerLink = (0, gill_1.getExplorerLink)({
+                cluster: this.sdk.config.solana.cluster,
+                transaction: signature
+            });
+            this.sdk.logger.info(`Sending list job transaction: ${explorerLink}`);
+            // Send and confirm the transaction
+            await this.sdk.solana.sendAndConfirmTransaction(signedTransaction);
+            this.sdk.logger.info("Job listing transaction confirmed!");
+            return signature;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to list job: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(`Failed to list job: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+   * 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();
+        try {
+            this.sdk.logger.info(`Starting to monitor job program account updates for program: ${programId}`);
+            let abortController = null;
+            let isMonitoring = true;
+            // Function to stop all monitoring
+            const stopMonitoring = () => {
+                isMonitoring = false;
+                if (abortController) {
+                    abortController.abort();
+                }
+                this.sdk.logger.info(`Stopped monitoring job program account updates`);
+            };
+            // Function to start/restart subscription with retry logic
+            const startSubscription = async () => {
+                while (isMonitoring) {
+                    try {
+                        this.sdk.logger.info('Attempting to establish WebSocket subscription...');
+                        abortController = new AbortController();
+                        const subscriptionIterable = await this.setupSubscription(abortController);
+                        this.sdk.logger.info('Successfully established WebSocket subscription');
+                        // Start processing subscription notifications
+                        await this.processSubscriptionNotifications(subscriptionIterable, { onJobAccount, onMarketAccount, onRunAccount, onError }, () => isMonitoring);
+                    }
+                    catch (error) {
+                        this.sdk.logger.warn(`WebSocket subscription failed: ${error}`);
+                        // Clean up current subscription
+                        if (abortController) {
+                            abortController.abort();
+                            abortController = null;
+                        }
+                        if (isMonitoring) {
+                            this.sdk.logger.info('Retrying WebSocket subscription in 5 seconds...');
+                            await new Promise(resolve => setTimeout(resolve, 5000));
+                        }
+                    }
+                }
+            };
+            // Start the subscription loop
+            startSubscription().catch(error => {
+                this.sdk.logger.error(`Failed to start subscription loop: ${error}`);
+            });
+            this.sdk.logger.info(`Successfully started monitoring job program account updates`);
+            return stopMonitoring;
+        }
+        catch (error) {
+            this.sdk.logger.error(`Failed to start monitoring job program accounts: ${error}`);
+            throw new index_js_1.NosanaError('Failed to start monitoring job program accounts', index_js_1.ErrorCodes.RPC_ERROR, error);
+        }
+    }
+    /**
+     * Set up WebSocket subscription for program notifications
+     */
+    async setupSubscription(abortController) {
+        try {
+            // Set up the subscription using the correct API pattern
+            const subscriptionIterable = await this.sdk.solana.rpcSubscriptions
+                .programNotifications(this.getProgramId(), { encoding: 'base64' })
+                .subscribe({ abortSignal: abortController.signal });
+            return subscriptionIterable;
+        }
+        catch (error) {
+            throw new Error(`Failed to setup subscription: ${error}`);
+        }
+    }
+    /**
+     * Process subscription notifications
+     */
+    async processSubscriptionNotifications(notificationIterable, options, isMonitoring) {
+        try {
+            for await (const notification of notificationIterable) {
+                // Check if monitoring should continue
+                if (!isMonitoring()) {
+                    this.sdk.logger.info('Monitoring stopped, exiting subscription processing');
+                    break;
+                }
+                try {
+                    const { value } = notification;
+                    await this.handleAccountUpdate(value, options, isMonitoring);
+                }
+                catch (error) {
+                    this.sdk.logger.error(`Error handling account update notification: ${error}`);
+                    if (options.onError) {
+                        try {
+                            await options.onError(error instanceof Error ? error : new Error(String(error)));
+                        }
+                        catch (callbackError) {
+                            this.sdk.logger.error(`Error in onError callback: ${callbackError}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.sdk.logger.error(`Subscription error: ${error}`);
+            // Throw the error so the calling function can restart the subscription
+            throw error;
+        }
+    }
+    transformJobAccount(jobAccount) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        const { discriminator: _, ...jobAccountData } = jobAccount.data;
+        return {
+            address: jobAccount.address,
+            ...(0, index_js_2.convertBigIntToNumber)(jobAccountData),
+            ipfsJob: IPFS_js_1.IPFS.solHashToIpfsHash(jobAccountData.ipfsJob),
+            ipfsResult: IPFS_js_1.IPFS.solHashToIpfsHash(jobAccountData.ipfsResult),
+        };
+    }
+    transformRunAccount(runAccount) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        const { discriminator: _, ...runAccountData } = runAccount.data;
+        return {
+            address: runAccount.address,
+            ...(0, index_js_2.convertBigIntToNumber)(runAccountData),
+        };
+    }
+    transformMarketAccount(marketAccount) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars 
+        const { discriminator: _, ...marketAccountData } = marketAccount.data;
+        return {
+            address: marketAccount.address,
+            ...(0, index_js_2.convertBigIntToNumber)(marketAccountData),
+        };
+    }
+    /**
+     * Handle account update using callback functions
+     */
+    async handleAccountUpdate(accountData, options, isMonitoring) {
+        try {
+            const { account, pubkey } = accountData;
+            const encodedAccount = (0, gill_1.parseBase64RpcAccount)(pubkey, account);
+            const accountType = programClient.identifyNosanaJobsAccount(encodedAccount);
+            switch (accountType) {
+                case programClient.NosanaJobsAccount.JobAccount:
+                    const jobAccount = programClient.decodeJobAccount(encodedAccount);
+                    await this.handleJobAccount(jobAccount, options.onJobAccount, isMonitoring);
+                    break;
+                case programClient.NosanaJobsAccount.MarketAccount:
+                    const marketAccount = programClient.decodeMarketAccount(encodedAccount);
+                    await this.handleMarketAccount(marketAccount, options.onMarketAccount, isMonitoring);
+                    break;
+                case programClient.NosanaJobsAccount.RunAccount:
+                    const runAccount = programClient.decodeRunAccount(encodedAccount);
+                    await this.handleRunAccount(runAccount, options.onRunAccount, isMonitoring);
+                    break;
+                default:
+                    this.sdk.logger.error(`No support yet for account type: ${accountType}`);
+                    return;
+            }
+        }
+        catch (error) {
+            this.sdk.logger.error(`Error in handleAccountUpdate: ${error}`);
+        }
+    }
+    async handleJobAccount(jobAccount, onJobAccount, _isMonitoring) {
+        if (onJobAccount) {
+            try {
+                await onJobAccount(this.transformJobAccount(jobAccount));
+            }
+            catch (error) {
+                this.sdk.logger.error(`Error in onJobAccount callback: ${error}`);
+                throw error;
+            }
+        }
+        this.sdk.logger.debug(`Processed job account ${jobAccount.address.toString()}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async handleMarketAccount(marketAccount, onMarketAccount, _isMonitoring) {
+        if (onMarketAccount) {
+            try {
+                await onMarketAccount(this.transformMarketAccount(marketAccount));
+            }
+            catch (error) {
+                this.sdk.logger.error(`Error in onMarketAccount callback: ${error}`);
+                throw error;
+            }
+        }
+        this.sdk.logger.debug(`Processed market account ${marketAccount.address.toString()}`);
+    }
+    async handleRunAccount(runAccount, onRunAccount, _isMonitoring) {
+        if (onRunAccount) {
+            try {
+                await onRunAccount(this.transformRunAccount(runAccount));
+            }
+            catch (error) {
+                this.sdk.logger.error(`Error in onRunAccount callback: ${error}`);
+                throw error;
+            }
+        }
+        this.sdk.logger.debug(`Processed run account ${runAccount.address.toString()}`);
+    }
+}
+exports.JobsProgram = JobsProgram;

package/dist/solana/SolanaUtils.d.ts

@@ -0,0 +1,15 @@
+import { Address, SolanaClient } from 'gill';
+import { NosanaClient } from '../index.js';
+export declare class SolanaUtils {
+    private readonly sdk;
+    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>;
+    getLatestBlockhash(): Promise<Readonly<{
+        blockhash: import("gill").Blockhash;
+        lastValidBlockHeight: bigint;
+    }>>;
+}

package/dist/solana/SolanaUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaUtils = void 0;
+const gill_1 = require("gill");
+const NosanaError_js_1 = require("../errors/NosanaError.js");
+class SolanaUtils {
+    constructor(sdk) {
+        this.sdk = sdk;
+        const rpcEndpoint = this.sdk.config.solana.rpcEndpoint;
+        if (!rpcEndpoint)
+            throw new NosanaError_js_1.NosanaError('RPC URL is required', NosanaError_js_1.ErrorCodes.INVALID_CONFIG);
+        const { rpc, rpcSubscriptions, sendAndConfirmTransaction } = (0, gill_1.createSolanaClient)({ urlOrMoniker: rpcEndpoint });
+        this.rpc = rpc;
+        this.rpcSubscriptions = rpcSubscriptions;
+        this.sendAndConfirmTransaction = sendAndConfirmTransaction;
+    }
+    async pda(seeds, programId) {
+        const addressEncoder = (0, gill_1.getAddressEncoder)();
+        const [pda] = await (0, gill_1.getProgramDerivedAddress)({
+            programAddress: programId,
+            seeds: seeds.map(seed => typeof seed !== 'string' ? addressEncoder.encode(seed) : seed),
+        });
+        return pda;
+    }
+    async getBalance(addressStr) {
+        try {
+            this.sdk.logger.debug(`Getting balance for address: ${addressStr}`);
+            const addr = (0, gill_1.address)(addressStr);
+            const balance = await this.rpc.getBalance(addr).send();
+            return balance.value;
+        }
+        catch (error) {
+            this.sdk.logger.error(`Failed to get balance: ${error}`);
+            throw new NosanaError_js_1.NosanaError('Failed to get balance', NosanaError_js_1.ErrorCodes.RPC_ERROR, error);
+        }
+    }
+    async getLatestBlockhash() {
+        try {
+            const { value: blockhash } = await this.rpc.getLatestBlockhash().send();
+            return blockhash;
+        }
+        catch (error) {
+            this.sdk.logger.error(`Failed to get latest blockhash: ${error}`);
+            throw new NosanaError_js_1.NosanaError('Failed to get latest blockhash', NosanaError_js_1.ErrorCodes.RPC_ERROR, error);
+        }
+    }
+}
+exports.SolanaUtils = SolanaUtils;

package/dist/utils/index.d.ts

@@ -0,0 +1,19 @@
+import { ReadonlyUint8Array } from 'gill';
+/**
+ * Type helper to convert bigint properties to number
+ */
+export type ConvertBigIntToNumber<T> = {
+    [K in keyof T]: T[K] extends bigint ? number : T[K];
+};
+/**
+ * Type helper to convert bigint to number and ReadonlyUint8Array to string
+ */
+export type ConvertTypesForDb<T> = {
+    [K in keyof T]: T[K] extends bigint ? number : T[K] extends ReadonlyUint8Array ? string : T[K];
+};
+/**
+ * Helper function to convert bigint values to numbers in an object
+ * @param obj Object that may contain bigint values
+ * @returns Object with all bigint values converted to numbers
+ */
+export declare function convertBigIntToNumber<T extends Record<string, any>>(obj: T): ConvertBigIntToNumber<T>;