robonomics-interface-vue 0.1.2 → 0.1.3

package/dist/account/index.js

@@ -0,0 +1,3 @@
+export { useAccount } from './useAccount.js';
+export { useBalance } from './useBalance.js';
+export { useSend } from './useSend.js';

package/dist/account/useAccount.js

@@ -0,0 +1,70 @@
+import { ref } from 'vue';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+
+/** @type {import('vue').Ref<string|null>} Current account address */
+const account = ref(null);
+/** @type {import('vue').Ref|null} Current account key pair */
+let pair = ref(null);
+
+/**
+ * @typedef {Object} AccountComposable
+ * @property {import('vue').Ref<string|null>} account - Current account address
+ * @property {import('vue').Ref|null} pair - Current account key pair
+ * @property {Function} setSender - Function for setting sender
+ * @property {Function} setSubscription - Function for setting subscription
+ */
+/**
+ * Vue сomposable for account management
+ * @description Provides functionality for setting transaction sender and subscription
+ * @returns {AccountComposable} Object with methods and properties for working with account
+ * @example
+ * const { account, pair, setSender, setSubscription } = useAccount()
+ *
+ * setSender(keypair, { subscription: 'sub', signer: 'sr25519' })
+ * setSubscription('subscription_id')
+ */
+const useAccount = () => {
+  const { isConnected, instance } = usePolkadotApi();
+
+  /**
+   * Sets transaction sender
+   * @description Sets key pair and subscription for sending transactions
+   * @param {Object} senderPair - Sender key pair
+   * @param {Object} options - Options for setting
+   * @param {string} options.subscription - Subscription ID
+   * @param {string} options.signer - Signing type (e.g., 'sr25519')
+   * @throws {Error} Throws error if not connected to network
+   * @example
+   * setSender(keypair, { subscription: 'sub_id', signer: 'sr25519' })
+   */
+  const setSender = (senderPair, { subscription, signer }) => {
+    if (!isConnected.value) {
+      throw new Error("Not connected");
+    }
+    instance.account.setSender(senderPair, {
+      signer,
+      subscription
+    });
+    account.value = senderPair.address;
+    pair.value = senderPair;
+  };
+
+  /**
+   * Sets subscription for account
+   * @description Sets subscription for working with account
+   * @param {string} subscription - Subscription ID
+   * @throws {Error} Throws error if not connected to network
+   * @example
+   * setSubscription('subscription_id')
+   */
+  const setSubscription = (subscription) => {
+    if (!isConnected.value) {
+      throw new Error("Not connected");
+    }
+    instance.account.useSubscription(subscription);
+  };
+
+  return { account, pair, setSender, setSubscription };
+};
+
+export { useAccount };

package/dist/account/useBalance.js

@@ -0,0 +1,89 @@
+import { account } from 'robonomics-interface';
+import { isRef, ref, watch, onUnmounted } from 'vue';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+
+/**
+ * @typedef {Object} BalanceComposable
+ * @property {import('vue').Ref<number|undefined>} balance - Current account balance
+ * @property {import('vue').Ref<string>} address - Address of tracked account
+ * @property {import('vue').Ref<Error|null>} error - Error when loading balance
+ * @property {Function} unsubscribe - Function for unsubscribing from changes
+ */
+/**
+ * Vue сomposable for tracking account balance
+ * @description Provides reactive account balance with automatic updates when address or connection status changes
+ * @param {string|import('vue').Ref<string>} addressInit - Account address for balance tracking
+ * @param {boolean} [isWatch] - Whether to enable automatic balance change tracking
+ * @returns {BalanceComposable} Object with balance and management methods
+ * @example
+ * const { balance, address, error } = useBalance('5F...', true)
+ *
+ * // With reactive address
+ * const address = ref('5F...')
+ * const { balance } = useBalance(address)
+ */
+function useBalance(addressInit, isWatch = true) {
+  const address = isRef(addressInit) ? addressInit : ref(addressInit);
+  const { isConnected, instance } = usePolkadotApi();
+  /** @type {import('vue').Ref<number|undefined>} Current account balance */
+  const balance = ref(0);
+  /** @type {import('vue').Ref<Error|null>} Error when loading balance */
+  const error = ref(null);
+  /** @type {Function|undefined} Function for unsubscribing from changes */
+  let unsubscriber;
+
+  /**
+   * Unsubscribes from balance changes
+   * @description Clears current subscription and resets unsubscriber
+   */
+  const unsubscribe = () => {
+    if (unsubscriber) {
+      unsubscriber();
+      unsubscriber = undefined;
+    }
+  };
+
+  /**
+   * Loads account balance
+   * @description Loads current balance or subscribes to changes depending on isWatch parameter
+   * @async
+   */
+  const loadBalance = async () => {
+    if (!isConnected.value) return;
+    unsubscribe();
+    try {
+      if (!isWatch) {
+        balance.value = await account.query.getBalance(
+          instance.api,
+          address.value
+        );
+      } else {
+        unsubscriber = await account.query.getBalance(
+          instance.api,
+          address.value,
+          (r) => {
+            balance.value = r;
+          }
+        );
+      }
+      error.value = null;
+    } catch (e) {
+      error.value = e;
+      balance.value = undefined;
+      unsubscriber = undefined;
+    }
+  };
+
+  watch([address, isConnected], loadBalance, { immediate: true });
+
+  onUnmounted(unsubscribe);
+
+  return {
+    balance,
+    address,
+    error,
+    unsubscribe
+  };
+}
+
+export { useBalance };

