Use Chrome manifest V3

packages/yoroi-connector/src/cardanoApiInject.js

@@ -0,0 +1,154 @@
+(() => {
+  class CardanoAuth {
+    constructor(auth, rpc) {
+      this._auth = auth;
+      this._cardano_rpc_call = rpc;
+    }
+
+    isEnabled() {
+      return this._auth != null;
+    }
+
+    getWalletId() {
+      if (!this._auth) {
+        throw new Error('This connection does not have auth enabled!');
+      }
+      return this._auth.walletId;
+    }
+
+    getWalletPubkey() {
+      if (!this._auth) {
+        throw new Error('This connection does not have auth enabled!');
+      }
+      return this._auth.pubkey;
+    }
+
+    signHexPayload(payload_hex_string) {
+      if (!this._auth) {
+        throw new Error('This connection does not have auth enabled!');
+      }
+      return this._cardano_rpc_call("auth_sign_hex_payload/cardano", [payload_hex_string]);
+    }
+
+    checkHexPayload(payload_hex_string, signature_hex_string) {
+      if (!this._auth) {
+        throw new Error('This connection does not have auth enabled!');
+      }
+      return this._cardano_rpc_call("auth_check_hex_payload/cardano", [payload_hex_string, signature_hex_string]);
+    }
+  }
+  class CardanoAPI {
+
+    constructor(auth, rpc) {
+      const self = this;
+      function rpcWrapper(func, params) {
+        return rpc(func, params, self._returnType[0]);
+      }
+      this._auth = new CardanoAuth(auth, rpcWrapper);
+      this._cardano_rpc_call = rpcWrapper;
+      this._disconnection = [false];
+      this._returnType = ["cbor"];
+      window.addEventListener('yoroi_wallet_disconnected', function() {
+          if (!self._disconnection[0]) {
+              self._disconnection[0] = true;
+              self._disconnection.slice(1).forEach(f => f());
+          }
+      });
+    }
+
+    experimental = Object.freeze({
+
+      setReturnType: (returnType) => {
+        if (returnType !== 'cbor' && returnType !== 'json') {
+          throw new Error('Possible return type values are: "cbor" or "json"');
+        }
+        this._returnType[0] = returnType;
+      },
+
+      auth: () => {
+        return this._auth;
+      },
+
+      createTx: (req) => {
+        return this._cardano_rpc_call("create_tx/cardano", [req]);
+      },
+
+      listNFTs: () => {
+        return this._cardano_rpc_call("list_nfts/cardano", []);
+      },
+
+      onDisconnect: (callback) => {
+        if (this._disconnection[0]) {
+          throw new Error('Cardano API instance is already disconnected!');
+        }
+        this._disconnection.push(callback);
+      },
+
+    }) 
+
+    getNetworkId() {
+      return this._cardano_rpc_call("get_network_id", []);
+    }
+
+    getBalance(token_id = '*') {
+      return this._cardano_rpc_call("get_balance", [token_id]);
+    }
+
+    getUsedAddresses(paginate = undefined) {
+      return this._cardano_rpc_call("get_used_addresses", [paginate]);
+    }
+
+    getUnusedAddresses() {
+      return this._cardano_rpc_call("get_unused_addresses", []);
+    }
+
+    getRewardAddresses() {
+      return this._cardano_rpc_call("get_reward_addresses/cardano", []);
+    }
+
+    getChangeAddress() {
+      return this._cardano_rpc_call("get_change_address", []);
+    }
+
+    getUtxos(amount = undefined, paginate = undefined) {
+      return this._cardano_rpc_call("get_utxos/cardano", [amount, paginate]);
+    }
+
+    submitTx(tx) {
+      return this._cardano_rpc_call('submit_tx', [tx]);
+    }
+
+    signTx(param, _partialSign = false) {
+      if (param == null) {
+        throw new Error('.signTx argument cannot be null!');
+      }
+      let tx = param;
+      let partialSign = _partialSign;
+      let returnTx = false;
+      if (typeof param === 'object') {
+        tx = param.tx;
+        partialSign = param.partialSign;
+        returnTx = param.returnTx;
+      } else if (typeof param !== 'string') {
+        throw new Error('.signTx argument is expected to be an object or a string!')
+      }
+      return this._cardano_rpc_call('sign_tx/cardano', [{ tx, partialSign, returnTx }]);
+    }
+
+    signData(address, payload) {
+      return this._cardano_rpc_call("sign_data", [address, payload]);
+    }
+
+    // DEPRECATED
+    getCollateralUtxos(requiredAmount) {
+      return this._cardano_rpc_call("get_collateral_utxos", [requiredAmount]);
+    }
+
+    getCollateral(requiredAmount) {
+      return this._cardano_rpc_call("get_collateral_utxos", [requiredAmount]);
+    }
+  }
+  window.CardanoAPI = CardanoAPI;
+
+  window.postMessage({ type: 'scripted_injected' });
+})();

