@polkadot-api/substrate-client 0.0.2 → 0.1.1

package/dist/index.d.mts

@@ -23,7 +23,7 @@ interface Subscriber<T> {
     error: (e: Error) => void;
 }
 
-type FollowSubscriptionCb<T> = (methodName: string, subscriptionId: string, cb: Subscriber<T>) => UnsubscribeFn;
+type FollowSubscriptionCb<T> = (subscriptionId: string, cb: Subscriber<T>) => UnsubscribeFn;
 type ClientRequestCb<T, TT> = {
     onSuccess: (result: T, followSubscription: FollowSubscriptionCb<TT>) => void;
     onError: (e: Error) => void;
@@ -215,15 +215,23 @@ declare function getChainHead(request: ClientRequest<string, FollowEventRpc>): C
 
 type Transaction = (tx: string, error: (e: Error) => void) => UnsubscribeFn;
 
-declare const getTransaction: (request: ClientRequest<string, any>, rpcMethods: Promise<Set<string>> | Set<string>) => (tx: string, error: (e: Error) => void) => () => void;
+declare const getTransaction: (request: ClientRequest<string, any>) => (tx: string, error: (e: Error) => void) => () => void;
+
+interface ChainSpecData {
+    name: string;
+    genesisHash: string;
+    properties: any;
+}
+declare const createGetChainSpec: (clientRequest: ClientRequest<any, any>) => () => Promise<ChainSpecData>;
 
 interface SubstrateClient {
     chainHead: ChainHead;
     transaction: Transaction;
     destroy: UnsubscribeFn;
+    getChainSpecData: () => Promise<ChainSpecData>;
     request: <T>(method: string, params: any[], abortSignal?: AbortSignal) => Promise<T>;
     _request: <Reply, Notification>(method: string, params: any[], cb?: ClientRequestCb<Reply, Notification>) => UnsubscribeFn;
 }
 declare const createClient: (provider: JsonRpcProvider) => SubstrateClient;
 
-export { type AbortablePromiseFn, type BestBlockChanged, type ChainHead, 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, getChainHead, getTransaction };
+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 };

package/dist/index.d.ts

@@ -23,7 +23,7 @@ interface Subscriber<T> {
     error: (e: Error) => void;
 }
 
-type FollowSubscriptionCb<T> = (methodName: string, subscriptionId: string, cb: Subscriber<T>) => UnsubscribeFn;
+type FollowSubscriptionCb<T> = (subscriptionId: string, cb: Subscriber<T>) => UnsubscribeFn;
 type ClientRequestCb<T, TT> = {
     onSuccess: (result: T, followSubscription: FollowSubscriptionCb<TT>) => void;
     onError: (e: Error) => void;
@@ -215,15 +215,23 @@ declare function getChainHead(request: ClientRequest<string, FollowEventRpc>): C
 
 type Transaction = (tx: string, error: (e: Error) => void) => UnsubscribeFn;
 
-declare const getTransaction: (request: ClientRequest<string, any>, rpcMethods: Promise<Set<string>> | Set<string>) => (tx: string, error: (e: Error) => void) => () => void;
+declare const getTransaction: (request: ClientRequest<string, any>) => (tx: string, error: (e: Error) => void) => () => void;
+
+interface ChainSpecData {
+    name: string;
+    genesisHash: string;
+    properties: any;
+}
+declare const createGetChainSpec: (clientRequest: ClientRequest<any, any>) => () => Promise<ChainSpecData>;
 
 interface SubstrateClient {
     chainHead: ChainHead;
     transaction: Transaction;
     destroy: UnsubscribeFn;
+    getChainSpecData: () => Promise<ChainSpecData>;
     request: <T>(method: string, params: any[], abortSignal?: AbortSignal) => Promise<T>;
     _request: <Reply, Notification>(method: string, params: any[], cb?: ClientRequestCb<Reply, Notification>) => UnsubscribeFn;
 }
 declare const createClient: (provider: JsonRpcProvider) => SubstrateClient;
 
-export { type AbortablePromiseFn, type BestBlockChanged, type ChainHead, 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, getChainHead, getTransaction };
+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 };

package/dist/index.js

@@ -102,43 +102,54 @@ var getSubscriptionsManager = () => {
   };
 };
 
