@tomo-inc/inject-providers 0.0.1

package/src/dogecoin/dogecoin.ts

@@ -0,0 +1,304 @@
+import { ethErrors } from "eth-rpc-errors";
+import { EventEmitter } from "events";
+
+import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
+import { TxType } from "./types";
+
+import { ChainTypes, IConnectors, IProductInfo } from "../types";
+
+const chainType = ChainTypes.DOGE;
+
+interface StateProvider {
+  accounts: string[] | null;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+export class DogecoinProvider extends EventEmitter {
+  _selectedAddress: string | null = null;
+  _network: string | null = null;
+  _isConnected = false;
+  _initialized = false;
+  _isUnlocked = false;
+  rdns = "";
+  name = "";
+  sendRequest: (chainType: string, data: any) => void;
+  onResponse: any;
+
+  _state: StateProvider = {
+    accounts: null,
+    isConnected: false,
+    isUnlocked: false,
+    initialized: false,
+    isPermanentlyDisconnected: false,
+  };
+
+  private _requestPromise = new ReadyPromise(0);
+
+  constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors) {
+    super();
+    this.name = productInfo.name;
+    this.rdns = productInfo.rdns;
+    this.setMaxListeners(100);
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+  }
+
+  initialize = async () => {
+    // dapp tab switch send data;
+    document.addEventListener("visibilitychange", async () => {
+      if (document.visibilityState === "visible") {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo(),
+        });
+      }
+    });
+
+    // this._bcm.connect().on("message", this._handleBackgroundMessage);
+    domReadyCall(async () => {
+      this._request({
+        method: "wallet_sendDomainMetadata",
+        params: await getDappInfo(),
+      });
+    });
+
+    this._state.initialized = true;
+    this._state.isConnected = true;
+
+    this.keepAlive();
+  };
+
+  /**
+   * Sending a message to the extension to receive will keep the service worker alive.
+   */
+  private keepAlive = () => {
+    this._request({
+      method: "keepAlive",
+      params: {},
+    }).then((v) => {
+      setTimeout(() => {
+        this.keepAlive();
+      }, 1000);
+    });
+  };
+
+  //adapter data by reuqest function
+  _request = async ({ method, params }: { method: string; params?: any }, adapter?: any) => {
+    if (!method) {
+      throw ethErrors.rpc.invalidRequest();
+    }
+
+    //api call -> ("0: dapp -> injector -> content");
+    const dappInfo = await getDappInfo();
+    this.sendRequest(chainType, { method, params, dappInfo });
+
+    //check result by method
+    return this.onResponse({ method }).then((res: any) => {
+      const { data } = res || {};
+
+      //maybe need some adaptor for doge api
+      return adapter ? adapter(data) : data;
+    });
+  };
+
+  request = async ({ method, params }: { method: string; params: any }) => {
+    if (!method) {
+      throw ethErrors.rpc.invalidRequest();
+    }
+    return this._request({
+      method,
+      params,
+    });
+  };
+
+  //res = { address, approved, balance, publicKey }
+  connect = async () => {
+    return this._request({
+      method: "connect",
+      params: {},
+    });
+  };
+
+  //res = { address, balance }
+  getBalance = async () => {
+    return this._request({
+      method: "getBalance",
+    });
+  };
+
+  //res = { disconnected }
+  disconnect = async () => {
+    return this._request({
+      method: "disconnect",
+      params: {},
+    });
+  };
+
+  //res = { "connected, address, selectedWalletAddress }
+  getConnectionStatus = async () => {
+    return this._request({
+      method: "getConnectionStatus",
+      params: {},
+    });
+  };
+
+  //res = { txId }
+  requestTransaction = async ({ recipientAddress, dogeAmount }: { recipientAddress: string; dogeAmount: number }) => {
+    return this._request({
+      method: "requestTransaction",
+      params: {
+        to: recipientAddress,
+        amount: dogeAmount,
+        type: TxType.SEND_DOGECOIN,
+      },
+    });
+  };
+
+  //res = {status === 'confirmed', confirmations > 1}
+  getTransactionStatus = async ({ txId }: { txId: string }) => {
+    return this._request({
+      method: "getTransactionStatus",
+      params: { txId },
+    });
+  };
+
+  //res = { signedMessage }
+  requestSignedMessage = async ({ message, type = "" }: { message: string; type?: string }) => {
+    return this._request({
+      method: "requestSignedMessage",
+      params: {
+        text: message,
+        type,
+      },
+    });
+  };
+
+  //res = { decryptedMessage }
+  requestDecryptedMessage = async ({ message }: { message: string }) => {
+    return this._request({
+      method: "requestDecryptedMessage",
+      params: {
+        message,
+      },
+    });
+  };
+
+  //res = { signedMessage }
+  getDRC20Balances = async (address: string, ticker?: string) => {
+    return this._request({
+      method: "getDRC20Balances",
+      params: {
+        address,
+        ticker,
+      },
+    });
+  };
+
+  //res = { availableBalance, transferableBalance, ticker, address }
+  getDRC20Balance = async ({ ticker }: { ticker?: string }) => {
+    return this._request({
+      method: "getDRC20Balance",
+      params: {
+        ticker,
+      },
+    });
+  };
+
+  //res = { inscriptions, ticker, address }
+  getTransferableDRC20 = async ({ ticker }: { ticker?: string }) => {
+    return this._request({
+      method: "getTransferableDRC20",
+      params: {
+        ticker,
+      },
+    });
+  };
+
+  //res = { txId, ticker, amount }
+  requestAvailableDRC20Transaction = async ({ ticker, amount }: { ticker: string; amount: number }) => {
+    return this._request({
+      method: "requestAvailableDRC20Transaction",
+      params: {
+        ticker,
+        amount,
+      },
+    });
+  };
+
+  //res = { txId }
+  requestInscriptionTransaction = async ({
+    location,
+    recipientAddress,
+  }: {
+    location: string;
+    recipientAddress: string;
+  }) => {
+    return this._request({
+      method: "requestInscriptionTransaction",
+      params: {
+        location,
+        recipientAddress,
+      },
+    });
+  };
+
+  //res = { ?signedRawTx, ?txId }
+  requestPsbt = async ({
+    rawTx,
+    indexes,
+    feeOnly,
+    signOnly,
+    partial,
+    sighashType,
+  }: {
+    rawTx: string;
+    indexes?: [];
+    feeOnly?: boolean;
+    signOnly?: boolean;
+    partial?: boolean;
+    sighashType?: string;
+  }) => {
+    return this._request({
+      method: "requestPsbt",
+      params: {
+        rawTx,
+        indexes,
+        feeOnly,
+        signOnly,
+        partial,
+        sighashType,
+      },
+    });
+  };
+
+  //---------//dunes
+  getDunesBalance = async (params: { ticker: string }) => {
+    return this._request({
+      method: "getDunesBalance",
+      params,
+    });
+  };
+
+  requestDunesTransaction = async ({
+    ticker,
+    amount,
+    recipientAddress,
+  }: {
+    ticker: string;
+    amount: number;
+    recipientAddress: string;
+  }) => {
+    return this._request({
+      method: "requestDunesTransaction",
+      params: {
+        ticker,
+        amount,
+        recipientAddress,
+      },
+    });
+  };
+}

