@swapkit/wallets 3.0.0-beta.21 → 3.0.0-beta.23

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/keystore/index.ts

@@ -24,6 +24,7 @@ export const keystoreWallet = createWallet({
     Chain.Ripple,
     Chain.Solana,
     Chain.Tron,
+    Chain.Near,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectKeystore(

package/src/ledger/clients/near.ts

@@ -0,0 +1,86 @@
+import type Transport from "@ledgerhq/hw-transport";
+import type { DerivationPathArray } from "@swapkit/helpers";
+import type { NearSigner } from "@swapkit/toolboxes/near";
+import type { SignedTransaction, Transaction } from "near-api-js/lib/transaction";
+
+export async function getNearLedgerClient(
+  transport: Transport,
+  derivationPath?: DerivationPathArray,
+) {
+  const Near = await import("@ledgerhq/hw-app-near");
+  const { Chain, DerivationPath, derivationPathToString, SwapKitError } = await import(
+    "@swapkit/helpers"
+  );
+  const nearApp = new Near.default(transport);
+
+  // NEAR uses m/44'/397'/0'/0'/0' by default
+  const path = derivationPath ? derivationPathToString(derivationPath) : DerivationPath[Chain.Near];
+
+  // Get address and public key from Ledger
+  const { address, publicKey: pubKeyHex } = await nearApp.getAddress(path);
+
+  const signer = {
+    async getPublicKey() {
+      const { utils } = await import("near-api-js");
+      // Convert hex public key to NEAR PublicKey format
+      return utils.PublicKey.fromString(`ed25519:${pubKeyHex}`);
+    },
+
+    signNep413Message(
+      _message: string,
+      _accountId: string,
+      _recipient: string,
+      _nonce: Uint8Array,
+      _callbackUrl?: string,
+    ) {
+      // Most NEAR Ledger apps don't support arbitrary message signing
+      return Promise.reject(
+        new SwapKitError("wallet_ledger_method_not_supported", {
+          wallet: "Ledger",
+          method: "signNep413Message",
+        }),
+      );
+    },
+
+    getAddress() {
+      return Promise.resolve(address);
+    },
+
+    async signTransaction(transaction: Transaction) {
+      const { Signature, SignedTransaction } = await import("near-api-js/lib/transaction");
+      try {
+        const signatureArray = await nearApp.signTransaction(transaction.encode(), path);
+        if (!signatureArray) {
+          throw new Error("Signature undefined");
+        }
+
+        const signature = new Signature({
+          keyType: 0,
+          data: signatureArray,
+        });
+
+        const signedTransaction = new SignedTransaction({ transaction, signature });
+
+        return [signatureArray, signedTransaction] as [
+          Uint8Array<ArrayBufferLike>,
+          SignedTransaction,
+        ];
+      } catch (error) {
+        throw new SwapKitError("wallet_ledger_signing_error", {
+          error,
+        });
+      }
+    },
+
+    signDelegateAction(_delegateAction: any) {
+      return Promise.reject(
+        new SwapKitError("wallet_ledger_method_not_supported", {
+          wallet: "Ledger",
+          method: "signDelegateAction",
+        }),
+      );
+    },
+  };
+
+  return signer as NearSigner;
+}

package/src/ledger/helpers/getLedgerAddress.ts

@@ -1,5 +1,6 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
+import type { getNearLedgerClient } from "../clients/near";
 import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
 import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
@@ -45,6 +46,10 @@ export const getLedgerAddress = async <
       return chain === Chain.BitcoinCash ? address.replace("bitcoincash:", "") : address;
     }
 
+    case Chain.Near: {
+      return await (ledgerClient as Awaited<ReturnType<typeof getNearLedgerClient>>).getAddress();
+    }
+
     case Chain.Ripple: {
       return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).address;
     }

package/src/ledger/helpers/getLedgerClient.ts

@@ -16,6 +16,7 @@ import {
   OptimismLedger,
   PolygonLedger,
 } from "../clients/evm";
+import { getNearLedgerClient } from "../clients/near";
 import { THORChainLedger } from "../clients/thorchain";
 import {
   BitcoinCashLedger,
@@ -25,6 +26,7 @@ import {
   LitecoinLedger,
 } from "../clients/utxo";
 import { XRPLedger } from "../clients/xrp";
+import { getLedgerTransport } from "./getLedgerTransport";
 
 type LedgerSignerMap = {
   [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
@@ -38,6 +40,7 @@ type LedgerSignerMap = {
   [Chain.Dogecoin]: ReturnType<typeof DogecoinLedger>;
   [Chain.Ethereum]: ReturnType<typeof EthereumLedger>;
   [Chain.Litecoin]: ReturnType<typeof LitecoinLedger>;
+  [Chain.Near]: Awaited<ReturnType<typeof getNearLedgerClient>>;
   [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
   [Chain.Ripple]: ReturnType<typeof XRPLedger>;
@@ -75,6 +78,10 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
       Promise.resolve(LitecoinLedger(derivationPath) as LedgerSignerMap[T]),
     )
     .with(Chain.Ripple, () => Promise.resolve(XRPLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(Chain.Near, async () => {
+      const transport = await getLedgerTransport();
+      return getNearLedgerClient(transport, derivationPath) as unknown as LedgerSignerMap[T];
+    })
     .with(
       Chain.Arbitrum,
       Chain.Avalanche,

package/src/ledger/index.ts

@@ -31,6 +31,7 @@ export const ledgerWallet = createWallet({
     Chain.Dogecoin,
     Chain.Ethereum,
     Chain.Litecoin,
+    Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
     Chain.Ripple,
@@ -269,6 +270,15 @@ async function getWalletMethods({
       return { ...toolbox, address, deposit, transfer, signMessage };
     }
 
+    case Chain.Near: {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const accountId = await signer.getAddress();
+      const toolbox = await getNearToolbox({ signer });
+
+      return { ...toolbox, address: accountId };
+    }
+
     case Chain.Ripple: {
       const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
       const signer = await getLedgerClient({ chain, derivationPath });

package/src/okx/helpers.ts

@@ -123,6 +123,22 @@ export async function getWalletMethods(chain: Chain) {
       return { ...toolbox, address, transfer: cosmosTransfer() };
     }
 
+    case Chain.Near: {
+      if (!(window.okxwallet && "near" in window.okxwallet)) {
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Near });
+      }
+
+      const { createNearSignerFromProvider } = await import("../helpers/near");
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+
+      const provider = window.okxwallet.near;
+      const signer = await createNearSignerFromProvider(provider, "OKX");
+      const accountId = await signer.getAddress();
+      const toolbox = await getNearToolbox({ signer });
+
+      return { ...toolbox, address: accountId };
+    }
+
     default:
       throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
   }

package/src/okx/index.ts

@@ -14,6 +14,7 @@ export const okxWallet = createWallet({
     Chain.Bitcoin,
     Chain.Cosmos,
     Chain.Ethereum,
+    Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
   ],

package/src/types.ts

@@ -16,6 +16,7 @@ import type { cosmostationWallet } from "./cosmostation";
 import type { ctrlWallet } from "./ctrl";
 import type { evmWallet } from "./evm-extensions";
 import type { exodusWallet } from "./exodus";
+import type { NearBrowserWalletProvider } from "./helpers/near";
 import type { keepkeyWallet } from "./keepkey";
 import type { keepkeyBexWallet } from "./keepkey-bex";
 import type { keplrWallet } from "./keplr";
@@ -122,6 +123,7 @@ declare global {
       thorchain: Eip1193Provider;
       mayachain: Eip1193Provider;
       solana: SolanaProvider & { isXDEFI: boolean };
+      near: NearBrowserWalletProvider;
     };
 
     bitkeep?: {
@@ -196,6 +198,15 @@ declare global {
             ) => Promise<boolean>;
             getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
           };
+          near: NearBrowserWalletProvider & {
+            requestSignIn: (params?: {
+              contractId?: string;
+              methodNames?: string[];
+            }) => Promise<{ accountId: string; accessKey?: any }>;
+            requestSignTransactions: (params: {
+              transactions: any[];
+            }) => Promise<any>;
+          };
         }
       | EthereumWindowProvider;
   }

package/src/walletconnect/constants.ts

@@ -13,6 +13,8 @@ export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
 export const OPTIMISM_MAINNET_ID = "eip155:10";
 export const POLYGON_MAINNET_ID = "eip155:137";
 export const BASE_MAINNET_ID = "eip155:8453";
+export const NEAR_MAINNET_ID = "near:mainnet";
+export const NEAR_TESTNET_ID = "near:testnet";
 
 export const DEFAULT_LOGGER = "debug";
 

package/src/walletconnect/helpers.ts

@@ -1,4 +1,4 @@
-import { Chain, type EVMChain } from "@swapkit/helpers";
+import { Chain, type EVMChain, SKConfig } from "@swapkit/helpers";
 
 import {
   ARBITRUM_ONE_MAINNET_ID,
@@ -9,13 +9,15 @@ import {
   ETHEREUM_MAINNET_ID,
   KUJIRA_MAINNET_ID,
   MAYACHAIN_MAINNET_ID,
+  NEAR_MAINNET_ID,
+  NEAR_TESTNET_ID,
   OPTIMISM_MAINNET_ID,
   POLYGON_MAINNET_ID,
   THORCHAIN_MAINNET_ID,
 } from "./constants";
 
 export const getAddressByChain = (
-  chain: EVMChain | Chain.THORChain | Chain.Maya | Chain.Kujira | Chain.Cosmos,
+  chain: EVMChain | Chain.THORChain | Chain.Maya | Chain.Kujira | Chain.Cosmos | Chain.Near,
   accounts: string[],
 ) => {
   const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
@@ -48,6 +50,11 @@ export const chainToChainId = (chain: Chain) => {
       return COSMOS_HUB_MAINNET_ID;
     case Chain.Kujira:
       return KUJIRA_MAINNET_ID;
+    case Chain.Near: {
+      // Use testnet if stagenet is enabled
+      const { isStagenet } = SKConfig.get("envs");
+      return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
+    }
     default:
       return "";
   }

package/src/walletconnect/index.ts

@@ -10,8 +10,10 @@ import {
   filterSupportedChains,
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams, createThorchainToolbox } from "@swapkit/toolboxes/cosmos";
+import type { NearSigner } from "@swapkit/toolboxes/near";
 import type { WalletConnectModalSign } from "@walletconnect/modal-sign-html";
 import type { SessionTypes, SignClientTypes } from "@walletconnect/types";
+import type { Transaction } from "near-api-js/lib/transaction";
 
 import { getWalletSupportedChains } from "../utils";
 import {
@@ -40,6 +42,7 @@ export const walletconnectWallet = createWallet({
     Chain.Ethereum,
     Chain.Kujira,
     Chain.Maya,
+    Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
     Chain.THORChain,
@@ -242,6 +245,71 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
         getAccount,
       };
     }
+
+    case Chain.Near: {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const { DEFAULT_NEAR_METHODS } = await import("./constants");
+
+      // Create a NEAR signer that uses WalletConnect
+      const signer = {
+        getPublicKey() {
+          // WalletConnect NEAR doesn't expose public key directly
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", {
+              method: "getPublicKey",
+            }),
+          );
+        },
+
+        signNep413Message(
+          _message: string,
+          _accountId: string,
+          _recipient: string,
+          _nonce: Uint8Array,
+          _callbackUrl?: string,
+        ) {
+          // WalletConnect NEAR spec doesn't include NEP-413 message signing
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", {
+              method: "signNep413Message",
+            }),
+          );
+        },
+
+        async signTransaction(transaction: Transaction) {
+          if (!walletconnect) {
+            throw new SwapKitError("wallet_walletconnect_connection_not_established");
+          }
+          // WalletConnect signs and sends in one operation
+          const result = await walletconnect.client.request({
+            topic: session.topic,
+            chainId: chainToChainId(Chain.Near),
+            request: {
+              method: DEFAULT_NEAR_METHODS.NEAR_SIGN_AND_SEND_TRANSACTION,
+              params: { transaction },
+            },
+          });
+          // Return dummy hash and result
+          return [new Uint8Array(32), result];
+        },
+
+        signDelegateAction(_delegateAction: any) {
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", {
+              method: "signDelegateAction",
+            }),
+          );
+        },
+
+        getAddress() {
+          return Promise.resolve(address);
+        },
+      } as NearSigner;
+
+      const toolbox = await getNearToolbox({ signer });
+      return toolbox;
+    }
+
     default:
       throw new SwapKitError({
         errorKey: "wallet_chain_not_supported",