@swapkit/wallets 3.0.0-beta.9 → 4.0.0-beta.39

package/src/helpers/near.ts

@@ -0,0 +1,206 @@
+//TBD @towan to be moved somewhere else
+import { SwapKitError } from "@swapkit/helpers";
+import type { NearSigner } from "@swapkit/toolboxes/near";
+import type { Account } from "near-api-js";
+import {
+  type Action,
+  type Signature,
+  SignedTransaction,
+  type Transaction,
+} from "near-api-js/lib/transaction";
+
+/**
+ * NEAR Browser Wallet Provider Interface
+ * Common interface implemented by browser extension wallets
+ */
+export interface NearBrowserWalletProvider {
+  // Connection methods
+  connect(params?: { contractId?: string; methodNames?: string[] }): Promise<
+    Account[] | { accountId: string }
+  >;
+  disconnect?(): Promise<void>;
+  signOut?(): Promise<void>; // Alternative to disconnect
+
+  // Account methods
+  getAccountId(): string | Promise<string>;
+  getAccounts?(): Promise<Account[]>;
+  isSignedIn(): boolean;
+  getPublicKey?(): Promise<string>;
+
+  // Signing methods
+  signMessage?(params: any): Promise<any>;
+  signAndSendTransaction(params: {
+    receiverId: string;
+    actions: Action[];
+    signerId?: string;
+  }): Promise<any>;
+  signAndSendTransactions?(params: {
+    transactions: Transaction[];
+  }): Promise<any[]>;
+
+  // Optional utility methods
+  request<T>(params: { method: string; params?: any }): Promise<T>;
+  verifyOwner?(params: {
+    message: string;
+    callbackUrl?: string;
+  }): Promise<any>;
+  getNetwork?(): Promise<{ networkId: string; nodeUrl: string }>;
+
+  // Event handlers (optional)
+  on?(event: string, handler: Function): void;
+  off?(event: string, handler: Function): void;
+}
+
+/**
+ * Helper to create a NEAR signer from browser extension providers
+ */
+export async function createNearSignerFromProvider(
+  provider: NearBrowserWalletProvider,
+  walletName: string,
+) {
+  const isConnected = provider.isSignedIn ? provider.isSignedIn() : false;
+  if (!isConnected) {
+    await provider.connect({ contractId: "", methodNames: [] });
+  }
+
+  const signer = {
+    ...provider,
+    async getPublicKey() {
+      // Most browser wallets expose public key through message signing
+      const { utils } = await import("near-api-js");
+
+      if (provider.getPublicKey) {
+        const pubKey = await provider.getPublicKey();
+        return utils.PublicKey.from(pubKey);
+      }
+
+      if (!provider.signMessage) {
+        throw new SwapKitError("wallet_ledger_method_not_supported", {
+          wallet: walletName,
+          method: "getPublicKey",
+        });
+      }
+
+      // Most browser wallets don't expose public key directly
+      // Return a dummy public key
+      const { PublicKey } = await import("near-api-js/lib/utils");
+      // Create a dummy ed25519 public key
+      const dummyKeyData = Buffer.alloc(32);
+      const dummyKey = `ed25519:${Buffer.from(dummyKeyData).toString("base64")}`;
+      return PublicKey.from(dummyKey);
+    },
+
+    async signNep413Message(
+      message: string,
+      _accountId: string,
+      recipient: string,
+      nonce: Uint8Array,
+      callbackUrl?: string,
+    ) {
+      if (!provider.signMessage) {
+        throw new SwapKitError("wallet_ledger_method_not_supported", {
+          wallet: walletName,
+          method: "signNep413Message",
+        });
+      }
+
+      // We know signMessage exists because we checked above
+      const result = await (
+        provider as Required<Pick<NearBrowserWalletProvider, "signMessage">>
+      ).signMessage({
+        message,
+        recipient,
+        nonce: Buffer.from(nonce),
+        callbackUrl,
+      });
+
+      return result;
+    },
+
+    async signTransaction(transaction: Transaction) {
+      if (!provider.request) {
+        throw new SwapKitError("wallet_near_method_not_supported", {
+          wallet: walletName,
+          method: "request",
+        });
+      }
+
+      // Browser wallets typically sign and send in one operation
+      // This is a limitation of browser wallet APIs
+      const result = await provider.request<{ signatures: Signature }>({
+        method: "near_signTransactions",
+        params: {
+          transactions: [transaction], // must be Array type
+        },
+      });
+
+      const signedTransaction = new SignedTransaction({
+        transaction,
+        signature: result.signatures,
+      });
+
+      return [result.signatures.data, signedTransaction] as [
+        Uint8Array<ArrayBufferLike>,
+        SignedTransaction,
+      ];
+    },
+
+    signDelegateAction(_delegateAction: any) {
+      // Most browser wallets don't support delegate actions yet
+      return Promise.reject(
+        new SwapKitError("wallet_ledger_method_not_supported", {
+          wallet: walletName,
+          method: "signDelegateAction",
+        }),
+      );
+    },
+
+    async getAddress() {
+      if (provider.getAccountId) {
+        return provider.getAccountId();
+      }
+
+      if (provider.isSignedIn && !provider.isSignedIn()) {
+        // Try connect method for wallets that don't have requestSignIn
+        const result = await provider.connect();
+        if (Array.isArray(result) && result.length > 0 && result[0]) {
+          return typeof result[0] === "string" ? result[0] : result[0].accountId;
+        }
+        throw new SwapKitError("wallet_connection_rejected_by_user", {
+          wallet: walletName,
+        });
+      }
+
+      throw new SwapKitError("wallet_connection_rejected_by_user", {
+        wallet: walletName,
+      });
+    },
+  };
+
+  return signer as NearSigner;
+}
+
+/**
+ * Detect if a wallet provider supports NEAR
+ */
+export function detectNearProvider(
+  window: any,
+  providerPath: string,
+): NearBrowserWalletProvider | null {
+  const parts = providerPath.split(".");
+  let provider = window;
+
+  for (const part of parts) {
+    provider = provider?.[part];
+    if (!provider) return null;
+  }
+
+  return provider;
+}
+
+/**
+ * Get NEAR chain ID for WalletConnect
+ */
+export function getNearChainId(isTestnet: boolean): string {
+  return isTestnet ? "near:testnet" : "near:mainnet";
+}