package/src/dogecoin/index.ts

@@ -0,0 +1,3 @@
+import { DogecoinProvider } from "./dogecoin";
+
+export { DogecoinProvider };

package/src/dogecoin/types.ts

@@ -0,0 +1,38 @@
+import { DappInfo } from "../types";
+
+export enum TxType {
+  SIGN_TX,
+  SEND_BITCOIN,
+  SEND_INSCRIPTION,
+  SEND_DOGECOIN,
+}
+
+export interface IDogeService {
+  connect(dappInfo: DappInfo): Promise<any>;
+  disconnect(dappInfo: DappInfo): Promise<any>;
+  requestAccounts(dappInfo: DappInfo): Promise<any>;
+  getAccounts(): Promise<any>;
+  getPublicKey(): Promise<any>;
+  getConnectionStatus(): Promise<any>;
+  getBalance(): Promise<any>;
+
+  signMessage(params: { text: string; type: string }): Promise<any>;
+  requestSignedMessage(params: { text: string; type: string }): Promise<any>;
+  requestDecryptedMessage(params: { message: string }): Promise<any>;
+
+  requestPsbt(params: { rawTx: string; signOnly?: boolean }): Promise<any>;
+
+  requestTransaction(txData: any): Promise<any>;
+  getTransactionStatus(params: { txId: string }): Promise<any>;
+
+  getDRC20Balance(params: { ticker: string }): Promise<any>;
+  getTransferableDRC20(params: { ticker: string }): Promise<any>;
+  requestAvailableDRC20Transaction(params: { ticker: string; amount: number }): Promise<any>;
+
+  requestInscriptionTransaction(params: {
+    recipientAddress: string;
+    location: string;
+    data?: string;
+    feeRate?: number;
+  }): Promise<any>;
+}