package/dist/account/useSend.js

@@ -0,0 +1,177 @@
+import { ref } from 'vue';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+import { useAccount } from './useAccount.js';
+
+/**
+ * @typedef {Object} SendComposable
+ * @property {Object} [tx] - Transaction object (if autoCreate = true)
+ * @property {Function} create - Function for creating transaction object
+ * @property {Function} send - Function for sending transaction
+ */
+/**
+ * Vue сomposable for sending transactions
+ * @description Provides functionality for creating and sending transactions in the Polkadot network
+ * @param {Object} options - Composable options
+ * @param {boolean} [options.autoCreate] - Automatically create transaction object
+ * @returns {SendComposable} Object with methods for working with transactions
+ * @example
+ * const { tx, create, send } = useSend({ autoCreate: true })
+ *
+ * // Sending simple transaction
+ * await tx.send(() => api.tx.system.remark('Hello'))
+ *
+ * // Creating custom transaction object
+ * const customTx = create()
+ * await customTx.send(() => api.tx.balances.transfer(address, amount))
+ */
+const useSend = ({ autoCreate = true } = {}) => {
+  const { isConnected, instance } = usePolkadotApi();
+  const { setSender } = useAccount();
+
+  /**
+   * Sends transaction to the network
+   * @description Performs signing and sending of transaction with automatic nonce management and subscription
+   * @param {Object} tx - Transaction object
+   * @param {Function|any} call - Callable function or transaction instance
+   * @param {Object} options - Options for sending
+   * @param {Object} options.pair - Key pair for signing (optional)
+   * @param {string} options.signer - Signing type (optional)
+   * @param {string} options.subscription - Subscription ID (optional)
+   * @returns {Promise<any>} Result of transaction sending
+   * @async
+   * @example
+   * await send(tx, () => api.tx.system.remark('Hello'), {
+   *   pair: keypair,
+   *   signer: 'sr25519'
+   * })
+   */
+  const send = async (tx, call, { pair, signer, subscription }) => {
+    if (!call) {
+      return;
+    }
+
+    tx.start();
+
+    let currentSubscription = false;
+
+    if (!instance.account.pair && !pair) {
+      tx.setError(new Error("Not sender"));
+    } else if (!isConnected.value) {
+      tx.setError(new Error("Not connected"));
+    } else {
+      if (call instanceof Function) {
+        try {
+          if (call.constructor.name === "AsyncFunction") {
+            call = await call();
+          } else {
+            call = call();
+          }
+        } catch (error) {
+          tx.setError(error);
+          tx.setPropcess(false);
+          return;
+        }
+      }
+
+      try {
+        if (pair) {
+          setSender(pair, { subscription, signer });
+        } else if (
+          subscription &&
+          subscription !== instance.account.subscription
+        ) {
+          currentSubscription = instance.account.subscription;
+          instance.account.useSubscription(subscription);
+        }
+        const nonce = await instance.api.rpc.system.accountNextIndex(
+          instance.account.pair.address
+        );
+        tx.result.value = await instance.account.signAndSend(call, {
+          nonce
+        });
+        // console.log("tx", tx.result.value.block, tx.result.value.tx);
+      } catch (e) {
+        tx.setError(e);
+      }
+    }
+
+    tx.setPropcess(false);
+
+    if (subscription && currentSubscription !== false) {
+      instance.account.useSubscription(currentSubscription);
+    }
+
+    return tx.result;
+  };
+
+  /**
+   * @typedef {Object} Tx
+   * @property {import('vue').Ref<string|null>} error - Transaction error
+   * @property {import('vue').Ref<boolean|null>} process - Processing status
+   * @property {import('vue').Ref<any>} result - Transaction result
+   * @property {Function} send - Function for sending transaction
+   * @property {Function} start - Function for starting transaction
+   * @property {Function} setPropcess - Function for setting processing status
+   * @property {Function} setError - Function for setting error
+   */
+  /**
+   * Creates transaction object
+   * @description Creates new transaction object with methods for state management
+   * @returns {Tx} Transaction object with management methods
+   * @example
+   * const tx = create()
+   * tx.start()
+   * await tx.send(() => api.tx.system.remark('Hello'))
+   */
+  const create = () => {
+    const tx = {
+      /** @type {import('vue').Ref<string|null>} Transaction error */
+      error: ref(null),
+      /** @type {import('vue').Ref<boolean|null>} Transaction processing status */
+      process: ref(null),
+      /** @type {import('vue').Ref<any>} Transaction result */
+      result: ref(false),
+      /**
+       * Sends transaction
+       * @param {Function|any} call - Callable function or transaction instance
+       * @param {Object} options - Options for sending
+       * @returns {Promise<any>} Result of sending
+       */
+      send: (call, options = {}) => {
+        return send(tx, call, options);
+      },
+      /**
+       * Starts transaction
+       * @description Resets transaction state and sets processing flag
+       */
+      start: () => {
+        tx.result.value = null;
+        tx.error.value = null;
+        tx.process.value = true;
+      },
+      /**
+       * Sets transaction processing status
+       * @param {boolean} process - New processing status
+       */
+      setPropcess: (process) => {
+        tx.process.value = process;
+      },
+      /**
+       * Sets transaction error
+       * @param {Error} e - Error object
+       */
+      setError: (e) => {
+        tx.error.value = e.message;
+        tx.process.value = false;
+      }
+    };
+    return tx;
+  };
+
+  if (autoCreate) {
+    return { tx: create(), create, send };
+  }
+  return { create, send };
+};
+
+export { useSend };