-// src/transaction/transaction.ts
-var getTxBroadcastNames = (input) => {
-  if (input.has("transaction_v1_broadcast"))
-    return ["transaction_v1_broadcast", "transaction_v1_stop"];
-  if (input.has("transactionWatch_unstable_submitAndWatch"))
-    return [
-      "transactionWatch_unstable_submitAndWatch",
-      "transactionWatch_unstable_unwatch"
-    ];
-  return ["transaction_unstable_submitAndWatch", "transaction_unstable_unwatch"];
+// src/methods.ts
+var chainHead = {
+  body: "",
+  call: "",
+  continue: "",
+  follow: "",
+  header: "",
+  stopOperation: "",
+  storage: "",
+  unfollow: "",
+  unpin: "",
+  followEvent: ""
+};
+var chainSpec = {
+  chainName: "",
+  genesisHash: "",
+  properties: ""
+};
+var transaction = {
+  broadcast: "",
+  stop: ""
+};
+var transactionWatch = {
+  submitAndWatch: "",
+  unwatch: ""
 };
-var getTransaction = (request, rpcMethods) => (tx, error) => {
-  const broadcast = (tx2, broadcastFn, cancelBroadcastFn) => request(broadcastFn, [tx2], {
+Object.entries({ chainHead, chainSpec, transaction, transactionWatch }).forEach(
+  ([fnGroupName, methods]) => {
+    Object.keys(methods).forEach((methodName) => {
+      ;
+      methods[methodName] = `${fnGroupName}_v1_${methodName}`;
+    });
+  }
+);
+
+// src/transaction/transaction.ts
+var getTransaction = (request) => (tx, error) => {
+  let cancel = request(transaction.broadcast, [tx], {
     onSuccess: (subscriptionId) => {
       cancel = subscriptionId === null ? noop2 : () => {
-        request(cancelBroadcastFn, [subscriptionId]);
+        request(transaction.stop, [subscriptionId]);
       };
       if (subscriptionId === null) {
-        error(
-          new Error("Max # of broadcasted transactions has been reached")
-        );
+        error(new Error("Max # of broadcasted transactions has been reached"));
       }
     },
     onError: error
   });
-  let isActive = true;
-  let cancel = () => {
-    isActive = false;
-  };
-  if (rpcMethods instanceof Promise) {
-    rpcMethods.then(getTxBroadcastNames).then((names) => {
-      if (!isActive)
-        return;
-      cancel = broadcast(tx, ...names);
-    });
-  } else
-    cancel = broadcast(tx, ...getTxBroadcastNames(rpcMethods));
   return () => {
     cancel();
   };
@@ -214,7 +225,7 @@ var createOperationPromise = (operationName, factory) => (request) => abortableP
         if (!isOperationGoing)
           return;
         done();
-        request("chainHead_unstable_stopOperation", [response.operationId]);
+        request(chainHead.stopOperation, [response.operationId]);
       };
     },
     onError: rej
@@ -226,7 +237,7 @@ var createOperationPromise = (operationName, factory) => (request) => abortableP
 
 // src/chainhead/body.ts
 var createBodyFn = createOperationPromise(
-  "chainHead_unstable_body",
+  chainHead.body,
   (hash) => [
     [hash],
     (e, res) => {
@@ -237,7 +248,7 @@ var createBodyFn = createOperationPromise(
 
 // src/chainhead/call.ts
 var createCallFn = createOperationPromise(
-  "chainHead_unstable_call",
+  chainHead.call,
   (hash, fnName, callParameters) => [
     [hash, fnName, callParameters],
     (e, res) => {
@@ -248,7 +259,7 @@ var createCallFn = createOperationPromise(
 
 // src/chainhead/header.ts
 var createHeaderFn = (request) => (hash) => new Promise((res, rej) => {
-  request("chainHead_unstable_header", [hash], {
+  request(chainHead.header, [hash], {
     onSuccess: res,
     onError: rej
   });
@@ -261,57 +272,53 @@ var createStorageCb = (request) => (hash, inputs, childTrie, onItems, onError, o
     onDone();
     return import_utils2.noop;
   }
-  let cancel = request(
-    "chainHead_unstable_storage",
-    [hash, inputs, childTrie],
-    {
-      onSuccess: (response, followSubscription) => {
-        if (response.result === "limitReached" || response.discardedItems === inputs.length)
-          return onError(new OperationLimitError());
-        const doneListening = followSubscription(response.operationId, {
-          next: (event) => {
-            switch (event.event) {
-              case "operationStorageItems": {
-                onItems(event.items);
-                break;
-              }
-              case "operationStorageDone": {
-                _onDone();
-                break;
-              }
-              case "operationError": {
-                _onError(new OperationError(event.error));
-                break;
-              }
-              case "operationInaccessible": {
-                _onError(new OperationInaccessibleError());
-                break;
-              }
-              default:
-                request("chainHead_unstable_continue", [event.operationId]);
+  let cancel = request(chainHead.storage, [hash, inputs, childTrie], {
+    onSuccess: (response, followSubscription) => {
+      if (response.result === "limitReached" || response.discardedItems === inputs.length)
+        return onError(new OperationLimitError());
+      const doneListening = followSubscription(response.operationId, {
+        next: (event) => {
+          switch (event.event) {
+            case "operationStorageItems": {
+              onItems(event.items);
+              break;
             }
-          },
-          error: onError
-        });
-        cancel = () => {
-          doneListening();
-          request("chainHead_unstable_stopOperation", [response.operationId]);
-        };
-        const _onError = (e) => {
-          cancel = import_utils2.noop;
-          doneListening();
-          onError(e);
-        };
-        const _onDone = () => {
-          cancel = import_utils2.noop;
-          doneListening();
-          onDone();
-        };
-        onDiscardedItems(response.discardedItems);
-      },
-      onError
-    }
-  );
+            case "operationStorageDone": {
+              _onDone();
+              break;
+            }
+            case "operationError": {
+              _onError(new OperationError(event.error));
+              break;
+            }
+            case "operationInaccessible": {
+              _onError(new OperationInaccessibleError());
+              break;
+            }
+            default:
+              request(chainHead.continue, [event.operationId]);
+          }
+        },
+        error: onError
+      });
+      cancel = () => {
+        doneListening();
+        request(chainHead.stopOperation, [response.operationId]);
+      };
+      const _onError = (e) => {
+        cancel = import_utils2.noop;
+        doneListening();
+        onError(e);
+      };
+      const _onDone = () => {
+        cancel = import_utils2.noop;
+        doneListening();
+        onDone();
+      };
+      onDiscardedItems(response.discardedItems);
+    },
+    onError
+  });
   return () => {
     cancel();
   };
@@ -354,7 +361,7 @@ var createStorageFn = (request) => {
 
 // src/chainhead/unpin.ts
 var createUnpinFn = (request) => (hashes) => hashes.length > 0 ? new Promise((res, rej) => {
-  request("chainHead_unstable_unpin", [hashes], {
+  request(chainHead.unpin, [hashes], {
     onSuccess() {
       res();
     },
@@ -405,7 +412,7 @@ function getChainHead(request) {
       unfollow(!(error instanceof DestroyedError));
     };
     const onFollowRequestSuccess = (subscriptionId, follow) => {
-      const done = follow("chainHead_unstable_followEvent", subscriptionId, {
+      const done = follow(subscriptionId, {
         next: onAllFollowEventsNext,
         error: onAllFollowEventsError
       });
@@ -413,7 +420,7 @@ function getChainHead(request) {
         followSubscription = null;
         unfollow = noop2;
         done();
-        sendUnfollow && request("chainHead_unstable_unfollow", [subscriptionId]);
+        sendUnfollow && request(chainHead.unfollow, [subscriptionId]);
         subscriptions.errorAll(new DisjointError());
         ongoingRequests.forEach((cb) => {
           cb();
@@ -433,7 +440,7 @@ function getChainHead(request) {
       deferredFollow.res(e);
     };
     let unfollow = request(
-      "chainHead_unstable_follow",
+      chainHead.follow,
       [withRuntime],
       { onSuccess: onFollowRequestSuccess, onError: onFollowRequestError }
     );
@@ -542,8 +549,8 @@ var createClient = (gProvider) => {
         if (!cb)
           return;
         responses.delete(id);
-        return error ? cb.onError(new RpcError(error)) : cb.onSuccess(result, (methodName, opaqueId, subscriber) => {
-          const subscriptionId2 = methodName + opaqueId;
+        return error ? cb.onError(new RpcError(error)) : cb.onSuccess(result, (opaqueId, subscriber) => {
+          const subscriptionId2 = opaqueId;
           subscriptions.subscribe(subscriptionId2, subscriber);
           return () => {
             subscriptions.unsubscribe(subscriptionId2);
@@ -554,7 +561,7 @@ var createClient = (gProvider) => {
       ({ subscription, result, error } = params);
       if (!subscription || !error && !Object.hasOwn(params, "result"))
         throw 0;
-      const subscriptionId = parsed.method + subscription;
+      const subscriptionId = subscription;
       if (error) {
         subscriptions.error(subscriptionId, new RpcError(error));
       } else {
@@ -591,21 +598,105 @@ var createClient = (gProvider) => {
   };
 };
 
+// src/chainspec.ts
+var createGetChainSpec = (clientRequest) => {
+  const request = abortablePromiseFn(
+    (onSuccess, onError, method, params) => clientRequest(method, params, { onSuccess, onError })
+  );
+  let cachedPromise = null;
+  return async () => {
+    if (cachedPromise)
+      return cachedPromise;
+    return cachedPromise = Promise.all([
+      request(chainSpec.chainName, []),
+      request(chainSpec.genesisHash, []),
+      request(chainSpec.properties, [])
+    ]).then(([name, genesisHash, properties]) => ({
+      name,
+      genesisHash,
+      properties
+    }));
+  };
+};
+
+// src/request-compatibility-enhancer.ts
+var getCompatibilityEnhancer = (rpcMethodsP, request) => (methods) => {
+  let translations = {};
+  let enhancedRequest = null;
+  return (method, ...rest) => {
+    if (enhancedRequest)
+      return enhancedRequest(method, ...rest);
+    let isRunning = true;
+    let cleanup = () => {
+      isRunning = false;
+    };
+    rpcMethodsP.then((rpcMethods) => {
+      enhancedRequest = (method_, ...iRest) => {
+        const method2 = translations[method_] ?? method_;
+        if (rpcMethods.has(method2))
+          return request(method2, ...iRest);
+        iRest[1]?.onError(new Error(`Unsupported method ${method2}`));
+        return noop2;
+      };
+      if (rpcMethods.has(method))
+        return;
+      const parts = method.split("_");
+      if (parts[1] !== "v1")
+        return;
+      parts[1] = "unstable";
+      if (rpcMethods.has(parts.join("_")))
+        Object.values(methods).forEach((value) => {
+          translations[value] = value.replace("_v1_", "_unstable_");
+        });
+      else if (parts[0] === "transaction") {
+        let unwatch;
+        let version;
+        const txGroup = ["transactionWatch", "transaction"].find(
+          (group) => {
+            version = ["v1", "unstable"].find(
+              (v) => rpcMethods.has(unwatch = `${group}_${v}_unwatch`)
+            );
+            return !!version;
+          }
+        );
+        if (txGroup) {
+          translations[methods.broadcast] = `${txGroup}_${version}_submitAndWatch`;
+          translations[methods.stop] = unwatch;
+        }
+      }
+    }).then(() => {
+      if (isRunning)
+        cleanup = enhancedRequest(method, ...rest);
+    });
+    return () => {
+      cleanup();
+    };
+  };
+};
+
 // src/index.ts
 var createClient2 = (provider) => {
   const client = createClient(provider);
   const request = abortablePromiseFn(
     (onSuccess, onError, method, params) => client.request(method, params, { onSuccess, onError })
   );
-  let rpcMethods = request("rpc_methods", []).then(
-    (x) => rpcMethods = new Set(Array.isArray(x) ? x : x.methods)
+  const rpcMethods = request("rpc_methods", []).then(
+    (x) => new Set(Array.isArray(x) ? x : x.methods),
+    () => /* @__PURE__ */ new Set()
+  );
+  const compatibilityEnhancer = getCompatibilityEnhancer(
+    rpcMethods,
+    client.request
   );
-  rpcMethods.catch(noop2);
   return {
-    chainHead: getChainHead(client.request),
+    chainHead: getChainHead(
+      compatibilityEnhancer(chainHead)
+    ),
     transaction: getTransaction(
-      client.request,
-      rpcMethods
+      compatibilityEnhancer(transaction)
+    ),
+    getChainSpecData: createGetChainSpec(
+      compatibilityEnhancer(chainSpec)
     ),
     destroy: () => {
       client.disconnect();