@nosana/kit 0.1.5 → 0.1.7

package/dist/config/types.d.ts

@@ -38,4 +38,6 @@ export interface ClientConfig {
 export interface PartialClientConfig {
     solana?: Partial<SolanaConfig>;
     wallet?: WalletConfig;
+    ipfs?: Partial<IpfsConfig>;
+    logLevel?: NosanaLogLevel;
 }

package/dist/config/utils.js

@@ -11,6 +11,10 @@ export const mergeConfigs = (defaultConfig, customConfig) => {
             ...defaultConfig.solana,
             ...customConfig.solana,
         },
+        ipfs: {
+            ...defaultConfig.ipfs,
+            ...customConfig.ipfs,
+        },
     };
 };
 export const getNosanaConfig = (network = NosanaNetwork.MAINNET, config) => {
@@ -27,4 +31,9 @@ export const getNosanaConfig = (network = NosanaNetwork.MAINNET, config) => {
 //   solana: {  
 //     rpcEndpoint: 'your-custom-rpc-endpoint-url',
 //   },
+//   ipfs: {
+//     jwt: 'your-custom-jwt-token',
+//     gateway: 'https://your-custom-gateway.com/ipfs/',
+//   },
+//   logLevel: NosanaLogLevel.DEBUG,
 // });

package/dist/index.d.ts

@@ -2,11 +2,13 @@ import { ClientConfig, NosanaNetwork, PartialClientConfig, WalletConfig } from '
 import { Logger } from './logger/Logger.js';
 import { JobsProgram } from './programs/JobsProgram.js';
 import { SolanaUtils } from './solana/SolanaUtils.js';
+import { IPFS } from './ipfs/IPFS.js';
 import { KeyPairSigner } from 'gill';
 export declare class NosanaClient {
     readonly config: ClientConfig;
     readonly jobs: JobsProgram;
     readonly solana: SolanaUtils;
+    readonly ipfs: IPFS;
     readonly logger: Logger;
     wallet: KeyPairSigner | undefined;
     constructor(network?: NosanaNetwork, customConfig?: PartialClientConfig);

package/dist/index.js

@@ -6,6 +6,7 @@ import { getNosanaConfig, NosanaNetwork } from './config/index.js';
 import { Logger } from './logger/Logger.js';
 import { JobsProgram } from './programs/JobsProgram.js';
 import { SolanaUtils } from './solana/SolanaUtils.js';
+import { IPFS } from './ipfs/IPFS.js';
 import { createKeyPairSignerFromBytes } from 'gill';
 import { NosanaError, ErrorCodes } from './errors/NosanaError.js';
 import bs58 from 'bs58';
@@ -18,6 +19,7 @@ export class NosanaClient {
         this.jobs = new JobsProgram(this);
         this.logger = Logger.getInstance();
         this.solana = new SolanaUtils(this);
+        this.ipfs = new IPFS(this.config.ipfs);
     }
     async setWallet(wallet) {
         try {

package/dist/ipfs/IPFS.d.ts

@@ -1,19 +1,50 @@
+import { AxiosRequestConfig } from 'axios';
 import { ReadonlyUint8Array } from 'gill';
+import type { IpfsConfig } from '../config/types.js';
 /**
  * Class to interact with Pinata Cloud
  * https://www.pinata.cloud/
  */
 export declare class IPFS {
+    private api;
+    config: IpfsConfig;
+    constructor(config: IpfsConfig);
     /**
      * Convert the ipfs bytes from a solana job to a CID
      * It prepends the 0x1220 (18,32) to make it 34 bytes and Base58 encodes it.
      * This result is IPFS addressable.
      */
-    static solHashToIpfsHash(hashArray: ReadonlyUint8Array): string;
+    static solHashToIpfsHash(hashArray: ReadonlyUint8Array | Array<number>): string | null;
     /**
      * Converts IPFS hash to byte array needed to submit results
      * @param hash IPFS hash
      * @returns Array<number>
      */
-    static IpfsHashToByteArray(hash: string): Uint8Array;
+    static IpfsHashToByteArray(hash: string): Array<number>;
+    /**
+     * Retrieve data from IPFS using the configured gateway
+     * @param hash IPFS hash string or byte array
+     * @param options Additional axios request options
+     * @returns The retrieved data
+     */
+    retrieve(hash: string | Array<number>, options?: AxiosRequestConfig): Promise<any>;
+    /**
+     * Function to pin data into Pinata Cloud
+     * @param data Object to pin into IPFS as JSON
+     * @returns The IPFS hash of the pinned data
+     */
+    pin(data: object): Promise<string>;
+    /**
+     * Function to pin a file into Pinata Cloud
+     * @param filePath Path to the file to pin
+     * @returns The IPFS hash of the pinned file
+     */
+    pinFile(filePath: string): Promise<string>;
+    /**
+     * Function to pin a file from buffer/blob into Pinata Cloud
+     * @param fileBuffer Buffer or Blob containing the file data
+     * @param fileName Name of the file
+     * @returns The IPFS hash of the pinned file
+     */
+    pinFileFromBuffer(fileBuffer: Buffer | Blob, fileName: string): Promise<string>;
 }

package/dist/ipfs/IPFS.js

@@ -1,9 +1,41 @@
 import bs58 from 'bs58';
+import axios, { AxiosHeaders } from 'axios';
+// Import form-data dynamically for Node.js environments
+let FormData;
+let fs;
+// Dynamically import Node.js-specific modules
+const loadNodeModules = async () => {
+    if (typeof window === 'undefined') {
+        try {
+            const formDataModule = await import('form-data');
+            FormData = formDataModule.default;
+            fs = await import('fs');
+        }
+        catch (error) {
+            console.warn('Node.js modules not available for file operations');
+        }
+    }
+    else {
+        // Use browser FormData
+        FormData = window.FormData;
+    }
+};
 /**
  * Class to interact with Pinata Cloud
  * https://www.pinata.cloud/
  */
 export class IPFS {
+    constructor(config) {
+        this.config = config;
+        const headers = new AxiosHeaders();
+        if (this.config.jwt) {
+            headers.set('Authorization', `Bearer ${this.config.jwt}`);
+        }
+        this.api = axios.create({
+            baseURL: this.config.api,
+            headers,
+        });
+    }
     /**
      * Convert the ipfs bytes from a solana job to a CID
      * It prepends the 0x1220 (18,32) to make it 34 bytes and Base58 encodes it.
@@ -11,18 +43,23 @@ export class IPFS {
      */
     static solHashToIpfsHash(hashArray) {
         let finalArray;
-        if (hashArray.length === 32) {
+        const inputArray = Array.isArray(hashArray) ? hashArray : Array.from(hashArray);
+        if (inputArray.length === 32) {
             // Create a new array with the prepended bytes [18, 32] + original array
             finalArray = new Uint8Array(34);
             finalArray[0] = 18;
             finalArray[1] = 32;
-            finalArray.set(hashArray, 2);
+            finalArray.set(inputArray, 2);
         }
         else {
             // Use the array as-is if it's not 32 bytes
-            finalArray = new Uint8Array(hashArray);
+            finalArray = new Uint8Array(inputArray);
         }
-        return bs58.encode(Buffer.from(finalArray));
+        const hash = bs58.encode(Buffer.from(finalArray));
+        if (hash === 'QmNLei78zWmzUdbeRB3CiUfAizWUrbeeZh5K1rhAQKCh51') {
+            return null;
+        }
+        return hash;
     }
     /**
      * Converts IPFS hash to byte array needed to submit results
@@ -31,10 +68,79 @@ export class IPFS {
      */
     static IpfsHashToByteArray(hash) {
         if (hash.length === 34) {
-            return new Uint8Array([...bs58.decode(hash).subarray(2)]);
+            return [...bs58.decode(hash).subarray(2)];
         }
         else {
-            return new Uint8Array([...bs58.decode(hash)]);
+            return [...bs58.decode(hash)];
+        }
+    }
+    /**
+     * Retrieve data from IPFS using the configured gateway
+     * @param hash IPFS hash string or byte array
+     * @param options Additional axios request options
+     * @returns The retrieved data
+     */
+    async retrieve(hash, options = {}) {
+        if (typeof hash !== 'string') {
+            const convertedHash = IPFS.solHashToIpfsHash(hash);
+            if (!convertedHash) {
+                throw new Error('Invalid hash provided');
+            }
+            hash = convertedHash;
+        }
+        const response = await axios.get(this.config.gateway + hash, options);
+        return response.data;
+    }
+    /**
+     * Function to pin data into Pinata Cloud
+     * @param data Object to pin into IPFS as JSON
+     * @returns The IPFS hash of the pinned data
+     */
+    async pin(data) {
+        const response = await this.api.post('/pinning/pinJSONToIPFS', data);
+        return response.data.IpfsHash;
+    }
+    /**
+     * Function to pin a file into Pinata Cloud
+     * @param filePath Path to the file to pin
+     * @returns The IPFS hash of the pinned file
+     */
+    async pinFile(filePath) {
+        // Ensure Node.js modules are loaded
+        await loadNodeModules();
+        if (!FormData || !fs) {
+            throw new Error('File operations are not supported in this environment');
+        }
+        const data = new FormData();
+        data.append('file', fs.createReadStream(filePath));
+        const response = await this.api.post('/pinning/pinFileToIPFS', data, {
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${data.getBoundary()}`,
+                Authorization: `Bearer ${this.config.jwt}`,
+            },
+        });
+        return response.data.IpfsHash;
+    }
+    /**
+     * Function to pin a file from buffer/blob into Pinata Cloud
+     * @param fileBuffer Buffer or Blob containing the file data
+     * @param fileName Name of the file
+     * @returns The IPFS hash of the pinned file
+     */
+    async pinFileFromBuffer(fileBuffer, fileName) {
+        // Ensure FormData is available
+        await loadNodeModules();
+        if (!FormData) {
+            throw new Error('FormData is not available in this environment');
         }
+        const data = new FormData();
+        data.append('file', fileBuffer, fileName);
+        const response = await this.api.post('/pinning/pinFileToIPFS', data, {
+            headers: {
+                'Content-Type': `multipart/form-data${data.getBoundary ? `; boundary=${data.getBoundary()}` : ''}`,
+                Authorization: `Bearer ${this.config.jwt}`,
+            },
+        });
+        return response.data.IpfsHash;
     }
 }

package/dist/utils/index.d.ts

@@ -9,7 +9,7 @@ export type ConvertBigIntToNumber<T> = {
  * 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];
+    [K in keyof T]: T[K] extends bigint ? number : T[K] extends ReadonlyUint8Array ? string | null : T[K];
 };
 /**
  * Helper function to convert bigint values to numbers in an object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/kit",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Nosana KIT",
   "type": "module",
   "main": "dist/index.js",
@@ -24,8 +24,10 @@
   "license": "MIT",
   "dependencies": {
     "@solana-program/token": "^0.5.1",
+    "axios": "^1.6.0",
     "bs58": "^6.0.0",
     "buffer": "^6.0.3",
+    "form-data": "^4.0.0",
     "gill": "^0.9.0"
   },
   "devDependencies": {