@shapeshiftoss/hdwallet-vultisig 1.62.5

package/src/vultisig.test.ts

@@ -0,0 +1,253 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+
+import { VultisigHDWallet } from ".";
+import { VultisigSolanaProvider, VultisigUtxoProvider } from "./types";
+
+describe("VultisigHDWallet", () => {
+  let wallet: VultisigHDWallet;
+
+  beforeEach(() => {
+    wallet = new VultisigHDWallet({
+      evmProvider: core.untouchable("VultisigHDWallet:provider"),
+      bitcoinProvider: core.untouchable("VultisigHDWallet:provider"),
+      solanaProvider: core.untouchable("VultisigHDWallet:provider"),
+      thorchainProvider: core.untouchable("VultisigHDWallet:provider"),
+      cosmosProvider: core.untouchable("VultisigHDWallet:provider"),
+    });
+  });
+
+  it("should match the metadata", async () => {
+    expect(wallet.getVendor()).toBe("Vultisig");
+    expect(wallet.hasOnDevicePinEntry()).toBe(false);
+    expect(wallet.hasOnDevicePassphrase()).toBe(false);
+    expect(wallet.hasOnDeviceDisplay()).toBe(true);
+    expect(wallet.hasOnDeviceRecovery()).toBe(true);
+    expect(await wallet.ethSupportsNetwork(1)).toBe(true);
+    expect(await wallet.ethSupportsSecureTransfer()).toBe(false);
+    expect(wallet.ethSupportsNativeShapeShift()).toBe(false);
+    expect(await wallet.ethSupportsEIP1559()).toBe(true);
+    expect(wallet.supportsOfflineSigning()).toBe(false);
+    expect(wallet.supportsBip44Accounts()).toBe(false);
+    expect(wallet.supportsBroadcast()).toBe(true);
+  });
+
+  describe("Ethereum", () => {
+    it("ethGetAddress returns a valid address", async () => {
+      wallet.evmProvider = {
+        request: jest.fn().mockReturnValue(["0x73d0385F4d8E00C5e6504C6030F47BF6212736A8"]),
+      };
+
+      const address = await wallet.ethGetAddress({ addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0") });
+
+      expect(address).toEqual("0x73d0385F4d8E00C5e6504C6030F47BF6212736A8");
+    });
+
+    it("ethSendTx returns a valid hash", async () => {
+      wallet.evmProvider = {
+        request: jest.fn().mockReturnValue("0x123"),
+      };
+
+      const hash = await wallet.ethSendTx({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        nonce: "0xDEADBEEF",
+        gasPrice: "0xDEADBEEF",
+        gasLimit: "0xDEADBEEF",
+        to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        chainId: 1,
+      });
+      expect(wallet.evmProvider.request).toHaveBeenCalled();
+      expect(hash).toMatchObject({ hash: "0x123" });
+    });
+
+    it("ethSendTx returns a valid hash if maxFeePerGas is present in msg", async () => {
+      wallet.evmProvider = {
+        request: jest.fn().mockReturnValue("0x123"),
+      };
+
+      const hash = await wallet.ethSendTx({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        nonce: "0xDEADBEEF",
+        gasLimit: "0xDEADBEEF",
+        maxFeePerGas: "0xDEADBEEF",
+        to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        chainId: 1,
+      });
+      expect(wallet.evmProvider.request).toHaveBeenCalled();
+      expect(hash).toMatchObject({ hash: "0x123" });
+    });
+
+    it("ethSendTx returns null on error", async () => {
+      wallet.evmProvider = {
+        request: jest.fn().mockRejectedValue(new Error("An Error has occurred")),
+      };
+
+      const hash = await wallet.ethSendTx({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        nonce: "0xDEADBEEF",
+        gasPrice: "0xDEADBEEF",
+        gasLimit: "0xDEADBEEF",
+        to: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        value: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        data: "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF",
+        chainId: 1,
+      });
+      expect(wallet.evmProvider.request).toHaveBeenCalled();
+      expect(hash).toBe(null);
+    });
+
+    it("should test ethSignMessage", async () => {
+      wallet.evmProvider = {
+        request: jest
+          .fn()
+          .mockReturnValue(
+            "0x05f51140905ffa33ffdc57f46b0b8d8fbb1d2a99f8cd843ca27893c01c31351c08b76d83dce412731c846e3b50649724415deb522d00950fbf4f2c1459c2b70b1b"
+          ),
+      };
+      const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+      expect(
+        await wallet.ethSignMessage({
+          addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+          message: msg,
+        })
+      ).toMatchInlineSnapshot(`
+        Object {
+          "address": "0",
+          "signature": "0x05f51140905ffa33ffdc57f46b0b8d8fbb1d2a99f8cd843ca27893c01c31351c08b76d83dce412731c846e3b50649724415deb522d00950fbf4f2c1459c2b70b1b",
+        }
+      `);
+    });
+
+    it("ethSignMessage returns null on error", async () => {
+      wallet.evmProvider = {
+        request: jest.fn().mockRejectedValue(new Error("An Error has occurred")),
+      };
+
+      const msg = "0x737570657220736563726574206d657373616765"; // super secret message
+      const sig = await wallet.ethSignMessage({
+        addressNList: core.bip32ToAddressNList("m/44'/60'/0'/0/0"),
+        message: msg,
+      });
+
+      expect(sig).toBe(null);
+    });
+
+    it("ethVerifyMessage returns true for a valid signature", async () => {
+      expect(
+        await wallet.ethVerifyMessage({
+          address: "0x2068dD92B6690255553141Dfcf00dF308281f763",
+          message: "Hello World",
+          signature:
+            "0x61f1dda82e9c3800e960894396c9ce8164fd1526fccb136c71b88442405f7d09721725629915d10bc7cecfca2818fe76bc5816ed96a1b0cebee9b03b052980131b",
+        })
+      ).toEqual(true);
+    });
+  });
+
+  describe("Bitcoin", () => {
+    it("btcGetAddress returns a valid address", async () => {
+      wallet.bitcoinProvider = {
+        request: jest.fn().mockReturnValue(["bc1q9sjm947kn2hz84syykmem7dshvevm8xm5dkrpg"]),
+      } as unknown as VultisigUtxoProvider;
+
+      const address = await wallet.btcGetAddress({
+        coin: "Bitcoin",
+      } as core.BTCGetAddress);
+
+      expect(address).toEqual("bc1q9sjm947kn2hz84syykmem7dshvevm8xm5dkrpg");
+    });
+
+    // TODO: hippo: Add tests for getAddress over non-supported script types
+
+    describe("btcGetAccountPaths", () => {
+      it("should return correct paths for Bitcoin (BIP84)", () => {
+        const paths = wallet.btcGetAccountPaths({
+          coin: "Bitcoin",
+          accountIdx: 0,
+        });
+
+        expect(paths).toHaveLength(1);
+        expect(paths[0]).toEqual({
+          coin: "Bitcoin",
+          scriptType: core.BTCInputScriptType.SpendWitness,
+          addressNList: [0x80000000 + 84, 0x80000000 + 0, 0x80000000 + 0],
+        });
+      });
+
+      it("should filter paths by scriptType when specified", () => {
+        const paths = wallet.btcGetAccountPaths({
+          coin: "Bitcoin",
+          accountIdx: 0,
+          scriptType: core.BTCInputScriptType.SpendWitness,
+        });
+
+        expect(paths).toHaveLength(1);
+        expect(paths[0].scriptType).toBe(core.BTCInputScriptType.SpendWitness);
+      });
+
+      it("should return empty array for unsupported coin", () => {
+        const paths = wallet.btcGetAccountPaths({
+          coin: "UnsupportedCoin" as any,
+          accountIdx: 0,
+        });
+
+        expect(paths).toHaveLength(0);
+      });
+    });
+
+    describe("btcSupportsScriptType", () => {
+      it("should support SpendWitness for Bitcoin", async () => {
+        const result = await wallet.btcSupportsScriptType("Bitcoin", core.BTCInputScriptType.SpendWitness);
+        expect(result).toBe(true);
+      });
+
+      it("should support SpendAddress for Bitcoin", async () => {
+        const result = await wallet.btcSupportsScriptType("Bitcoin", core.BTCInputScriptType.SpendAddress);
+        expect(result).toBe(true);
+      });
+
+      it("should NOT support SpendP2SHWitness for any coin", async () => {
+        const coins = ["Bitcoin"];
+        for (const coin of coins) {
+          const result = await wallet.btcSupportsScriptType(coin, core.BTCInputScriptType.SpendP2SHWitness);
+          expect(result).toBe(false);
+        }
+      });
+
+      it("should NOT support unsupported script types", async () => {
+        const coins = ["Bitcoin"];
+        for (const coin of coins) {
+          const result = await wallet.btcSupportsScriptType(coin, "UnsupportedScriptType" as any);
+          expect(result).toBe(false);
+        }
+      });
+
+      it("should return false for unsupported coin", async () => {
+        const result = await wallet.btcSupportsScriptType(
+          "UnsupportedCoin" as any,
+          core.BTCInputScriptType.SpendWitness
+        );
+        expect(result).toBe(false);
+      });
+    });
+  });
+
+  describe("Solana", () => {
+    it("solanaGetAddress returns a valid address", async () => {
+      wallet.solanaProvider = {
+        connect: jest.fn().mockReturnValue({
+          publicKey: "DsYwEVzeSNMkU5PVwjwtZ8EDRQxaR6paXfFAdhMQxmaV",
+        }),
+      } as unknown as VultisigSolanaProvider;
+
+      const address = await wallet.solanaGetAddress();
+
+      expect(address).toEqual("DsYwEVzeSNMkU5PVwjwtZ8EDRQxaR6paXfFAdhMQxmaV");
+    });
+  });
+
+  // TODO: hippo: Missing tests for Thorchain and Cosmos
+});

package/src/vultisig.ts

@@ -0,0 +1,459 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { Address } from "@shapeshiftoss/hdwallet-core";
+import Base64 from "base64-js";
+import * as bitcoinMsg from "bitcoinjs-message";
+import { keccak256, recoverAddress } from "ethers/lib/utils.js";
+import isObject from "lodash/isObject";
+
+import * as btc from "./bitcoin";
+import * as cosmos from "./cosmos";
+import * as eth from "./ethereum";
+import { solanaSendTx, solanaSignTx } from "./solana";
+import * as thorchain from "./thorchain";
+import { VultisigEvmProvider, VultisigOfflineProvider, VultisigSolanaProvider, VultisigUtxoProvider } from "./types";
+
+export function isVultisig(wallet: core.HDWallet): wallet is VultisigHDWallet {
+  return isObject(wallet) && (wallet as any)._isVultisig;
+}
+
+export class VultisigHDWalletInfo
+  implements
+    core.HDWalletInfo,
+    core.BTCWalletInfo,
+    core.ETHWalletInfo,
+    core.SolanaWalletInfo,
+    core.ThorchainWalletInfo,
+    core.CosmosWalletInfo
+{
+  // TODO(gomes): turn me back once signPSBT is fixed upstream
+  readonly _supportsBTCInfo = false;
+  readonly _supportsETHInfo = true;
+  readonly _supportsSolanaInfo = true;
+  readonly _supportsThorchainInfo = true;
+  readonly _supportsCosmosInfo = true;
+
+  constructor() {}
+
+  public getVendor(): string {
+    return "Vultisig";
+  }
+
+  public hasOnDevicePinEntry(): boolean {
+    return false;
+  }
+
+  public hasOnDevicePassphrase(): boolean {
+    return false;
+  }
+
+  public hasOnDeviceDisplay(): boolean {
+    return true;
+  }
+
+  public hasOnDeviceRecovery(): boolean {
+    return true;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public hasNativeShapeShift(srcCoin: core.Coin, dstCoin: core.Coin): boolean {
+    return false;
+  }
+
+  public supportsBip44Accounts(): boolean {
+    return false;
+  }
+
+  public supportsOfflineSigning(): boolean {
+    return false;
+  }
+
+  public supportsBroadcast(): boolean {
+    return true;
+  }
+
+  public describePath(msg: core.DescribePath): core.PathDescription {
+    switch (msg.coin.toLowerCase()) {
+      case "bitcoin": {
+        // case "zcash": // case "bitcoincash": // case "dogecoin": // case "litecoin":
+        const unknown = core.unknownUTXOPath(msg.path, msg.coin, msg.scriptType);
+
+        if (!msg.scriptType) return unknown;
+        if (!this.btcSupportsCoin(msg.coin)) return unknown;
+        if (!this.btcSupportsScriptType(msg.coin, msg.scriptType)) return unknown;
+
+        return core.describeUTXOPath(msg.path, msg.coin, msg.scriptType);
+      }
+      case "ethereum": {
+        return core.describeETHPath(msg.path);
+      }
+      case "solana":
+        return core.solanaDescribePath(msg.path);
+      case "cosmos":
+        return core.cosmosDescribePath(msg.path);
+      case "thorchain":
+        return core.thorchainDescribePath(msg.path);
+      default:
+        throw new Error(`Unsupported path for coin: ${msg.coin}`);
+    }
+  }
+
+  /** Ethereum */
+
+  public async ethSupportsNetwork(chainId = 1): Promise<boolean> {
+    return chainId === 1;
+  }
+
+  public async ethSupportsSecureTransfer(): Promise<boolean> {
+    return false;
+  }
+
+  public ethSupportsNativeShapeShift(): boolean {
+    return false;
+  }
+
+  public async ethSupportsEIP1559(): Promise<boolean> {
+    return true;
+  }
+
+  public ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath> {
+    return eth.ethGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public ethNextAccountPath(msg: core.ETHAccountPath): core.ETHAccountPath | undefined {
+    console.error("Method not implemented");
+    return undefined;
+  }
+
+  /** Bitcoin */
+
+  public async btcSupportsCoin(coin: core.Coin): Promise<boolean> {
+    const vultisigSupportedCoins = ["bitcoin"]; // Just BTC for first part of integration, we will enable it progressively
+    return vultisigSupportedCoins.includes(coin.toLowerCase());
+  }
+
+  public async btcSupportsScriptType(coin: string, scriptType?: core.BTCInputScriptType | undefined): Promise<boolean> {
+    if (!this.btcSupportsCoin(coin)) return false;
+
+    const c = coin.toLowerCase();
+    switch (scriptType) {
+      case core.BTCInputScriptType.SpendAddress:
+        return ["bitcoin"].includes(c);
+      case core.BTCInputScriptType.SpendWitness:
+        return ["bitcoin"].includes(c);
+      default:
+        return false;
+    }
+  }
+
+  public async btcSupportsSecureTransfer(): Promise<boolean> {
+    return false;
+  }
+
+  public btcSupportsNativeShapeShift(): boolean {
+    return false;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public btcGetAccountPaths(msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath> {
+    return btc.btcGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public btcNextAccountPath(msg: core.BTCAccountPath): core.BTCAccountPath | undefined {
+    throw new Error("Method not implemented");
+  }
+
+  /** Solana */
+
+  public solanaGetAccountPaths(msg: core.SolanaGetAccountPaths): Array<core.SolanaAccountPath> {
+    return core.solanaGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public solanaNextAccountPath(msg: core.SolanaAccountPath): core.SolanaAccountPath | undefined {
+    throw new Error("Method not implemented");
+  }
+
+  public thorchainGetAccountPaths(msg: core.ThorchainGetAccountPaths): Array<core.ThorchainAccountPath> {
+    return thorchain.thorchainGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public thorchainNextAccountPath(msg: core.ThorchainAccountPath): core.ThorchainAccountPath | undefined {
+    throw new Error("Method not implemented.");
+  }
+
+  public cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): Array<core.CosmosAccountPath> {
+    return cosmos.cosmosGetAccountPaths(msg);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public cosmosNextAccountPath(_msg: core.CosmosAccountPath): core.CosmosAccountPath | undefined {
+    throw new Error("Method not implemented.");
+  }
+}
+
+export class VultisigHDWallet
+  extends VultisigHDWalletInfo
+  implements core.HDWallet, core.BTCWallet, core.ETHWallet, core.SolanaWallet, core.ThorchainWallet, core.CosmosWallet
+{
+  // TODO(gomes): turn me back once signPSBT is fixed upstream
+  readonly _supportsBTC = false;
+  readonly _supportsETH = true;
+  readonly _supportsEthSwitchChain = true;
+  readonly _supportsAvalanche = true;
+  readonly _supportsOptimism = true;
+  readonly _supportsPolygon = true;
+  readonly _supportsGnosis = false;
+  readonly _supportsArbitrum = true;
+  readonly _supportsArbitrumNova = false;
+  readonly _supportsBase = true;
+  readonly _supportsBSC = true;
+  readonly _supportsSolana = true;
+  readonly _supportsThorchain = true;
+  readonly _supportsCosmos = true;
+  readonly _isVultisig = true;
+
+  evmProvider: VultisigEvmProvider;
+  bitcoinProvider: VultisigUtxoProvider;
+  solanaProvider: VultisigSolanaProvider;
+  thorchainProvider: VultisigOfflineProvider;
+  cosmosProvider: VultisigOfflineProvider;
+
+  ethAddress?: Address | null;
+
+  constructor(providers: {
+    evmProvider: VultisigEvmProvider;
+    bitcoinProvider: VultisigUtxoProvider;
+    solanaProvider: VultisigSolanaProvider;
+    thorchainProvider: VultisigOfflineProvider;
+    cosmosProvider: VultisigOfflineProvider;
+  }) {
+    super();
+
+    this.evmProvider = providers.evmProvider;
+    this.bitcoinProvider = providers.bitcoinProvider;
+    this.solanaProvider = providers.solanaProvider;
+    this.thorchainProvider = providers.thorchainProvider;
+    this.cosmosProvider = providers.cosmosProvider;
+  }
+
+  transport?: core.Transport | undefined;
+
+  public async getDeviceID(): Promise<string> {
+    return "vultisig:" + (await this.getVault());
+  }
+
+  async getFeatures(): Promise<Record<string, any>> {
+    return {};
+  }
+
+  public async getFirmwareVersion(): Promise<string> {
+    return "vultisig";
+  }
+
+  public async getModel(): Promise<string> {
+    return "Vultisig";
+  }
+
+  public async getLabel(): Promise<string> {
+    return "Vultisig";
+  }
+
+  public async isInitialized(): Promise<boolean> {
+    return true;
+  }
+
+  public async isLocked(): Promise<boolean> {
+    return false;
+  }
+
+  public async clearSession(): Promise<void> {}
+
+  public async initialize(): Promise<void> {}
+
+  public async ping(msg: core.Ping): Promise<core.Pong> {
+    return { msg: msg.msg };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendPin(pin: string): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendPassphrase(passphrase: string): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendCharacter(charater: string): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async sendWord(word: string): Promise<void> {}
+
+  public async cancel(): Promise<void> {}
+
+  public async wipe(): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async reset(msg: core.ResetDevice): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async recover(msg: core.RecoverDevice): Promise<void> {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async loadDevice(msg: core.LoadDevice): Promise<void> {}
+
+  public async disconnect(): Promise<void> {}
+
+  public async getPublicKeys(msg: Array<core.GetPublicKey>): Promise<Array<core.PublicKey | null>> {
+    return await Promise.all(
+      msg.map(async (getPublicKey) => {
+        const { coin, scriptType } = getPublicKey;
+
+        if (scriptType !== undefined) {
+          const isSupported = await this.btcSupportsScriptType(coin, scriptType);
+          if (!isSupported) {
+            return null;
+          }
+        }
+
+        switch (coin) {
+          case "Bitcoin": {
+            // Note this is a pubKey, not an xpub, however vultisig does not support utxo derivation,
+            // so this functions as an account (xpub) for all intents and purposes
+            const pubKey = await this.btcGetAddress({ coin, scriptType } as core.BTCGetAddress);
+            return { xpub: pubKey } as core.PublicKey;
+          }
+          default:
+            break;
+        }
+        throw new Error("Vultisig does not support");
+      })
+    );
+  }
+
+  /** Ethereum */
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async ethGetAddress(_msg: core.ETHGetAddress): Promise<core.Address | null> {
+    const address = await eth.ethGetAddress(this.evmProvider);
+
+    if (address) {
+      this.ethAddress = address;
+      return address;
+    } else {
+      this.ethAddress = null;
+      return null;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async ethSignTx(msg: core.ETHSignTx): Promise<core.ETHSignedTx | null> {
+    console.error("Method not implemented");
+    return null;
+  }
+
+  public async ethSendTx(msg: core.ETHSignTx): Promise<core.ETHTxHash | null> {
+    const address = await this.ethGetAddress({ addressNList: [] });
+    return address ? eth.ethSendTx(msg, this.evmProvider, address) : null;
+  }
+
+  public async ethSignMessage(msg: core.ETHSignMessage): Promise<core.ETHSignedMessage | null> {
+    const address = await this.ethGetAddress({ addressNList: [] });
+    return address ? eth.ethSignMessage(msg, this.evmProvider, address) : null;
+  }
+
+  async ethSignTypedData(msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData | null> {
+    const address = await this.ethGetAddress({ addressNList: [] });
+    return address ? eth.ethSignTypedData(msg, this.evmProvider, address) : null;
+  }
+
+  public async ethVerifyMessage(msg: core.ETHVerifyMessage): Promise<boolean | null> {
+    if (!msg.signature.startsWith("0x")) msg.signature = `0x${msg.signature}`;
+    const digest = keccak256(core.buildMessage(msg.message));
+    return recoverAddress(digest, msg.signature) === msg.address;
+  }
+
+  public async ethGetChainId(): Promise<number | null> {
+    return eth.ethGetChainId(this.evmProvider);
+  }
+
+  public async ethAddChain(params: core.AddEthereumChainParameter): Promise<void> {
+    return eth.ethAddChain(this.evmProvider, params);
+  }
+
+  public async ethSwitchChain(params: core.AddEthereumChainParameter): Promise<void> {
+    return eth.ethSwitchChain(this.evmProvider, params);
+  }
+
+  /** Bitcoin */
+
+  public async btcGetAddress(msg: core.BTCGetAddress): Promise<string | null> {
+    return btc.btcGetAddress(this.bitcoinProvider, msg);
+  }
+
+  public async btcSignTx(msg: core.BTCSignTx): Promise<core.BTCSignedTx | null> {
+    const { coin } = msg;
+    switch (coin) {
+      case "Bitcoin":
+        return btc.bitcoinSignTx(msg, this.bitcoinProvider);
+      default:
+        throw new Error("Vultisig does not support");
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async btcSignMessage(msg: core.BTCSignMessage): Promise<core.BTCSignedMessage | null> {
+    throw new Error("not supported");
+  }
+
+  public async btcVerifyMessage(msg: core.BTCVerifyMessage): Promise<boolean | null> {
+    const signature = Base64.fromByteArray(core.fromHexString(msg.signature));
+    return bitcoinMsg.verify(msg.message, msg.address, signature);
+  }
+
+  /** get vault */
+
+  public async getVault(): Promise<string | null> {
+    const vault = await window.vultisig?.getVault();
+    return vault?.uid || null;
+  }
+
+  /** Solana */
+
+  public async solanaGetAddress(): Promise<string | null> {
+    const { publicKey } = await this.solanaProvider.connect();
+    return publicKey.toString();
+  }
+
+  public async solanaSignTx(msg: core.SolanaSignTx): Promise<core.SolanaSignedTx | null> {
+    const address = await this.solanaGetAddress();
+    return address ? solanaSignTx(msg, this.solanaProvider, address) : null;
+  }
+
+  public async solanaSendTx(msg: core.SolanaSignTx): Promise<core.SolanaTxSignature | null> {
+    const address = await this.solanaGetAddress();
+    return address ? solanaSendTx(msg, this.solanaProvider, address) : null;
+  }
+
+  /** THORChain */
+
+  public async thorchainGetAddress(): Promise<string | null> {
+    const address = await thorchain.thorchainGetAddress(this.thorchainProvider);
+    return address || null;
+  }
+
+  public async thorchainSignTx(msg: core.ThorchainSignTx): Promise<core.ThorchainSignedTx | null> {
+    return thorchain.thorchainSignTx(this.thorchainProvider, msg);
+  }
+
+  /** Cosmos */
+
+  public async cosmosGetAddress(): Promise<string | null> {
+    const address = await cosmos.cosmosGetAddress(this.cosmosProvider);
+    return address || null;
+  }
+
+  public async cosmosSignTx(msg: core.CosmosSignTx): Promise<core.CosmosSignedTx | null> {
+    return cosmos.cosmosSignTx(this.cosmosProvider, msg);
+  }
+}