@leather.io/provider 1.0.0

package/dist/injected-provider.js

@@ -0,0 +1,378 @@
+export default ({branch, commitSha, version}) =>  `// src/add-leather-to-providers.ts
+function addLeatherToProviders() {
+  const win = window;
+  if (!win.btc_providers) win.btc_providers = [];
+  win.btc_providers.push({
+    id: "LeatherProvider",
+    name: "Leather",
+    icon: "data:image/svg;base64,PHN2ZyB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCIgdmlld0JveD0iMCAwIDEyOCAxMjgiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxyZWN0IHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiByeD0iMjYuODM4NyIgZmlsbD0iIzEyMTAwRiIvPgo8cGF0aCBkPSJNNzQuOTE3MSA1Mi43MTE0QzgyLjQ3NjYgNTEuNTQwOCA5My40MDg3IDQzLjU4MDQgOTMuNDA4NyAzNy4zNzYxQzkzLjQwODcgMzUuNTAzMSA5MS44OTY4IDM0LjIxNTQgODkuNjg3MSAzNC4yMTU0Qzg1LjUwMDQgMzQuMjE1NCA3OC40MDYxIDQwLjUzNjggNzQuOTE3MSA1Mi43MTE0Wk0zOS45MTEgODMuNDk5MUMzMC4wMjU2IDgzLjQ5OTEgMjkuMjExNSA5My4zMzI0IDM5LjA5NjkgOTMuMzMyNEM0My41MTYzIDkzLjMzMjQgNDguODY2MSA5MS41NzY0IDUxLjY1NzMgODguNDE1N0M0Ny41ODY4IDg0LjkwMzggNDQuMjE0MSA4My40OTkxIDM5LjkxMSA4My40OTkxWk0xMDIuODI5IDc5LjI4NDhDMTAzLjQxIDk1Ljc5MDcgOTUuMDM2OSAxMDUuMDM5IDgwLjg0ODQgMTA1LjAzOUM3Mi40NzQ4IDEwNS4wMzkgNjguMjg4MSAxMDEuODc4IDU5LjMzMyA5Ni4wMjQ4QzU0LjY4MSAxMDEuMTc2IDQ1Ljg0MjMgMTA1LjAzOSAzOC41MTU0IDEwNS4wMzlDMTMuMjc4NSAxMDUuMDM5IDE0LjMyNTIgNzIuODQ2MyA0MC4wMjczIDcyLjg0NjNDNDUuMzc3MSA3Mi44NDYzIDQ5LjkxMjggNzQuMjUxMSA1NS43Mjc3IDc3Ljg4TDU5LjU2NTYgNjQuNDE3N0M0My43NDg5IDYwLjA4NjQgMzUuODQwNSA0Ny45MTE4IDQzLjYzMjYgMzAuNDY5M0g1Ni4xOTI5QzQ5LjIxNSA0Mi4wNTg2IDUzLjk4MzIgNTEuNjU3OCA2Mi44MjIgNTIuNzExNEM2Ny41OTAzIDM1LjczNzIgNzcuODI0NiAyMi41MDkgOTEuNDMxNiAyMi41MDlDOTkuMTA3NCAyMi41MDkgMTA1LjE1NSAyNy41NDI4IDEwNS4xNTUgMzYuNjczN0MxMDUuMTU1IDUxLjMwNjYgODYuMDgxOSA2My4yNDcxIDcxLjY2MDcgNjQuNDE3N0w2NS43Mjk1IDg1LjM3MjFDNzIuNDc0OCA5My4yMTUzIDkxLjE5OSAxMDAuODI0IDkxLjE5OSA3OS4yODQ4SDEwMi44MjlaIiBmaWxsPSIjRjdGNUYzIi8+Cjwvc3ZnPgo=",
+    webUrl: "https://leather.io",
+    chromeWebStoreUrl: "https://chromewebstore.google.com/detail/leather/ldinpeekobnhjjdofggfgjlcehhmanlj",
+    methods: [
+      "open",
+      "getInfo",
+      "supportedMethods",
+      "openSwap",
+      "getAddresses",
+      "stx_updateProfile",
+      "stx_signMessage",
+      "stx_transferStx",
+      "stx_transferSip10Ft",
+      "stx_signTransaction",
+      "stx_signStructuredMessage",
+      "stx_getAddresses",
+      "stx_deployContract",
+      "stx_callContract",
+      "signPsbt",
+      "signMessage",
+      "sendTransfer"
+      // Better to import a type than a variable from @leather.io/rpc to save a lot of space in the injected provider script
+    ]
+  });
+}
+
+// src/legacy-requests.ts
+var MESSAGE_SOURCE = "stacks-wallet";
+function isValidEvent(event, method) {
+  const { data } = event;
+  const correctSource = data.source === MESSAGE_SOURCE;
+  const correctMethod = data.method === method;
+  return correctSource && correctMethod && !!data.payload;
+}
+async function callAndReceive(methodName, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject("Unable to get response from Blockstack extension");
+    }, 1e3);
+    function waitForResponse(event) {
+      if (event.data.source === "blockstack-extension" && event.data.method === \`\${methodName}Response\`) {
+        clearTimeout(timeout);
+        window.removeEventListener("message", waitForResponse);
+        resolve(event.data);
+      }
+    }
+    window.addEventListener("message", waitForResponse);
+    window.postMessage(
+      {
+        method: methodName,
+        source: "blockstack-app",
+        ...opts
+      },
+      window.location.origin
+    );
+  });
+}
+function placeholderLegacyRequests() {
+  return {
+    getURL: () => {
+      throw new Error("This function i deprecated");
+    },
+    structuredDataSignatureRequest: () => {
+      throw new Error("This function is deprecated");
+    },
+    signatureRequest: () => {
+      throw new Error("This function is deprecated");
+    },
+    authenticationRequest: () => {
+      throw new Error("This function is deprecated");
+    },
+    transactionRequest: () => {
+      throw new Error("This function is deprecated");
+    },
+    psbtRequest: () => {
+      throw new Error("This function is deprecated");
+    },
+    profileUpdateRequest: () => {
+      throw new Error("This function is deprecated");
+    }
+  };
+}
+function legacyRequests() {
+  return {
+    getURL: async () => {
+      const { url } = await callAndReceive("getURL");
+      return url;
+    },
+    structuredDataSignatureRequest: async (signatureRequest) => {
+      const event = new CustomEvent(
+        "hiroWalletStructuredDataSignatureRequest" /* structuredDataSignatureRequest */,
+        {
+          detail: { signatureRequest }
+        }
+      );
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletSignatureResponse" /* signatureResponse */)) return;
+          if (event2.data.payload?.signatureRequest !== signatureRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.signatureResponse === "cancel") {
+            reject(event2.data.payload.signatureResponse);
+            return;
+          }
+          if (typeof event2.data.payload.signatureResponse !== "string") {
+            resolve(event2.data.payload.signatureResponse);
+          }
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    },
+    signatureRequest: async (signatureRequest) => {
+      const event = new CustomEvent("hiroWalletSignatureRequest" /* signatureRequest */, {
+        detail: { signatureRequest }
+      });
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletSignatureResponse" /* signatureResponse */)) return;
+          if (event2.data.payload?.signatureRequest !== signatureRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.signatureResponse === "cancel") {
+            reject(event2.data.payload.signatureResponse);
+            return;
+          }
+          if (typeof event2.data.payload.signatureResponse !== "string") {
+            resolve(event2.data.payload.signatureResponse);
+          }
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    },
+    authenticationRequest: async (authenticationRequest) => {
+      console.warn(\`
+        WARNING: Legacy Leather request detected
+
+        Leather now uses an RPC-style API, that can be used directly,
+        rather than through libraries such as Stacks Connect. For example,
+        to get a user's addresses, you should use the
+        LeatherProvider.request('getAddresses') method.
+
+        See our docs for more information https://leather.gitbook.io/
+      \`);
+      const event = new CustomEvent(
+        "hiroWalletStacksAuthenticationRequest" /* authenticationRequest */,
+        {
+          detail: { authenticationRequest }
+        }
+      );
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletAuthenticationResponse" /* authenticationResponse */)) return;
+          if (event2.data.payload?.authenticationRequest !== authenticationRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.authenticationResponse === "cancel") {
+            reject(event2.data.payload.authenticationResponse);
+            return;
+          }
+          resolve(event2.data.payload.authenticationResponse);
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    },
+    transactionRequest: async (transactionRequest) => {
+      const event = new CustomEvent(
+        "hiroWalletStacksTransactionRequest" /* transactionRequest */,
+        {
+          detail: { transactionRequest }
+        }
+      );
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletTransactionResponse" /* transactionResponse */)) return;
+          if (event2.data.payload?.transactionRequest !== transactionRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.transactionResponse === "cancel") {
+            reject(event2.data.payload.transactionResponse);
+            return;
+          }
+          if (typeof event2.data.payload.transactionResponse !== "string") {
+            resolve(event2.data.payload.transactionResponse);
+          }
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    },
+    psbtRequest: async (psbtRequest) => {
+      const event = new CustomEvent("hiroWalletPsbtRequest" /* psbtRequest */, {
+        detail: { psbtRequest }
+      });
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletPsbtResponse" /* psbtResponse */)) return;
+          if (event2.data.payload?.psbtRequest !== psbtRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.psbtResponse === "cancel") {
+            reject(event2.data.payload.psbtResponse);
+            return;
+          }
+          if (typeof event2.data.payload.psbtResponse !== "string") {
+            resolve(event2.data.payload.psbtResponse);
+          }
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    },
+    profileUpdateRequest: async (profileUpdateRequest) => {
+      const event = new CustomEvent(
+        "hiroWalletProfileUpdateRequest" /* profileUpdateRequest */,
+        {
+          detail: { profileUpdateRequest }
+        }
+      );
+      document.dispatchEvent(event);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event2) {
+          if (!isValidEvent(event2, "hiroWalletProfileUpdateResponse" /* profileUpdateResponse */)) return;
+          if (event2.data.payload?.profileUpdateRequest !== profileUpdateRequest) return;
+          window.removeEventListener("message", handleMessage);
+          if (event2.data.payload.profileUpdateResponse === "cancel") {
+            reject(event2.data.payload.profileUpdateResponse);
+            return;
+          }
+          if (typeof event2.data.payload.profileUpdateResponse !== "string") {
+            resolve(event2.data.payload.profileUpdateResponse);
+          }
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    }
+  };
+}
+function getLegacyRequests(platform) {
+  switch (platform) {
+    case "extension":
+      return legacyRequests();
+    case "mobile":
+    default:
+      return placeholderLegacyRequests();
+  }
+}
+
+// src/index.ts
+function initInpageProvider({ onDispatch, env }) {
+  addLeatherToProviders();
+  const provider = {
+    isLeather: true,
+    ...getLegacyRequests(env.platform),
+    getProductInfo() {
+      return {
+        version: env.version,
+        name: "Leather",
+        meta: {
+          tag: env.branch,
+          commit: env.commitSha
+        }
+      };
+    },
+    request(method, params) {
+      const id = crypto.randomUUID();
+      const rpcRequest = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params: params ?? {}
+      };
+      onDispatch(rpcRequest);
+      return new Promise((resolve, reject) => {
+        function handleMessage(event) {
+          const response = typeof event.data === "object" ? event.data : JSON.parse(event.data);
+          if (response.id !== id) return;
+          window.removeEventListener("message", handleMessage);
+          if ("error" in response) return reject(response);
+          return resolve(response);
+        }
+        window.addEventListener("message", handleMessage);
+      });
+    }
+  };
+  function consoleDeprecationNotice(text) {
+    console.warn(\`Deprecation warning: \${text}\`);
+  }
+  function warnAboutDeprecatedProvider(legacyProvider) {
+    return Object.fromEntries(
+      Object.entries(legacyProvider).map(([key, value]) => {
+        if (typeof value === "function") {
+          return [
+            key,
+            (...args) => {
+              switch (key) {
+                case "authenticationRequest":
+                  consoleDeprecationNotice(
+                    \`Use LeatherProvider.request('getAddresses') instead, see docs https://leather.gitbook.io/developers/bitcoin/connect-users/get-addresses\`
+                  );
+                  break;
+                case "psbtRequest":
+                  consoleDeprecationNotice(
+                    \`Use LeatherProvider.request('signPsbt') instead, see docs https://leather.gitbook.io/developers/bitcoin/sign-transactions/partially-signed-bitcoin-transactions-psbts\`
+                  );
+                  break;
+                case "structuredDataSignatureRequest":
+                case "signatureRequest":
+                  consoleDeprecationNotice(
+                    \`Use LeatherProvider.request('stx_signMessage') instead\`
+                  );
+                  break;
+                default:
+                  consoleDeprecationNotice(
+                    "The provider object is deprecated. Use \`LeatherProvider\` instead"
+                  );
+              }
+              return value(...args);
+            }
+          ];
+        }
+        return [key, value];
+      })
+    );
+  }
+  try {
+    Object.defineProperty(window, "StacksProvider", {
+      get: () => warnAboutDeprecatedProvider(provider),
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      set: () => {
+      }
+    });
+  } catch {
+    console.log("Unable to set StacksProvider");
+  }
+  try {
+    Object.defineProperty(window, "HiroWalletProvider", {
+      get: () => warnAboutDeprecatedProvider(provider),
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      set: () => {
+      }
+    });
+  } catch {
+    console.log("Unable to set HiroWalletProvider");
+  }
+  try {
+    Object.defineProperty(window, "LeatherProvider", {
+      get: () => provider,
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      set: () => {
+      }
+    });
+  } catch {
+    console.warn("Unable to set LeatherProvider");
+  }
+  if (typeof window.btc === "undefined") {
+    window.btc = warnAboutDeprecatedProvider(provider);
+  }
+}
+
+// src/mobile.ts
+initInpageProvider({
+  onDispatch(rpcRequest) {
+    window.ReactNativeWebView.postMessage(JSON.stringify(rpcRequest));
+  },
+  env: {
+    platform: "mobile",
+    branch: "${branch}",
+    commitSha: "${commitSha}",
+    version: "${version}"
+  }
+});
+//# sourceMappingURL=mobile.js.map`

package/dist/injected-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/injected-provider.ts"],"sourcesContent":["// placeholder for creating injected-provider.d.ts for mobile\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport default (_: { branch: string; commitSha: string; version: string }) => '';\n"],"mappings":";AAEA,IAAO,4BAAQ,CAAC,MAA8D;","names":[]}

package/dist/mobile.d.ts

@@ -0,0 +1,2 @@
+
+export {  }