packages/yoroi-connector/src/ergoApiInject.js

@@ -0,0 +1,79 @@
+// RPC set-up
+(() => {
+var ergoRpcUid = 0;
+var ergoRpcResolver = new Map();
+
+window.addEventListener("message", function(event) {
+    if (event.data.type == "connector_rpc_response" && event.data.protocol === "ergo") {
+        console.debug("page received from connector: " + JSON.stringify(event.data) + " with source = " + event.source + " and origin = " + event.origin);
+        const rpcPromise = ergoRpcResolver.get(event.data.uid);
+        if (rpcPromise !== undefined) {
+            const ret = event.data.return;
+            if (ret.err !== undefined) {
+                rpcPromise.reject(ret.err);
+            } else {
+                rpcPromise.resolve(ret.ok);
+            }
+        }
+    }
+});
+
+class ErgoAPI {
+    get_balance(token_id = 'ERG') {
+        return this._ergo_rpc_call("get_balance", [token_id]);
+    }
+
+    get_utxos(amount = undefined, token_id = 'ERG', paginate = undefined) {
+        return this._ergo_rpc_call("get_utxos", [amount, token_id, paginate]);
+    }
+
+    get_used_addresses(paginate = undefined) {
+        return this._ergo_rpc_call("get_used_addresses", [paginate]);
+    }
+
+    get_unused_addresses() {
+        return this._ergo_rpc_call("get_unused_addresses", []);
+    }
+
+    get_change_address() {
+        return this._ergo_rpc_call("get_change_address", []);
+    }
+
+    sign_tx(tx) {
+        return this._ergo_rpc_call("sign_tx", [tx]);
+    }
+
+    sign_tx_input(tx, index) {
+        return this._ergo_rpc_call("sign_tx_input", [tx, index]);
+    }
+
+    // This is unsupported by current version of Yoroi
+    // and the details of it are not finalized yet in the EIP-012
+    // dApp bridge spec.
+    // sign_data(addr, message) {
+    //     return this._ergo_rpc_call("sign_data", [addr, message]);
+    // }
+
+    submit_tx(tx) {
+        return this._ergo_rpc_call("submit_tx", [tx]);
+    }
+
+    _ergo_rpc_call(func, params) {
+        return new Promise(function(resolve, reject) {
+            window.postMessage({
+                type: "connector_rpc_request",
+                protocol: "ergo",
+                uid: ergoRpcUid,
+                function: func,
+                params: params
+            }, location.origin);
+            console.debug("ergoRpcUid = " + ergoRpcUid);
+            ergoRpcResolver.set(ergoRpcUid, { resolve: resolve, reject: reject });
+            ergoRpcUid += 1;
+        });
+    }
+}
+
+window.ergo = Object.freeze(new ErgoAPI());
+window.postMessage({ type: 'scripted_injected' });
+})();

packages/yoroi-connector/src/initialInject.js