package/src/keepkey/chains/cosmos.ts

@@ -21,64 +21,58 @@ export const cosmosWalletMethods = async ({
     getFeeRateFromThorswap,
     createStargateClient,
   } = await import("@swapkit/toolboxes/cosmos");
+  const derivationPathString = derivationPath
+    ? derivationPathToString(derivationPath)
+    : `${DerivationPath.GAIA}/0`;
 
-  try {
-    const derivationPathString = derivationPath
-      ? derivationPathToString(derivationPath)
-      : `${DerivationPath.GAIA}/0`;
+  const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  })) as { address: string };
 
-    const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
-      address_n: bip32ToAddressNList(derivationPathString),
-    })) as { address: string };
+  const toolbox = await getCosmosToolbox(Chain.Cosmos);
 
-    const toolbox = await getCosmosToolbox(Chain.Cosmos);
-
-    if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
-      DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-        await getFeeRateFromThorswap(ChainId.Cosmos, 500),
-      );
-    }
+  if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
+    DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
+      await getFeeRateFromThorswap(ChainId.Cosmos, 500),
+    );
+  }
 
-    // TODO support other cosmos assets
-    const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-      const amount = assetValue.getBaseValue("string");
-      const accountInfo = await toolbox.getAccount(fromAddress);
+  // TODO support other cosmos assets
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
+    const amount = assetValue.getBaseValue("string");
+    const accountInfo = await toolbox.getAccount(fromAddress);
 