package/src/evm/index.ts

@@ -0,0 +1,3 @@
+import { EvmProvider } from "./metamask";
+
+export { EvmProvider };

package/src/evm/messages.ts

@@ -0,0 +1,39 @@
+const ProductInfo = { name: "ethereum.provider" };
+
+const messages = {
+  errors: {
+    disconnected: () => `${ProductInfo.name}: Disconnected from chain. Attempting to connect.`,
+    permanentlyDisconnected: () =>
+      `${ProductInfo.name}: Disconnected from ${ProductInfo.name} background. Page reload required.`,
+    sendSiteMetadata: () =>
+      `${ProductInfo.name}: Failed to send site metadata. This is an internal error, please report this bug.`,
+    unsupportedSync: (method: string) =>
+      `${ProductInfo.name}: The ${ProductInfo.name} Ethereum provider does not support synchronous methods like ${method} without a callback parameter.`,
+    invalidDuplexStream: () => "Must provide a Node.js-style duplex stream.",
+    invalidOptions: (maxEventListeners: unknown, shouldSendMetadata: unknown) =>
+      `Invalid options. Received: { maxEventListeners: ${maxEventListeners}, shouldSendMetadata: ${shouldSendMetadata} }`,
+    invalidRequestArgs: () => `Expected a single, non-array, object argument.`,
+    invalidRequestMethod: () => `'args.method' must be a non-empty string.`,
+    invalidRequestParams: () => `'args.params' must be an object or array if provided.`,
+    invalidLoggerObject: () => `'args.logger' must be an object if provided.`,
+    invalidLoggerMethod: (method: string) => `'args.logger' must include required method '${method}'.`,
+  },
+  info: {
+    connected: (chainId: string) => `${ProductInfo.name}: Connected to chain with ID "${chainId}".`,
+  },
+  warnings: {
+    // deprecated methods
+    enableDeprecation: `${ProductInfo.name}: 'ethereum.enable()' is deprecated and may be removed in the future. Please use the 'eth_requestAccounts' RPC method instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1102`,
+    sendDeprecation: `${ProductInfo.name}: 'ethereum.send(...)' is deprecated and may be removed in the future. Please use 'ethereum.sendAsync(...)' or 'ethereum.request(...)' instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193`,
+    // deprecated events
+    events: {
+      close: `${ProductInfo.name}: The event 'close' is deprecated and may be removed in the future. Please use 'disconnect' instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#disconnect`,
+      data: `${ProductInfo.name}: The event 'data' is deprecated and will be removed in the future. Use 'message' instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`,
+      networkChanged: `${ProductInfo.name}: The event 'networkChanged' is deprecated and may be removed in the future. Use 'chainChanged' instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#chainchanged`,
+      notification: `${ProductInfo.name}: The event 'notification' is deprecated and may be removed in the future. Use 'message' instead.\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`,
+    },
+    // misc
+    experimentalMethods: `${ProductInfo.name}: 'ethereum._${ProductInfo.name}' exposes non-standard, experimental methods. They may be removed or changed without warning.`,
+  },
+};
+export default messages;