@@ -0,0 +1,120 @@
+(() => {
+  const WALLET_NAME = 'yoroi';
+  const API_VERSION = '0.3.0';
+  const ICON_URL = 'data:image/svg+xml;base64,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';
+
+  var connectRequests = [];
+
+  window.addEventListener("message", function(event) {
+    if (event.data.type === "connector_connected") {
+      if (event.data.err !== undefined) {
+        connectRequests.forEach(promise => promise.reject(event.data.err));
+      } else {
+        const isSuccess = event.data.success;
+        connectRequests.forEach(promise => {
+            if (promise.protocol === 'cardano') {
+                if (isSuccess) {
+                    promise.resolve(event.data.auth);
+                } else {
+                    promise.reject({ code: -3, info: 'User Rejected' });
+                }
+            } else {
+                promise.resolve(isSuccess);
+            }
+        });
+      }
+    }
+  });
+
+  window.ergo_request_read_access = function() {
+    return new Promise(function(resolve, reject) {
+      window.postMessage({
+        type: "connector_connect_request/ergo",
+      }, location.origin);
+      connectRequests.push({ resolve: resolve, reject: reject });
+    });
+  };
+
+  window.ergo_check_read_access = function() {
+    if (typeof ergo !== "undefined") {
+      return ergo._ergo_rpc_call("ping", []);
+    } else {
+      return Promise.resolve(false);
+    }
+  };
+
+  // RPC setup
+  var cardanoRpcUid = 0;
+  var cardanoRpcResolver = new Map();
+
+  window.addEventListener("message", function(event) {
+    if (event.data.type === "connector_rpc_response" && event.data.protocol === "cardano") {
+      console.debug("page received from connector: " + JSON.stringify(event.data) + " with source = " + event.source + " and origin = " + event.origin);
+      const rpcPromise = cardanoRpcResolver.get(event.data.uid);
+      if (rpcPromise !== undefined) {
+        const ret = event.data.return;
+        if (ret.err !== undefined) {
+          rpcPromise.reject(ret.err);
+        } else {
+          rpcPromise.resolve(ret.ok);
+        }
+      }
+    }
+  });
+
+  function cardano_rpc_call(func, params, returnType) {
+    return new Promise(function(resolve, reject) {
+      window.postMessage({
+        type: "connector_rpc_request",
+        protocol: "cardano",
+        url: location.hostname,
+        uid: cardanoRpcUid,
+        function: func,
+        params,
+        returnType: returnType || "cbor",
+      }, location.origin);
+      console.debug("cardanoRpcUid = " + cardanoRpcUid);
+      cardanoRpcResolver.set(cardanoRpcUid, { resolve: resolve, reject: reject });
+      cardanoRpcUid += 1;
+    });
+  }
+
+  function cardano_request_read_access(cardanoAccessRequest) {
+    const { requestIdentification, onlySilent } = (cardanoAccessRequest || {});
+    return new Promise(function(resolve, reject) {
+      window.postMessage({
+        type: "connector_connect_request/cardano",
+        requestIdentification,
+        onlySilent,
+      }, location.origin);
+      connectRequests.push({
+        protocol: 'cardano',
+        resolve: (auth) => {
+            const authWrapper = auth == null ? null : Object.freeze({
+              walletId: auth.walletId,
+              pubkey: auth.pubkey,
+            });
+            resolve(Object.freeze(new CardanoAPI(authWrapper, cardano_rpc_call)));
+        },
+        reject: reject
+      });
+    });
+  }
+
+  function cardano_check_read_access() {
+    return cardano_rpc_call("is_enabled/cardano", []);
+  }
+
+  window.cardano = {
+    ...(window.cardano||{}),
+    [WALLET_NAME]: {
+      icon: ICON_URL,
+      enable: cardano_request_read_access,
+      isEnabled: cardano_check_read_access,
+      apiVersion: API_VERSION,
+      name: WALLET_NAME,
+    }
+  };
+
+  window.postMessage({ type: 'scripted_injected' });
+})();