-      const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
-        signerAddress: fromAddress,
-        signDoc: {
-          fee: DEFAULT_COSMOS_FEE_MAINNET,
-          memo: memo || "",
-          sequence: accountInfo?.sequence.toString() ?? "",
-          chain_id: ChainId.Cosmos,
-          account_number: accountInfo?.accountNumber.toString() ?? "",
-          msgs: [
-            {
-              value: {
-                amount: [{ denom: "uatom", amount }],
-                to_address: recipient,
-                from_address: fromAddress,
-              },
-              type: "cosmos-sdk/MsgSend",
+    const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
+      signerAddress: fromAddress,
+      signDoc: {
+        fee: DEFAULT_COSMOS_FEE_MAINNET,
+        memo: memo || "",
+        sequence: accountInfo?.sequence.toString() ?? "",
+        chain_id: ChainId.Cosmos,
+        account_number: accountInfo?.accountNumber.toString() ?? "",
+        msgs: [
+          {
+            value: {
+              amount: [{ denom: "uatom", amount }],
+              to_address: recipient,
+              from_address: fromAddress,
             },
-          ],
-        },
-      });
+            type: "cosmos-sdk/MsgSend",
+          },
+        ],
+      },
+    });
 
-      const decodedBytes = atob(keepKeySignedTx.serialized);
-      const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
-        decodedBytes.charCodeAt(i),
-      );
+    const decodedBytes = atob(keepKeySignedTx.serialized);
+    const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
+      decodedBytes.charCodeAt(i),
+    );
 
-      const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
-      const response = await client.broadcastTx(uint8Array);
+    const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
+    const response = await client.broadcastTx(uint8Array);
 
-      return response.transactionHash;
-    };
+    return response.transactionHash;
+  };
 
-    return { ...toolbox, transfer, address: fromAddress };
-  } catch (e) {
-    console.error(e);
-    throw e;
-  }
+  return { ...toolbox, transfer, address: fromAddress };
 };

package/src/keepkey/chains/evm.ts