package/dist/datalog/index.js

@@ -0,0 +1,3 @@
+export { useAction } from './useAction.js';
+export { useDatalog } from './useDatalog.js';
+export { useQuery } from './useQuery.js';

package/dist/datalog/useAction.js

@@ -0,0 +1,38 @@
+import { datalog } from 'robonomics-interface';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+
+/**
+ * @typedef {Object} DatalogActionComposable
+ * @property {Function} write - Function for writing data to datalog
+ */
+/**
+ * Vue сomposable for performing datalog actions
+ * @description Provides functions for writing data to datalog
+ * @returns {DatalogActionComposable} Object with methods for working with datalog
+ * @example
+ * const { write } = useAction()
+ *
+ * // Writing data to datalog
+ * const tx = write('Hello World')
+ * await tx.signAndSend(keypair)
+ */
+function useAction() {
+  const { instance, composeWithCheckConnection } = usePolkadotApi();
+
+  /**
+   * Creates transaction for writing data to datalog
+   * @description Creates transaction instance for writing data to datalog
+   * @param {string} data - Data to write to datalog
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = write('Sensor data: 25.5°C')
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const write = (data) => {
+    return datalog.action.write(instance.api, data);
+  };
+
+  return { write: composeWithCheckConnection(write) };
+}
+
+export { useAction };

package/dist/datalog/useDatalog.js

@@ -0,0 +1,60 @@
+import { tools } from 'robonomics-interface';
+import { isRef, ref, watch, onUnmounted, toRefs } from 'vue';
+import { useLoader } from '../tools/useLoader.js';
+import { useQuery } from './useQuery.js';
+
+/**
+ * @typedef {Object} DatalogComposable
+ * @property {import('vue').Ref<any>} data - Datalog data
+ * @property {import('vue').Ref<boolean>} loading - Loading status
+ * @property {import('vue').Ref<Error|null>} error - Loading error
+ * @property {Function} load - Function for forced data loading
+ */
+/**
+ * Vue сomposable for working with datalog
+ * @description Provides functionality for loading and tracking changes in datalog with automatic subscription management
+ * @param {string|import('vue').Ref<string>} addressInit - Datalog address for tracking
+ * @param {Object} options - Composable options
+ * @param {boolean} [options.immediate] - Whether to start loading immediately
+ * @returns {DatalogComposable} Object with datalog state and management methods
+ * @example
+ * const { data, loading, error, load } = useDatalog('5F...', { immediate: true })
+ *
+ * // With reactive address
+ * const address = ref('5F...')
+ * const { data } = useDatalog(address)
+ */
+function useDatalog(addressInit, { immediate = true } = {}) {
+  const address = isRef(addressInit) ? addressInit : ref(addressInit);
+  const { loader, setter, state } = useLoader();
+  const { load, listen } = useQuery();
+  const watcher = tools.createWatcher();
+
+  /**
+   * Starts the process of loading and subscribing to changes
+   * @description Stops previous subscription, loads data and subscribes to new changes
+   */
+  const run = () => {
+    loader(async () => {
+      watcher.stop();
+      const data = await load(address.value);
+      setter(data);
+      const unsubscribe = await listen(address.value, (newData) => {
+        data.push(newData);
+        setter([...data]);
+      });
+      watcher.set(unsubscribe);
+    });
+  };
+
+  watch(address, run, { immediate });
+
+  onUnmounted(watcher.stop);
+
+  return {
+    ...toRefs(state),
+    load: run
+  };
+}
+
+export { useDatalog };

package/dist/datalog/useQuery.js

@@ -0,0 +1,95 @@
+import { encodeAddress } from '@polkadot/util-crypto';
+import { tools, datalog } from 'robonomics-interface';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+
+/**
+ * @typedef {Object} DatalogQueryComposable
+ * @property {Function} load - Function for loading data from datalog
+ * @property {Function} listen - Function for subscribing to datalog events
+ */
+/**
+ * Vue сomposable for datalog queries
+ * @description Provides functions for loading data from datalog and subscribing to events
+ * @returns {DatalogQueryComposable} Object with methods for working with datalog
+ * @example
+ * const { load, listen } = useQuery()
+ *
+ * // Loading data
+ * const data = await load('5F...')
+ *
+ * // Subscribing to events
+ * const unsubscribe = await listen('5F...', (newData) => {
+ *   console.log('New datalog entry:', newData)
+ * })
+ */
+function useQuery() {
+  const { instance, composeWithCheckConnection } = usePolkadotApi();
+
+  /**
+   * Converts raw data to human-readable format
+   * @description Converts block and data to human-readable format
+   * @param {Array} raw - Raw data [block, data]
+   * @returns {Array} Converted data [blockNumber, humanReadableData]
+   * @example
+   * const humanData = toHuman([12345, '0x1234...'])
+   * // Result: [12345, 'decoded data']
+   */
+  const toHuman = (raw) => {
+    return [raw[0].toNumber(), raw[1].toHuman()];
+  };
+
+  /**
+   * Loads data from datalog by address
+   * @description Loads all datalog entries for specified address
+   * @param {string} address - Datalog address for loading
+   * @returns {Promise<Array>} Array of datalog entries in human-readable format
+   * @async
+   * @example
+   * const data = await load('5F...')
+   * // Result: [[12345, 'data1'], [12346, 'data2']]
+   */
+  const load = async (address) => {
+    const data = await datalog.query.read(instance.api, address);
+    return data.map(toHuman);
+  };
+
+  /**
+   * Subscribes to datalog events for specified address
+   * @description Creates subscription to datalog events and filters them by address
+   * @param {string} address - Datalog address for tracking
+   * @param {Function} cb - Callback function for processing new data
+   * @returns {Promise<Function>} Function for unsubscribing
+   * @async
+   * @example
+   * const unsubscribe = await listen('5F...', (newData) => {
+   *   console.log('New entry:', newData)
+   * })
+   *
+   * // Unsubscribe
+   * unsubscribe()
+   */
+  const listen = async (address, cb) => {
+    return await tools.events.on(instance.api, { section: "datalog" }, (r) => {
+      r = address
+        ? r.filter(
+            (item) => encodeAddress(item.data[0]) === encodeAddress(address)
+          )
+        : r;
+      if (r.length) {
+        for (const item of r) {
+          cb({
+            sender: encodeAddress(item.data[0]),
+            data: toHuman([item.data[1], item.data[2]])
+          });
+        }
+      }
+    });
+  };
+
+  return {
+    load: composeWithCheckConnection(load),
+    listen: composeWithCheckConnection(listen)
+  };
+}
+
+export { useQuery };

package/dist/devices/index.js

@@ -0,0 +1,3 @@
+export { useAction } from './useAction.js';
+export { useDevices } from './useDevices.js';
+export { useQuery } from './useQuery.js';

package/dist/devices/useAction.js

@@ -0,0 +1,119 @@
+import { devices } from 'robonomics-interface';
+import { usePolkadotApi } from '../usePolkadotApi.js';
+
+/**
+ * @typedef {Object} DevicesActionComposable
+ * @property {Function} add - Function for adding new devices
+ * @property {Function} remove - Function for removing devices
+ * @property {Function} replace - Function for replacing devices
+ * @property {Function} replaceAll - Function for completely replacing devices list
+ * @property {Function} clear - Function for clearing devices list
+ */
+/**
+ * Vue сomposable for performing device actions
+ * @description Provides functions for managing devices list (adding, removing, replacing)
+ * @returns {DevicesActionComposable} Object with methods for working with devices
+ * @example
+ * const { add, remove, replace, replaceAll, clear } = useAction()
+ *
+ * // Adding devices
+ * const tx = add(['5F...'], ['5F...', '5F...'])
+ * await tx.signAndSend(keypair)
+ *
+ * // Removing devices
+ * const tx = remove(['5F...', '5F...'], ['5F...'])
+ * await tx.signAndSend(keypair)
+ */
+function useAction() {
+  const { composeWithCheckConnection, instance } = usePolkadotApi();
+
+  /**
+   * Adds new devices to existing list
+   * @description Creates transaction for adding new device addresses to current list
+   * @param {Array<string>} current - Current list of device addresses
+   * @param {Array<string>} newAddresses - New device addresses to add
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = add(['5F...'], ['5F...', '5F...'])
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const add = (current, newAddresses) => {
+    return devices.action.setDevices(
+      instance.api,
+      devices.tools.add(current, newAddresses)
+    );
+  };
+
+  /**
+   * Removes devices from existing list
+   * @description Creates transaction for removing specified device addresses from current list
+   * @param {Array<string>} current - Current list of device addresses
+   * @param {Array<string>} addresses - Device addresses to remove
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = remove(['5F...', '5F...'], ['5F...'])
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const remove = (current, addresses) => {
+    return devices.action.setDevices(
+      instance.api,
+      devices.tools.remove(current, addresses)
+    );
+  };
+
+  /**
+   * Replaces devices in existing list
+   * @description Creates transaction for replacing specified device addresses with new ones
+   * @param {Array<string>} current - Current list of device addresses
+   * @param {Array<string>} removeAddresses - Device addresses to remove
+   * @param {Array<string>} newAddresses - New device addresses to add
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = replace(['5F...', '5F...'], ['5F...'], ['5F...'])
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const replace = (current, removeAddresses, newAddresses) => {
+    return devices.action.setDevices(
+      instance.api,
+      devices.tools.replace(current, removeAddresses, newAddresses)
+    );
+  };
+
+  /**
+   * Completely replaces devices list
+   * @description Creates transaction for completely replacing current devices list with new one
+   * @param {Array<string>} addresses - New list of device addresses
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = replaceAll(['5F...', '5F...', '5F...'])
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const replaceAll = (addresses) => {
+    return devices.action.setDevices(
+      instance.api,
+      devices.tools.replaceAll(addresses)
+    );
+  };
+
+  /**
+   * Clears devices list
+   * @description Creates transaction for completely clearing devices list
+   * @returns {Object} Transaction instance for signing and sending
+   * @example
+   * const tx = clear()
+   * await tx.signAndSend(keypair, { nonce })
+   */
+  const clear = () => {
+    return devices.action.setDevices(instance.api, devices.tools.clear());
+  };
+
+  return {
+    add: composeWithCheckConnection(add),
+    remove: composeWithCheckConnection(remove),
+    replace: composeWithCheckConnection(replace),
+    replaceAll: composeWithCheckConnection(replaceAll),
+    clear: composeWithCheckConnection(clear)
+  };
+}
+
+export { useAction };