@shapeshiftoss/hdwallet-vultisig 1.62.5

package/src/bitcoin.ts

@@ -0,0 +1,171 @@
+import * as bitcoin from "@shapeshiftoss/bitcoinjs-lib";
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { BTCInputScriptType } from "@shapeshiftoss/hdwallet-core";
+
+import { VultisigUtxoProvider } from "./types";
+
+const getNetwork = (coin: string): bitcoin.networks.Network => {
+  switch (coin.toLowerCase()) {
+    case "bitcoin":
+      return bitcoin.networks.bitcoin;
+    default:
+      throw new Error(`Unsupported coin: ${coin}`);
+  }
+};
+
+export async function btcGetAddress(provider: VultisigUtxoProvider, msg: core.BTCGetAddress): Promise<string | null> {
+  const value = await (async () => {
+    switch (msg.coin.toLowerCase()) {
+      case "bitcoin": {
+        const accounts = await provider.request<"request_accounts">({
+          method: "request_accounts",
+          params: [],
+        });
+        return accounts.length > 0 ? accounts[0] : null;
+      }
+      default:
+        throw new Error("Vultisig does not support");
+    }
+  })();
+  if (!value || typeof value !== "string") return null;
+
+  return value;
+}
+
+export const btcGetAccountPaths = (msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath> => {
+  const slip44 = core.slip44ByCoin(msg.coin);
+  if (slip44 === undefined) return [];
+
+  const bip84 = core.segwitNativeAccount(msg.coin, slip44, msg.accountIdx);
+
+  const coinPaths = {
+    bitcoin: [bip84],
+  } as Partial<Record<string, Array<core.BTCAccountPath>>>;
+
+  let paths: Array<core.BTCAccountPath> = coinPaths[msg.coin.toLowerCase()] || [];
+
+  if (msg.scriptType !== undefined) {
+    paths = paths.filter((path) => {
+      return path.scriptType === msg.scriptType;
+    });
+  }
+
+  return paths;
+};
+
+async function addInput(psbt: bitcoin.Psbt, input: core.BTCSignTxInput): Promise<void> {
+  switch (input.scriptType) {
+    case BTCInputScriptType.SpendWitness: {
+      psbt.addInput({
+        hash: input.txid,
+        index: input.vout,
+        nonWitnessUtxo: Buffer.from(input.hex, "hex"),
+      });
+
+      break;
+    }
+    default:
+      throw new Error(`Unsupported script type: ${input.scriptType}`);
+  }
+}
+
+async function addOutput(
+  provider: VultisigUtxoProvider,
+  psbt: bitcoin.Psbt,
+  output: core.BTCSignTxOutput,
+  coin: string
+): Promise<void> {
+  if (!output.amount) throw new Error("Invalid output - missing amount.");
+
+  const address = await (async () => {
+    if (output.address) return output.address;
+
+    if (output.addressNList) {
+      const outputAddress = await btcGetAddress(provider, {
+        addressNList: output.addressNList,
+        coin,
+        showDisplay: false,
+      });
+      if (!outputAddress) throw new Error("Could not get address from wallet");
+      return outputAddress;
+    }
+  })();
+
+  if (!address) throw new Error("Invalid output - no address");
+
+  psbt.addOutput({ address, value: BigInt(output.amount) });
+}
+
+export async function bitcoinSignTx(
+  msg: core.BTCSignTx,
+  provider: VultisigUtxoProvider
+): Promise<core.BTCSignedTx | null> {
+  try {
+    const network = getNetwork(msg.coin);
+    const psbt = new bitcoin.Psbt({ network });
+
+    psbt.setVersion(msg.version ?? 2);
+    if (msg.locktime) {
+      psbt.setLocktime(msg.locktime);
+    }
+
+    for (const input of msg.inputs) {
+      await addInput(psbt, input);
+    }
+
+    for (const output of msg.outputs) {
+      await addOutput(provider, psbt, output, msg.coin);
+    }
+
+    if (msg.opReturnData) {
+      const data = Buffer.from(msg.opReturnData, "utf-8");
+      const embed = bitcoin.payments.embed({ data: [data] });
+      const script = embed.output;
+      if (!script) throw new Error("unable to build OP_RETURN script");
+      // OP_RETURN_DATA output is always 0 value
+      psbt.addOutput({ script, value: BigInt(0) });
+    }
+
+    const inputsToSign = await Promise.all(
+      msg.inputs.map(async (input, index) => {
+        const address = await btcGetAddress(provider, {
+          addressNList: input.addressNList,
+          coin: msg.coin,
+          showDisplay: false,
+        });
+
+        if (!address) throw new Error("Could not get address from wallet");
+
+        return {
+          address,
+          signingIndexes: [index],
+          sigHash: bitcoin.Transaction.SIGHASH_ALL,
+        };
+      })
+    );
+
+    const signedPsbtBuffer = await provider.signPSBT(psbt.toBuffer(), { inputsToSign }, false);
+    const signedPsbt = bitcoin.Psbt.fromBuffer(signedPsbtBuffer, { network });
+
+    signedPsbt.finalizeAllInputs();
+
+    const tx = signedPsbt.extractTransaction();
+
+    // If this is a THORChain transaction, validate the vout ordering
+    if (msg.vaultAddress && !core.validateVoutOrdering(msg, tx)) {
+      throw new Error("Improper vout ordering for BTC Thorchain transaction");
+    }
+
+    const signatures = signedPsbt.data.inputs.map((input) =>
+      input.partialSig ? Buffer.from(input.partialSig[0].signature).toString("hex") : ""
+    );
+
+    return {
+      signatures,
+      serializedTx: tx.toHex(),
+    };
+  } catch (error) {
+    console.error("Error signing with Vultisig:", error);
+    return null;
+  }
+}

package/src/cosmos.ts

@@ -0,0 +1,43 @@
+import { StdTx } from "@cosmjs/amino";
+import { SignerData } from "@cosmjs/stargate";
+import {
+  CosmosAccountPath,
+  CosmosGetAccountPaths,
+  CosmosSignedTx,
+  CosmosSignTx,
+  slip44ByCoin,
+} from "@shapeshiftoss/hdwallet-core";
+import { sign } from "@shapeshiftoss/proto-tx-builder";
+
+import { VultisigOfflineProvider } from "./types";
+
+const ATOM_CHAIN = "cosmoshub-4";
+
+export function cosmosGetAccountPaths(msg: CosmosGetAccountPaths): Array<CosmosAccountPath> {
+  return [
+    {
+      addressNList: [0x80000000 + 44, 0x80000000 + slip44ByCoin("Atom"), 0x80000000 + msg.accountIdx, 0, 0],
+    },
+  ];
+}
+
+export async function cosmosGetAddress(provider: VultisigOfflineProvider): Promise<string | undefined> {
+  const offlineSigner = provider.getOfflineSigner(ATOM_CHAIN);
+  const accounts = await offlineSigner.getAccounts();
+  return accounts[0]?.address;
+}
+
+export async function cosmosSignTx(provider: VultisigOfflineProvider, msg: CosmosSignTx): Promise<CosmosSignedTx> {
+  const offlineSigner = provider.getOfflineSigner(ATOM_CHAIN);
+
+  const address = await cosmosGetAddress(provider);
+  if (!address) throw new Error("failed to get address");
+
+  const signerData: SignerData = {
+    sequence: Number(msg.sequence),
+    accountNumber: Number(msg.account_number),
+    chainId: msg.chain_id,
+  };
+
+  return await sign(address, msg.tx as StdTx, offlineSigner, signerData, "cosmos");
+}

package/src/ethereum.ts

@@ -0,0 +1,169 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { ETHSignedMessage } from "@shapeshiftoss/hdwallet-core";
+import { AddEthereumChainParameter } from "@shapeshiftoss/hdwallet-core";
+import { ethErrors, serializeError } from "eth-rpc-errors";
+import { isHexString } from "ethers/lib/utils";
+
+import { VultisigEvmProvider } from "./types";
+
+export function ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath> {
+  const slip44 = core.slip44ByCoin(msg.coin);
+  if (slip44 === undefined) return [];
+  return [
+    {
+      addressNList: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx, 0, 0],
+      hardenedPath: [0x80000000 + 44, 0x80000000 + slip44, 0x80000000 + msg.accountIdx],
+      relPath: [0, 0],
+      description: "Vultisig",
+    },
+  ];
+}
+
+export async function ethSendTx(
+  msg: core.ETHSignTx,
+  vultisig: VultisigEvmProvider,
+  from: string
+): Promise<core.ETHTxHash | null> {
+  try {
+    const utxBase = {
+      from: from,
+      to: msg.to,
+      value: msg.value,
+      nonce: msg.nonce,
+      chainId: msg.chainId,
+      data: msg.data,
+      gas: msg.gasLimit,
+    };
+
+    const utx = msg.maxFeePerGas
+      ? {
+          ...utxBase,
+          maxFeePerGas: msg.maxFeePerGas,
+          maxPriorityFeePerGas: msg.maxPriorityFeePerGas,
+        }
+      : { ...utxBase, gasPrice: msg.gasPrice };
+
+    const signedTx = await vultisig.request?.({
+      method: "eth_sendTransaction",
+      params: [utx],
+    });
+
+    return { hash: signedTx } as core.ETHTxHash;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethSignMessage(
+  msg: core.ETHSignMessage,
+  vultisig: VultisigEvmProvider,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    if (!isHexString(msg.message)) throw new Error("data is not an hex string");
+    const signedMsg = await vultisig.request?.({
+      method: "personal_sign",
+      params: [msg.message, address],
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethSignTypedData(
+  msg: core.ETHSignTypedData,
+  vultisig: VultisigEvmProvider,
+  address: string
+): Promise<core.ETHSignedMessage | null> {
+  try {
+    const signedMsg = await vultisig.request?.({
+      method: "eth_signTypedData_v4",
+      params: [address, JSON.stringify(msg.typedData)],
+    });
+
+    return {
+      address: address,
+      signature: signedMsg,
+    } as ETHSignedMessage;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function ethGetAddress(vultisig: VultisigEvmProvider): Promise<core.Address | null> {
+  if (!(vultisig && vultisig.request)) {
+    return null;
+  }
+  try {
+    const ethAccounts = await vultisig.request({
+      method: "eth_accounts",
+    });
+    return ethAccounts[0];
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+export async function ethGetChainId(evmProvider: VultisigEvmProvider): Promise<number | null> {
+  try {
+    // chainId as hex string
+    const chainId: string = (await evmProvider?.request?.({ method: "eth_chainId" })) || "";
+    return parseInt(chainId, 16);
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+export async function ethAddChain(evmProvider: VultisigEvmProvider, params: AddEthereumChainParameter): Promise<void> {
+  // at this point, we know that we're in the context of a valid Coinbase provider
+  await evmProvider?.request?.({ method: "wallet_addEthereumChain", params: [params] });
+}
+
+export async function ethSwitchChain(
+  evmProvider: VultisigEvmProvider,
+  params: AddEthereumChainParameter
+): Promise<void> {
+  try {
+    // at this point, we know that we're in the context of a valid Coinbase provider
+    await evmProvider?.request?.({ method: "wallet_switchEthereumChain", params: [{ chainId: params.chainId }] });
+  } catch (e: any) {
+    const error = serializeError(e);
+    if (error.code === -32603) {
+      try {
+        await ethAddChain(evmProvider, params);
+        return;
+      } catch (addChainE: any) {
+        const addChainError = serializeError(addChainE);
+
+        if (addChainError.code === 4001) {
+          throw ethErrors.provider.userRejectedRequest();
+        }
+
+        throw (addChainError.data as any).originalError as {
+          code: number;
+          message: string;
+          stack: string;
+        };
+      }
+    }
+
+    if (error.code === 4001) {
+      throw ethErrors.provider.userRejectedRequest();
+    }
+
+    throw (error.data as any).originalError as {
+      code: number;
+      message: string;
+      stack: string;
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./adapter";
+export * from "./vultisig";

package/src/solana.ts

@@ -0,0 +1,31 @@
+import * as core from "@shapeshiftoss/hdwallet-core";
+import { PublicKey } from "@solana/web3.js";
+
+import { VultisigSolanaProvider } from "./types";
+
+export type SolanaAccount = {
+  publicKey: PublicKey;
+};
+
+export async function solanaSignTx(
+  msg: core.SolanaSignTx,
+  provider: VultisigSolanaProvider,
+  address: string
+): Promise<core.SolanaSignedTx | null> {
+  const transaction = core.solanaBuildTransaction(msg, address);
+  const signedTransaction = await provider.signTransaction(transaction);
+  return {
+    serialized: Buffer.from(signedTransaction.serialize()).toString("base64"),
+    signatures: signedTransaction.signatures.map((signature) => Buffer.from(signature).toString("base64")),
+  };
+}
+
+export async function solanaSendTx(
+  msg: core.SolanaSignTx,
+  provider: VultisigSolanaProvider,
+  address: string
+): Promise<core.SolanaTxSignature | null> {
+  const transaction = core.solanaBuildTransaction(msg, address);
+  const { signature } = await provider.signAndSendTransaction(transaction);
+  return { signature };
+}

package/src/thorchain.ts

@@ -0,0 +1,43 @@
+import { StdTx } from "@cosmjs/amino";
+import { SignerData } from "@cosmjs/stargate";
+import {
+  CosmosAccountPath,
+  CosmosGetAccountPaths,
+  CosmosSignedTx,
+  CosmosSignTx,
+  slip44ByCoin,
+} from "@shapeshiftoss/hdwallet-core";
+import { sign } from "@shapeshiftoss/proto-tx-builder";
+
+import { VultisigOfflineProvider } from "./types";
+
+export function thorchainGetAccountPaths(msg: CosmosGetAccountPaths): Array<CosmosAccountPath> {
+  return [
+    {
+      addressNList: [0x80000000 + 44, 0x80000000 + slip44ByCoin("Thorchain"), 0x80000000 + msg.accountIdx, 0, 0],
+    },
+  ];
+}
+
+export async function thorchainGetAddress(provider: VultisigOfflineProvider): Promise<string | undefined> {
+  const offlineSigner = provider.getOfflineSigner("thorchain-1");
+  const accounts = await offlineSigner.getAccounts();
+  return accounts[0].address;
+}
+
+export async function thorchainSignTx(provider: VultisigOfflineProvider, msg: CosmosSignTx): Promise<CosmosSignedTx> {
+  const offlineSigner = provider.getOfflineSigner(msg.chain_id);
+
+  const address = await thorchainGetAddress(provider);
+  if (!address) throw new Error("failed to get address");
+
+  const signerData: SignerData = {
+    sequence: Number(msg.sequence),
+    accountNumber: Number(msg.account_number),
+    chainId: msg.chain_id,
+  };
+
+  const result = await sign(address, msg.tx as StdTx, offlineSigner, signerData, "thor");
+
+  return result;
+}

package/src/types.ts

@@ -0,0 +1,62 @@
+import { OfflineSigner } from "@cosmjs/proto-signing";
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { TransactionSignature } from "@solana/web3.js";
+import { providers } from "ethers";
+
+import { SolanaAccount } from "./solana";
+
+export type VultisigRequestParams = {
+  get_accounts: [];
+  request_accounts: [];
+};
+
+type VultisigRequestReturn = {
+  get_accounts: Promise<string[]>;
+  request_accounts: Promise<string[]>;
+};
+
+type VultisigRequestMethod = keyof VultisigRequestParams;
+
+export type VultisigRequestPayload<M extends VultisigRequestMethod> = {
+  method: M;
+  params: VultisigRequestParams[M];
+};
+
+export type VultisigEvmProvider = providers.ExternalProvider;
+
+export type VultisigUtxoProvider = {
+  request<M extends VultisigRequestMethod>(payload: VultisigRequestPayload<M>): Promise<VultisigRequestReturn[M]>;
+  signPSBT(
+    psbt: Uint8Array,
+    {
+      inputsToSign,
+    }: {
+      inputsToSign: {
+        address: string;
+        signingIndexes: number[];
+        sigHash?: number;
+      }[];
+    },
+    broadcast: boolean
+  ): Promise<Uint8Array>;
+};
+
+export type VultisigSolanaProvider = providers.ExternalProvider & {
+  publicKey?: PublicKey;
+  connect(): Promise<SolanaAccount>;
+  signTransaction(transaction: VersionedTransaction): Promise<VersionedTransaction>;
+  signAndSendTransaction(transaction: VersionedTransaction): Promise<{ signature: TransactionSignature }>;
+};
+
+export type VultisigOfflineProvider = providers.ExternalProvider & {
+  getOfflineSigner(chainId: string): OfflineSigner;
+};
+
+export type VultisigGetVault = {
+  hexChainCode: string;
+  isFastVault: boolean;
+  name: string;
+  publicKeyEcdsa: string;
+  publicKeyEddsa: string;
+  uid: string;
+};