@@ -4,6 +4,7 @@ import {
   ChainToChainId,
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
@@ -35,7 +36,7 @@ export class KeepKeySigner extends AbstractSigner {
   }
 
   signTypedData(): Promise<string> {
-    throw new Error("this method is not implemented");
+    throw new SwapKitError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
   }
 
   getAddress = async () => {
@@ -62,14 +63,21 @@ export class KeepKeySigner extends AbstractSigner {
     gasPrice,
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
   }: TransactionRequest) => {
-    if (!to) throw new Error("Missing to address");
-    if (!gasLimit) throw new Error("Missing gasLimit");
-    if (!data) throw new Error("Missing data");
+    if (!to)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
+    if (!gasLimit)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
+    if (!data) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing data" });
 
     const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
-    if (isEIP1559 && !maxFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (isEIP1559 && !maxPriorityFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (!(isEIP1559 || gasPrice)) throw new Error("Missing gasPrice");
+    if (isEIP1559 && !maxFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
+    if (isEIP1559 && !maxPriorityFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "Missing maxPriorityFeePerGas",
+      });
+    if (!(isEIP1559 || gasPrice))
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
 
     const { toHexString } = await import("@swapkit/toolboxes/evm");
 
@@ -100,7 +108,7 @@ export class KeepKeySigner extends AbstractSigner {
   };
 
   sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new Error("No provider set");
+    if (!this.provider) throw new SwapKitError("wallet_keepkey_no_provider");
 
     const signedTxHex = await this.signTransaction(tx);
 

package/src/keepkey/chains/mayachain.ts

@@ -7,6 +7,7 @@ import {
   type DerivationPathArray,
   type GenericTransferParams,
   SKConfig,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
@@ -44,11 +45,11 @@ export const mayachainWalletMethods = async ({
     sender,
     memo,
   }: SignTransactionParams) => {
-    const { makeSignDoc } = await import("@cosmjs/amino");
+    const { makeSignDoc } = (await import("@cosmjs/amino")).default;
     const { getDenomWithChain } = await import("@swapkit/toolboxes/cosmos");
 
     const account = await toolbox.getAccount(sender);
-    if (!account) throw new Error("Account not found");
+    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
     const { accountNumber, sequence = 0 } = account;
     const amount = assetValue.getBaseValue("string");
 

package/src/keepkey/chains/ripple.ts

@@ -0,0 +1,118 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
+import {
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  type GenericTransferParams,
+  derivationPathToString,
+} from "@swapkit/helpers";
+import { bip32ToAddressNList } from "../coins";
+
+import { getRippleToolbox } from "@swapkit/toolboxes/ripple";
+
+export const rippleWalletMethods = async ({
+  sdk,
+  derivationPath,
+}: {
+  sdk: KeepKeySdk;
+  derivationPath?: DerivationPathArray;
+}) => {
+  // Derivation path handling (default to standard XRP 44'/144'/0'/0/0)
+  const derivationPathString = derivationPath
+    ? derivationPathToString(derivationPath)
+    : `${DerivationPath[Chain.Ripple]}/0`;
+
+  // Fetch address from KeepKey
+  // @ts-ignore - keepkey-sdk typings may not yet include xrpGetAddress
+  const { address } = await (sdk as any).address.xrpGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  });
+
+  // Inject minimal signer so toolbox's address helpers work
+  const signer = {
+    getAddress: () => Promise.resolve(address),
+    signTransaction: () => {
+      throw new Error("signTransaction not supported via toolbox");
+    },
+  };
+
+  const toolbox = await getRippleToolbox({ signer });
+
+  const transfer = async ({ recipient, assetValue, memo }: GenericTransferParams) => {
+    // Build XRPL Payment tx using toolbox helper
+    const tx = await toolbox.createTransaction({
+      assetValue,
+      recipient,
+      memo,
+      sender: address,
+    });
+
+    // Convert toolbox Payment tx into KeepKey StdTx wrapper (KeepKey-specific format)
+    const stdTx = {
+      type: "auth/StdTx",
+      value: {
+        fee: {
+          amount: [
+            {
+              amount: "1000",
+              denom: "drop",
+            },
+          ],
+          gas: "28000",
+        },
+        memo: memo && memo.length > 0 ? memo : "",
+        msg: [
+          {
+            type: "ripple-sdk/MsgSend",
+            value: {
+              amount: [
+                {
+                  amount: tx.Amount,
+                  denom: "drop",
+                },
+              ],
+              from_address: address,
+              to_address: recipient,
+            },
+          },
+        ],
+        signatures: null,
+      },
+    };
+
+    const unsignedTx = {
+      addressNList: bip32ToAddressNList(derivationPathString),
+      tx: stdTx,
+      flags: tx.Flags === 0 ? undefined : tx.Flags,
+      lastLedgerSequence: tx.LastLedgerSequence?.toString(),
+      sequence: (tx.Sequence ?? 0).toString(),
+      payment: {
+        amount: tx.Amount,
+        destination: tx.Destination,
+        destinationTag: (tx.DestinationTag ?? "0").toString(),
+      },
+    } as any;
+
+    // Sign with KeepKey
+    // @ts-ignore - typings missing
+    const responseSign = JSON.parse(await (sdk as any).xrp.xrpSignTransaction(unsignedTx));
+
+    // keepkey-sdk may return either { tx_blob } or StdTx with Base64 serializedTx
+    const txBlob: string | undefined =
+      (responseSign as any).tx_blob ?? (responseSign as any).value?.signatures?.[0]?.serializedTx;
+    if (!txBlob) throw new Error("KeepKey XRP sign failed");
+
+    const buffer = Buffer.from(txBlob, "base64");
+    const txBlobHex = buffer.toString("hex");
+
+    // Broadcast signed tx via toolbox
+    return toolbox.broadcastTransaction(txBlobHex);
+  };
+
+  return {
+    ...toolbox,
+    address,
+    getAddress: () => address,
+    transfer,
+  };
+};

package/src/keepkey/chains/thorchain.ts

@@ -11,6 +11,7 @@ import {
   type DerivationPathArray,
   type GenericTransferParams,
   SKConfig,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
@@ -31,7 +32,7 @@ export const thorchainWalletMethods = async ({
   sdk: KeepKeySdk;
   derivationPath?: DerivationPathArray;
 }) => {
-  const { makeSignDoc } = await import("@cosmjs/amino");
+  const { makeSignDoc } = (await import("@cosmjs/amino")).default;
   const { buildAminoMsg, getDefaultChainFee, createStargateClient, getCosmosToolbox } =
     await import("@swapkit/toolboxes/cosmos");
 
@@ -51,7 +52,7 @@ export const thorchainWalletMethods = async ({
     memo,
   }: SignTransactionParams) => {
     const account = await toolbox.getAccount(sender);
-    if (!account) throw new Error("Account not found");
+    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
     const { accountNumber, sequence = 0 } = account;
 
     const isTransfer = recipient && recipient !== "";

package/src/keepkey/chains/utxo.ts

@@ -5,6 +5,7 @@ import {
   type DerivationPathArray,
   FeeOption,
   type GenericTransferParams,
+  SwapKitError,
   type UTXOChain,
   derivationPathToString,
 } from "@swapkit/helpers";
@@ -26,7 +27,11 @@ export const utxoWalletMethods = async ({
   sdk,
   chain,
   derivationPath,
-}: { sdk: KeepKeySdk; chain: UTXOChain; derivationPath?: DerivationPathArray }) => {
+}: {
+  sdk: KeepKeySdk;
+  chain: Exclude<UTXOChain, Chain.Zcash>;
+  derivationPath?: DerivationPathArray;
+}) => {
   const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
   // This might not work for BCH
   const toolbox = await getUtxoToolbox(chain);
@@ -101,8 +106,14 @@ export const utxoWalletMethods = async ({
     memo,
     ...rest
   }: GenericTransferParams) => {
-    if (!walletAddress) throw new Error("From address must be provided");
-    if (!recipient) throw new Error("Recipient address must be provided");
+    if (!walletAddress)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "From address must be provided",
+      });
+    if (!recipient)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "Recipient address must be provided",
+      });
 
     const createTxMethod =
       chain === Chain.BitcoinCash

package/src/keepkey/coins.ts

@@ -2,6 +2,8 @@
     KeepKey Specific bip32 path conventions
 */
 
+import { SwapKitError } from "@swapkit/helpers";
+
 const HARDENED = 0x80000000;
 
 export enum ChainToKeepKeyName {
@@ -10,6 +12,7 @@ export enum ChainToKeepKeyName {
   DOGE = "Dogecoin",
   LTC = "Litecoin",
   DASH = "Dash",
+  XRP = "Ripple",
 }
 
 export function addressNListToBIP32(address: number[]) {
@@ -27,7 +30,9 @@ export function bip32ToAddressNList(initPath: string): number[] {
   let path = initPath;
 
   if (!bip32Like(path)) {
-    throw new Error(`Not a bip32 path: '${path}'`);
+    throw new SwapKitError("wallet_keepkey_invalid_params", {
+      reason: `Not a bip32 path: '${path}'`,
+    });
   }
 
   if (/^m\//i.test(path)) {
@@ -44,18 +49,20 @@ export function bip32ToAddressNList(initPath: string): number[] {
     const segment = segments[i];
     if (segment) {
       const tmp = /(\d+)([hH']?)/.exec(segment);
-      if (tmp === null) throw new Error("Invalid input");
+      if (tmp === null)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid input" });
 
       const [, num = "", modifier = ""] = tmp;
 
       ret[i] = Number.parseInt(num, 10);
 
-      if (ret[i] >= HARDENED) throw new Error("Invalid child index");
+      if (ret[i] >= HARDENED)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid child index" });
 
       if (modifier === "h" || modifier === "H" || modifier === "'") {
         ret[i] += HARDENED;
       } else if (modifier.length > 0) {
-        throw new Error("Invalid modifier");
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid modifier" });
       }
     }
   }