@polkadot-api/substrate-client 0.2.2 → 0.4.0

package/dist/index.d.ts

@@ -1,6 +1,13 @@
+export { AbortError } from '@polkadot-api/utils';
 import { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
 export * from '@polkadot-api/json-rpc-provider';
-export { AbortError } from '@polkadot-api/utils';
+
+type UnsubscribeFn = () => void;
+type WithAbortSignal<T extends Array<any>> = [
+    ...args: T,
+    abortSignal?: AbortSignal
+];
+type AbortablePromiseFn<A extends Array<any>, T> = (...args: WithAbortSignal<A>) => Promise<T>;
 
 interface IRpcError {
     code: number;
@@ -13,13 +20,6 @@ declare class RpcError extends Error implements IRpcError {
     constructor(e: IRpcError);
 }
 
-type UnsubscribeFn = () => void;
-type WithAbortSignal<T extends Array<any>> = [
-    ...args: T,
-    abortSignal?: AbortSignal
-];
-type AbortablePromiseFn<A extends Array<any>, T> = (...args: WithAbortSignal<A>) => Promise<T>;
-
 interface Subscriber<T> {
     next: (data: T) => void;
     error: (e: Error) => void;
@@ -40,6 +40,10 @@ declare class DestroyedError extends Error {
     constructor();
 }
 
+type Transaction = (tx: string, error: (e: Error) => void) => UnsubscribeFn;
+
+declare const getTransaction: (request: ClientRequest<string, any>) => (tx: string, error: (e: Error) => void) => () => void;
+
 type FollowInnerSubscriptionCb<T> = (subscriptionId: string, cb: Subscriber<T>) => UnsubscribeFn;
 type ClientInnerRequestCb<T, TT> = {
     onSuccess: (result: T, followSubscription: FollowInnerSubscriptionCb<TT>) => void;
@@ -212,10 +216,6 @@ type OperationEventsRpc = OperationBodyDoneRpc | OperationCallDoneRpc | Operatio
 type FollowEventRpc = FollowEventWithRuntimeRpc | FollowEventWithoutRuntimeRpc | OperationEventsRpc | StopRpc;
 declare function getChainHead(request: ClientRequest<string, FollowEventRpc>): ChainHead;
 
-type Transaction = (tx: string, error: (e: Error) => void) => UnsubscribeFn;
-
-declare const getTransaction: (request: ClientRequest<string, any>) => (tx: string, error: (e: Error) => void) => () => void;
-
 interface ChainSpecData {
     name: string;
     genesisHash: string;
@@ -223,7 +223,37 @@ interface ChainSpecData {
 }
 declare const createGetChainSpec: (clientRequest: ClientRequest<any, any>) => () => Promise<ChainSpecData>;
 
+type ArchiveStorageItemInput = StorageItemInput & {
+    paginationStartKey?: string;
+};
+interface Archive {
+    body: AbortablePromiseFn<[hash: string], Array<string>>;
+    call: AbortablePromiseFn<[
+        hash: string,
+        fnName: string,
+        callParameters: string
+    ], string>;
+    header: AbortablePromiseFn<[hash: string], string>;
+    finalizedHeight: AbortablePromiseFn<[], number>;
+    hashByHeight: AbortablePromiseFn<[height: number], string[]>;
+    storage: <Type extends StorageItemInput["type"]>(hash: string, type: Type, key: string, childTrie: string | null, abortSignal?: AbortSignal | undefined) => Promise<StorageResult<Type>>;
+    storageSubscription: (hash: string, inputs: Array<ArchiveStorageItemInput>, childTrie: string | null, onItem: (item: StorageItemResponse) => void, onError: (e: Error) => void, onDone: () => void) => () => void;
+}
+
+declare class BlockHashNotFoundError extends Error {
+    constructor(hash: string);
+}
+declare class StorageError extends Error {
+    constructor(message: string);
+}
+declare class CallError extends Error {
+    constructor(message: string);
+}
+
+declare const getArchive: (request: ClientRequest<any, any>) => Archive;
+
 interface SubstrateClient {
+    archive: Archive;
     chainHead: ChainHead;
     transaction: Transaction;
     destroy: UnsubscribeFn;
@@ -233,4 +263,5 @@ interface SubstrateClient {
 }
 declare const createClient: (provider: JsonRpcProvider) => SubstrateClient;
 
-export { type AbortablePromiseFn, type BestBlockChanged, type ChainHead, type ChainSpecData, type Client, type ClientInnerRequest, type ClientInnerRequestCb, type ClientRequest, type ClientRequestCb, DestroyedError, DisjointError, type Finalized, type FollowEventWithRuntime, type FollowEventWithoutRuntime, type FollowInnerSubscriptionCb, type FollowResponse, type FollowSubscriptionCb, type IRpcError, type Initialized, type InitializedWithRuntime$1 as InitializedWithRuntime, type NewBlock, type NewBlockWithRuntime$1 as NewBlockWithRuntime, OperationError, OperationInaccessibleError, OperationLimitError, RpcError, type Runtime, StopError, type StorageItemInput, type StorageItemResponse, type StorageResult, type SubstrateClient, type Transaction, type UnsubscribeFn, createClient, createGetChainSpec, getChainHead, getTransaction };
+export { BlockHashNotFoundError, CallError, DestroyedError, DisjointError, OperationError, OperationInaccessibleError, OperationLimitError, RpcError, StopError, StorageError, createClient, createGetChainSpec, getArchive, getChainHead, getTransaction };
+export type { AbortablePromiseFn, Archive, ArchiveStorageItemInput, BestBlockChanged, ChainHead, ChainSpecData, Client, ClientInnerRequest, ClientInnerRequestCb, ClientRequest, ClientRequestCb, Finalized, FollowEventWithRuntime, FollowEventWithoutRuntime, FollowInnerSubscriptionCb, FollowResponse, FollowSubscriptionCb, IRpcError, Initialized, InitializedWithRuntime$1 as InitializedWithRuntime, NewBlock, NewBlockWithRuntime$1 as NewBlockWithRuntime, Runtime, StorageItemInput, StorageItemResponse, StorageResult, SubstrateClient, Transaction, UnsubscribeFn };

package/dist/index.js

@@ -2,6 +2,20 @@
 
 var utils = require('@polkadot-api/utils');
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class RpcError extends Error {
+  constructor(e) {
+    super(e.message);
+    __publicField(this, "code");
+    __publicField(this, "data");
+    this.code = e.code;
+    this.data = e.data;
+    this.name = "RpcError";
+  }
+}
+
 const abortablePromiseFn = (fn) => (...args) => new Promise((res, rej) => {
   let cancel = utils.noop;
   const [actualArgs, abortSignal] = args[args.length - 1] instanceof AbortSignal ? [args.slice(0, args.length - 1), args[args.length - 1]] : [args];
@@ -63,49 +77,81 @@ const getSubscriptionsManager = () => {
   };
 };
 
-const chainHead = {
-  body: "",
-  call: "",
-  continue: "",
-  follow: "",
-  header: "",
-  stopOperation: "",
-  storage: "",
-  unfollow: "",
-  unpin: "",
-  followEvent: ""
-};
-const chainSpec = {
-  chainName: "",
-  genesisHash: "",
-  properties: ""
-};
-const transaction = {
-  broadcast: "",
-  stop: ""
-};
-Object.entries({ chainHead, chainSpec, transaction }).forEach(
-  ([fnGroupName, methods]) => {
-    Object.keys(methods).forEach((methodName) => {
-      methods[methodName] = `${fnGroupName}_v1_${methodName}`;
-    });
+class DestroyedError extends Error {
+  constructor() {
+    super("Client destroyed");
+    this.name = "DestroyedError";
   }
-);
+}
 
-const getTransaction = (request) => (tx, error) => {
-  let cancel = request(transaction.broadcast, [tx], {
-    onSuccess: (subscriptionId) => {
-      cancel = subscriptionId === null ? noop : () => {
-        request(transaction.stop, [subscriptionId]);
-      };
-      if (subscriptionId === null) {
-        error(new Error("Max # of broadcasted transactions has been reached"));
+let nextClientId = 1;
+const createClient$1 = (gProvider) => {
+  let clientId = nextClientId++;
+  const responses = /* @__PURE__ */ new Map();
+  const subscriptions = getSubscriptionsManager();
+  let connection = null;
+  const send = (id, method, params) => {
+    connection.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      })
+    );
+  };
+  function onMessage(message) {
+    try {
+      let id, result, error, params, subscription;
+      const parsed = JSON.parse(message);
+      ({ id, result, error, params } = parsed);
+      if (id) {
+        const cb = responses.get(id);
+        if (!cb) return;
+        responses.delete(id);
+        return error ? cb.onError(new RpcError(error)) : cb.onSuccess(result, (opaqueId, subscriber) => {
+          const subscriptionId2 = opaqueId;
+          subscriptions.subscribe(subscriptionId2, subscriber);
+          return () => {
+            subscriptions.unsubscribe(subscriptionId2);
+          };
+        });
       }
-    },
-    onError: error
-  });
-  return () => {
-    cancel();
+      ;
+      ({ subscription, result, error } = params);
+      if (!subscription || !error && !Object.hasOwn(params, "result")) throw 0;
+      const subscriptionId = subscription;
+      if (error) {
+        subscriptions.error(subscriptionId, new RpcError(error));
+      } else {
+        subscriptions.next(subscriptionId, result);
+      }
+    } catch (e) {
+      console.warn("Error parsing incomming message: " + message);
+      console.error(e);
+    }
+  }
+  connection = gProvider(onMessage);
+  const disconnect = () => {
+    connection?.disconnect();
+    connection = null;
+    subscriptions.errorAll(new DestroyedError());
+    responses.forEach((r) => r.onError(new DestroyedError()));
+    responses.clear();
+  };
+  let nextId = 1;
+  const request = (method, params, cb) => {
+    if (!connection) throw new Error("Not connected");
+    const id = `${clientId}-${nextId++}`;
+    if (cb) responses.set(id, cb);
+    send(id, method, params);
+    return () => {
+      responses.delete(id);
+    };
+  };
+  return {
+    request,
+    disconnect
   };
 };
 
@@ -140,6 +186,35 @@ class OperationInaccessibleError extends Error {
   }
 }
 
+const chainHead = {
+  body: "",
+  call: "",
+  continue: "",
+  follow: "",
+  header: "",
+  stopOperation: "",
+  storage: "",
+  unfollow: "",
+  unpin: "",
+  followEvent: ""
+};
+const chainSpec = {
+  chainName: "",
+  genesisHash: "",
+  properties: ""
+};
+const transaction = {
+  broadcast: "",
+  stop: ""
+};
+Object.entries({ chainHead, chainSpec, transaction }).forEach(
+  ([fnGroupName, methods]) => {
+    Object.keys(methods).forEach((methodName) => {
+      methods[methodName] = `${fnGroupName}_v1_${methodName}`;
+    });
+  }
+);
+
 const createOperationPromise = (operationName, factory) => (request) => abortablePromiseFn((res, rej, ...args) => {
   let isRunning = true;
   let cancel = () => {
@@ -218,7 +293,7 @@ const createHeaderFn = (request) => (hash) => new Promise((res, rej) => {
   });
 });
 
-const createStorageCb = (request) => (hash, inputs, childTrie, onItems, onError, onDone, onDiscardedItems) => {
+const createStorageCb$1 = (request) => (hash, inputs, childTrie, onItems, onError, onDone, onDiscardedItems) => {
   if (inputs.length === 0) {
     onDone();
     return utils.noop;
@@ -284,8 +359,8 @@ const createStorageCb = (request) => (hash, inputs, childTrie, onItems, onError,
   };
 };
 
-const createStorageFn = (request) => {
-  const cbStore = createStorageCb(request);
+const createStorageFn$1 = (request) => {
+  const cbStore = createStorageCb$1(request);
   return abortablePromiseFn((resolve, reject, hash, type, key, childTrie) => {
     const isDescendants = type.startsWith("descendants");
     let result = isDescendants ? [] : null;
@@ -327,13 +402,6 @@ const createUnpinFn = (request) => (hashes) => hashes.length > 0 ? new Promise((
   });
 }) : Promise.resolve();
 
-class DestroyedError extends Error {
-  constructor() {
-    super("Client destroyed");
-    this.name = "DestroyedError";
-  }
-}
-
 function isOperationEvent(event) {
   return event.operationId !== void 0;
 }
@@ -455,96 +523,164 @@ function getChainHead(request) {
       body: createBodyFn(fRequest),
       call: createCallFn(fRequest),
       header: createHeaderFn(fRequest),
-      storage: createStorageFn(fRequest),
-      storageSubscription: createStorageCb(fRequest),
+      storage: createStorageFn$1(fRequest),
+      storageSubscription: createStorageCb$1(fRequest),
       unpin: createUnpinFn(fRequest),
       _request: fRequest
     };
   };
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class RpcError extends Error {
-  constructor(e) {
-    super(e.message);
-    __publicField(this, "code");
-    __publicField(this, "data");
-    this.code = e.code;
-    this.data = e.data;
-    this.name = "RpcError";
+class BlockHashNotFoundError extends Error {
+  constructor(hash) {
+    super(`Invalid BlockHash: ${hash}`);
+    this.name = "BlockHashNotFoundError";
+  }
+}
+class StorageError extends Error {
+  constructor(message) {
+    super(`Storage Error: ${message}`);
+    this.name = "StorageError";
+  }
+}
+class CallError extends Error {
+  constructor(message) {
+    super(`Call Error: ${message}`);
+    this.name = "CallError";
   }
 }
 
-let nextClientId = 1;
-const createClient$1 = (gProvider) => {
-  let clientId = nextClientId++;
-  const responses = /* @__PURE__ */ new Map();
-  const subscriptions = getSubscriptionsManager();
-  let connection = null;
-  const send = (id, method, params) => {
-    connection.send(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        id,
-        method,
-        params
-      })
-    );
-  };
-  function onMessage(message) {
-    try {
-      let id, result, error, params, subscription;
-      const parsed = JSON.parse(message);
-      ({ id, result, error, params } = parsed);
-      if (id) {
-        const cb = responses.get(id);
-        if (!cb) return;
-        responses.delete(id);
-        return error ? cb.onError(new RpcError(error)) : cb.onSuccess(result, (opaqueId, subscriber) => {
-          const subscriptionId2 = opaqueId;
-          subscriptions.subscribe(subscriptionId2, subscriber);
-          return () => {
-            subscriptions.unsubscribe(subscriptionId2);
-          };
-        });
-      }
-      ;
-      ({ subscription, result, error } = params);
-      if (!subscription || !error && !Object.hasOwn(params, "result")) throw 0;
-      const subscriptionId = subscription;
-      if (error) {
-        subscriptions.error(subscriptionId, new RpcError(error));
-      } else {
-        subscriptions.next(subscriptionId, result);
-      }
-    } catch (e) {
-      console.warn("Error parsing incomming message: " + message);
-      console.error(e);
-    }
+const createStorageCb = (archiveRequest) => (hash, inputs, childTrie, onItem, onError, onDone) => {
+  if (inputs.length === 0) {
+    onDone();
+    return utils.noop;
   }
-  connection = gProvider(onMessage);
-  const disconnect = () => {
-    connection?.disconnect();
-    connection = null;
-    subscriptions.errorAll(new DestroyedError());
-    responses.forEach((r) => r.onError(new DestroyedError()));
-    responses.clear();
+  let isRunning = true;
+  let cancel = () => {
+    isRunning = false;
   };
-  let nextId = 1;
-  const request = (method, params, cb) => {
-    if (!connection) throw new Error("Not connected");
-    const id = `${clientId}-${nextId++}`;
-    if (cb) responses.set(id, cb);
-    send(id, method, params);
-    return () => {
-      responses.delete(id);
-    };
+  archiveRequest("storage", [hash, inputs, childTrie], {
+    onSuccess: (operationId, followSubscription) => {
+      const stopOperation = () => {
+        archiveRequest("stopStorage", [operationId]);
+      };
+      if (!isRunning) return stopOperation();
+      const doneListening = followSubscription(operationId, {
+        next: (event) => {
+          const { event: type } = event;
+          if (type === "storage") {
+            const { event: _, ...item } = event;
+            onItem(item);
+          } else if (type === "storageDone") _onDone();
+          else _onError(new StorageError(event.error));
+        },
+        error: onError
+      });
+      const tearDown = () => {
+        cancel = utils.noop;
+        doneListening();
+      };
+      cancel = () => {
+        tearDown();
+        stopOperation();
+      };
+      const _onError = (e) => {
+        tearDown();
+        onError(e);
+      };
+      const _onDone = () => {
+        tearDown();
+        onDone();
+      };
+    },
+    onError
+  });
+  return () => {
+    cancel();
   };
+};
+
+const createStorageFn = (cbStore) => abortablePromiseFn((resolve, reject, hash, type, key, childTrie) => {
+  const isDescendants = type.startsWith("descendants");
+  let result = isDescendants ? [] : null;
+  const onItem = isDescendants ? result.push.bind(result) : ({ [type]: res }) => {
+    result = res;
+  };
+  return cbStore(
+    hash,
+    [{ key, type }],
+    childTrie,
+    onItem,
+    (e) => {
+      reject(e);
+      result = null;
+    },
+    () => {
+      resolve(result);
+      result = null;
+    }
+  );
+});
+
+const identity = () => (x) => x;
+const handleInvalidBlockHash = () => (result, hash) => {
+  if (result === null) throw new BlockHashNotFoundError(hash);
+  return result;
+};
+const getArchive = (request) => {
+  const archiveRequest = (method, ...rest) => request(`archive_v1_${method}`, ...rest);
+  const fnCreator = (method) => (mapper) => abortablePromiseFn(
+    (res, rej, ...args) => archiveRequest(method, args, {
+      onSuccess: (x) => {
+        try {
+          res(mapper(x, ...args));
+        } catch (e) {
+          rej(e);
+        }
+      },
+      onError: rej
+    })
+  );
+  const header = fnCreator("header")(
+    handleInvalidBlockHash()
+  );
+  const body = fnCreator("body")(
+    handleInvalidBlockHash()
+  );
+  const storageSubscription = createStorageCb(archiveRequest);
+  const storage = createStorageFn(storageSubscription);
+  const call = fnCreator("call")((x, hash) => {
+    if (!x) throw new BlockHashNotFoundError(hash);
+    if (!x.success) throw new CallError(x.error);
+    return x.value;
+  });
+  const finalizedHeight = fnCreator("finalizedHeight")(identity());
+  const hashByHeight = fnCreator("hashByHeight")(identity());
   return {
-    request,
-    disconnect
+    header,
+    body,
+    storageSubscription,
+    storage,
+    call,
+    finalizedHeight,
+    hashByHeight
+  };
+};
+
+const getTransaction = (request) => (tx, error) => {
+  let cancel = request(transaction.broadcast, [tx], {
+    onSuccess: (subscriptionId) => {
+      cancel = subscriptionId === null ? noop : () => {
+        request(transaction.stop, [subscriptionId]);
+      };
+      if (subscriptionId === null) {
+        error(new Error("Max # of broadcasted transactions has been reached"));
+      }
+    },
+    onError: error
+  });
+  return () => {
+    cancel();
   };
 };
 
@@ -567,24 +703,44 @@ const createGetChainSpec = (clientRequest) => {
   };
 };
 
+const clientCache = /* @__PURE__ */ new Map();
 const createClient = (provider) => {
+  const cached = clientCache.get(provider);
+  if (cached) {
+    cached.refCount++;
+    return cached.client;
+  }
   const { request, disconnect } = createClient$1(provider);
-  return {
+  const destroy = () => {
+    const cached2 = clientCache.get(provider);
+    if (!cached2 || cached2.refCount <= 1) {
+      clientCache.delete(provider);
+      disconnect();
+    } else {
+      cached2.refCount--;
+    }
+  };
+  const client = {
+    archive: getArchive(request),
     chainHead: getChainHead(request),
     transaction: getTransaction(request),
     getChainSpecData: createGetChainSpec(request),
-    destroy: disconnect,
+    destroy,
     request: abortablePromiseFn(
       (onSuccess, onError, method, params) => request(method, params, { onSuccess, onError })
     ),
     _request: request
   };
+  clientCache.set(provider, { client, refCount: 1 });
+  return client;
 };
 
 Object.defineProperty(exports, "AbortError", {
   enumerable: true,
   get: function () { return utils.AbortError; }
 });
+exports.BlockHashNotFoundError = BlockHashNotFoundError;
+exports.CallError = CallError;
 exports.DestroyedError = DestroyedError;
 exports.DisjointError = DisjointError;
 exports.OperationError = OperationError;
@@ -592,5 +748,6 @@ exports.OperationInaccessibleError = OperationInaccessibleError;
 exports.OperationLimitError = OperationLimitError;
 exports.RpcError = RpcError;
 exports.StopError = StopError;
+exports.StorageError = StorageError;
 exports.createClient = createClient;
 //# sourceMappingURL=index.js.map