@functionland/react-native-fula 1.14.7 → 1.19.0

package/src/protocols/chain-api.ts

@@ -1,7 +1,8 @@
-import { default as EventTypes } from '../interfaces/api-lookup';
+import { default as EventTypes } from '../interfaces/lookup';
 
 import { ApiPromise, WsProvider } from '@polkadot/api';
-//import { Keyring } from '@polkadot/keyring';
+import { Keyring } from '@polkadot/keyring';
+const { cryptoWaitReady } = require('@polkadot/util-crypto');
 import type * as BType from '../types/blockchain';
 
 const types = {
@@ -9,7 +10,7 @@ const types = {
 };
 
 export const init = async (
-  wsAddress: string = 'wss://node3.functionyard.fx.land'
+  wsAddress: string = 'wss://node3.functionyard.fula.network'
 ): Promise<ApiPromise> => {
   const provider = new WsProvider(wsAddress);
   const api = await ApiPromise.create({ types, provider }).catch((err) => {
@@ -23,14 +24,68 @@ export const disconnectApi = async (api: ApiPromise): Promise<void> => {
   await api.disconnect();
 };
 
+/*function addDoubleSlashToSeed(seed: string): string {
+  return seed.startsWith('//') ? seed : '//' + seed;
+}*/
+
 /*
-  createAccount: This function takes a seed and returns am account
+  createManifest: This function batch uploads manifests
 */
-/*export const uploadManifest = async (
+function serialize(obj: any): string {
+  return JSON.stringify(obj);
+}
+
+function createManifest(
+  cids: string[],
+  poolId: number,
+  replicationFactor: number = 4
+): {
+  manifest: string[]; // or string[]
+  cids: string[]; // or string[]
+  poolId: number[];
+  replicationFactor: number[];
+} {
+  const manifest_metadata = cids.map((cid) => ({
+    job: {
+      work: 'Storage',
+      engine: 'IPFS',
+      uri: cid,
+    },
+  }));
+
+  // Serialize manifest_metadata to Uint8Array or string
+  const serializedManifest = manifest_metadata.map((item) => serialize(item)); // Implement `serialize` accordingly
+
+  // Serialize cids to Uint8Array or string
+  const serializedCids = cids.map((cid) => serialize(cid)); // Implement `serialize` accordingly
+
+  // Create arrays for `poolId` and `replicationFactor`
+  const poolIds = new Array(cids.length).fill(poolId);
+  const replicationFactors = new Array(cids.length).fill(replicationFactor);
+
+  const batchUploadManifest = {
+    manifest: serializedManifest,
+    cids: serializedCids,
+    poolId: poolIds,
+    replicationFactor: replicationFactors,
+  };
+
+  return batchUploadManifest;
+}
+
+export const batchUploadManifest = async (
   api: ApiPromise | undefined,
   seed: string,
-  manifest: typeof EventTypes.FunctionlandFulaCall._enum.upload_manifest
-): Promise<BType.ManifestUploadResponse> => {
+  cids_i: string[],
+  poolId_i: number,
+  replicationFactor_i: number = 4
+): Promise<{ hash: string }> => {
+  const { manifest, cids, poolId, replicationFactor } = createManifest(
+    cids_i,
+    poolId_i,
+    replicationFactor_i
+  );
+
   console.log('uploadManifest in react-native started');
   try {
     if (api === undefined) {
@@ -39,27 +94,51 @@ export const disconnectApi = async (api: ApiPromise): Promise<void> => {
 
     // Simple transaction
     const keyring = new Keyring({ type: 'sr25519' });
-    const userKey = keyring.addFromUri(seed, { name: 'account' });
+    const userKey = keyring.addFromUri(seed, { name: 'account' }, 'sr25519');
     console.log(
       `${userKey.meta.name}: has address ${userKey.address} with publicKey [${userKey.publicKey}]`
     );
-    const submitExtrinsic = await api.tx.manifest.upload(manifest);
-    const unsub = await submitExtrinsic
-      .signAndSend(userKey, ({ status, events }) => {
-        if (status.isInBlock || status.isFinalized) {
-          console.log(events);
-          unsub();
-          return Promise.resolve({ success: true });
-        }
-      })
-      .catch((error) => {
-        console.log(':( transaction failed', error);
-        return Promise.reject(error);
-      });
+    if (api?.tx?.fula?.batchUploadManifest) {
+      const submitExtrinsic = api.tx.fula.batchUploadManifest(
+        manifest,
+        cids,
+        poolId,
+        replicationFactor
+      );
+      let unsub: () => void; // Define a variable to hold the unsub function
+
+      if (submitExtrinsic) {
+        return new Promise<{ hash: string }>((resolve, reject) => {
+          submitExtrinsic
+            .signAndSend(userKey, ({ status }) => {
+              if (status.isInBlock || status.isFinalized) {
+                if (unsub) {
+                  unsub(); // Call unsub before resolving the promise
+                }
+                resolve({ hash: status.asInBlock.toString() });
+              }
+            })
+            .then((unsubFn) => {
+              unsub = unsubFn; // Store the unsub function once it becomes available
+            })
+            .catch((error) => {
+              if (unsub) {
+                unsub(); // Call unsub before rejecting the promise
+              }
+              console.log(':( transaction failed', error);
+              reject(error);
+            });
+        });
+      } else {
+        return Promise.reject(new TypeError('submitExtrinsic not constructed'));
+      }
+    } else {
+      return Promise.reject(new TypeError('api not initialized'));
+    }
   } catch (err) {
     return Promise.reject(err);
   }
-};*/
+};
 
 /*
   listPools: This function takes start index and length and returns a promise of an object that contains a list of pools. Each pool in the list contains the poolID, owner, poolName, parent, and participants of the pool
@@ -75,7 +154,7 @@ export const listPools = async (
       api = await init();
     }
     // Type guard to assure TypeScript that api is not undefined
-    if (!api || !api.query || !api.query.pool || !api.query.pool.lastPoolId || !api.query.pool.pools) {
+    if (!api?.query?.pool?.lastPoolId || !api?.query?.pool?.pools) {
       throw new Error('Failed to initialize api or api.query.pool');
     }
     const pools: BType.PoolListResponse = { pools: [] };
@@ -116,7 +195,7 @@ export const checkJoinRequest = async (
       api = await init();
     }
     // Type guard to assure TypeScript that api is not undefined
-    if (!api || !api.query || !api.query.pool || !api.query.pool.poolRequests) {
+    if (!api?.query?.pool?.poolRequests) {
       throw new Error('Failed to initialize api or api.query.pool');
     }
 
@@ -133,3 +212,48 @@ export const checkJoinRequest = async (
     return Promise.reject(err);
   }
 };
+
+function isAccountInfo(obj: any): obj is { data: { free: any } } {
+  return 'data' in obj && 'free' in obj.data;
+}
+/*
+  checkAccountExsists: This function takes accountId and checks if the account exists
+  */
+export const checkAccountBalance = async (
+  api: ApiPromise | undefined,
+  accountId: string
+): Promise<string> => {
+  console.log('checkAcocuntExsists in react-native started');
+  try {
+    if (api === undefined) {
+      api = await init();
+    }
+    // Type guard to assure TypeScript that api is not undefined
+    if (!api?.query?.system?.account) {
+      throw new Error('Failed to initialize api or api.query.account');
+    }
+    let balance: any;
+    let accountInfo = await api.query.system.account(accountId);
+    if (isAccountInfo(accountInfo)) {
+      balance = accountInfo.data.free;
+    }
+
+    if (balance && balance !== '0' && balance > 0) {
+      return Promise.resolve(balance.toHuman());
+    }
+    return Promise.resolve('0');
+  } catch (err) {
+    return Promise.reject(err);
+  }
+};
+
+export const getAccountIdFromSeed = async (seed: string): Promise<string> => {
+  try {
+    await cryptoWaitReady();
+    const keyring = new Keyring({ type: 'sr25519' });
+    const account = keyring.addFromUri(seed, { name: 'account' }, 'sr25519');
+    return Promise.resolve(account.address);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+};