@vleap/warps-adapter-near 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/index.mjs

@@ -900,83 +900,65 @@ var WarpNearExplorer = class {
 };
 
 // src/WarpNearWallet.ts
-import * as bip39 from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
 import {
   getProviderConfig as getProviderConfig4,
-  getWarpWalletMnemonicFromConfig,
-  getWarpWalletPrivateKeyFromConfig
+  initializeWalletCache
 } from "@vleap/warps";
+import { connect as connect4, keyStores as keyStores4 } from "near-api-js";
+
+// src/providers/MnemonicWalletProvider.ts
+import { keyToImplicitAddress } from "@near-js/crypto";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3, getWarpWalletMnemonicFromConfig } from "@vleap/warps";
 import bs58 from "bs58";
-import { connect as connect4, KeyPair, keyStores as keyStores4 } from "near-api-js";
-var WarpNearWallet = class {
+import { KeyPair } from "near-api-js";
+var MnemonicWalletProvider = class {
   constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
-    this.nearConfig = {
-      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
-      nodeUrl: providerConfig.url,
-      keyStore: new keyStores4.InMemoryKeyStore()
-    };
+    this.keypair = null;
   }
-  async signTransaction(tx) {
-    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
-    const keyPair = this.getKeyPair();
-    const accountId = this.getAddress();
-    if (!accountId) throw new Error("No account ID available");
-    await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
-    const near = await connect4(this.nearConfig);
-    const account = await near.account(accountId);
-    if (tx.signature) {
-      return tx;
+  async getAddress() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    if (address) return address;
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return keyToImplicitAddress(publicKey.toString());
+    } catch {
+      return null;
     }
-    const signedTx = await account.signAndSendTransaction({
-      receiverId: tx.receiverId,
-      actions: tx.actions
-    });
-    return {
-      ...tx,
-      signature: signedTx.transaction.hash,
-      transactionHash: signedTx.transaction.hash
-    };
   }
-  async signTransactions(txs) {
-    if (txs.length === 0) return [];
-    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return publicKey.toString();
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const keypair = this.getKeyPair();
+    return tx;
   }
   async signMessage(message) {
-    const keyPair = this.getKeyPair();
+    const keypair = this.getKeyPair();
     const messageBytes = new TextEncoder().encode(message);
-    const signature = keyPair.sign(messageBytes);
+    const signature = keypair.sign(messageBytes);
     return bs58.encode(signature.signature);
   }
-  async sendTransaction(tx) {
-    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
-    const keyPair = this.getKeyPair();
-    const accountId = this.getAddress();
-    if (!accountId) throw new Error("No account ID available");
-    await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
-    const near = await connect4(this.nearConfig);
-    const account = await near.account(accountId);
-    if (tx.transactionHash) {
-      return tx.transactionHash;
-    }
-    const result = await account.signAndSendTransaction({
-      receiverId: tx.receiverId,
-      actions: tx.actions
-    });
-    return result.transaction.hash;
-  }
-  async sendTransactions(txs) {
-    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  getKeyPairInstance() {
+    return this.getKeyPair();
   }
   create(mnemonic) {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const keyPair = KeyPair.fromRandom("ed25519");
     const publicKey = keyPair.getPublicKey();
-    const accountId = publicKey.toString().split(":")[1] || publicKey.toString();
+    const accountId = keyToImplicitAddress(publicKey.toString());
     return {
+      provider: "mnemonic",
       address: accountId,
       privateKey: keyPair.toString(),
       mnemonic
@@ -987,77 +969,213 @@ var WarpNearWallet = class {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const keyPair = KeyPair.fromRandom("ed25519");
     const publicKey = keyPair.getPublicKey();
-    const accountId = publicKey.toString().split(":")[1] || publicKey.toString();
+    const accountId = keyToImplicitAddress(publicKey.toString());
     return {
+      provider: "mnemonic",
       address: accountId,
       privateKey: keyPair.toString(),
       mnemonic
     };
   }
-  getAddress() {
+  getKeyPair() {
+    if (this.keypair) return this.keypair;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.keypair = KeyPair.fromRandom("ed25519");
+    return this.keypair;
+  }
+};
+
+// src/providers/PrivateKeyWalletProvider.ts
+import { keyToImplicitAddress as keyToImplicitAddress2 } from "@near-js/crypto";
+import * as bip392 from "@scure/bip39";
+import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english.js";
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig4, getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
+import bs582 from "bs58";
+import { KeyPair as KeyPair2 } from "near-api-js";
+var PrivateKeyWalletProvider = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = getWarpWalletAddressFromConfig4(this.config, this.chain.name);
+    if (address) return address;
     try {
-      const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-      if (privateKey) {
-        try {
-          const keyPair = KeyPair.fromString(privateKey);
-          const publicKey = keyPair.getPublicKey();
-          return publicKey.toString().split(":")[1] || publicKey.toString();
-        } catch {
-          return null;
-        }
-      }
-      const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
-      if (mnemonic) {
-        const seed = bip39.mnemonicToSeedSync(mnemonic);
-        const keyPair = KeyPair.fromRandom("ed25519");
-        const publicKey = keyPair.getPublicKey();
-        return publicKey.toString().split(":")[1] || publicKey.toString();
-      }
-      const wallet = this.config.user?.wallets?.[this.chain.name];
-      if (wallet && typeof wallet === "object" && "address" in wallet) {
-        return wallet.address;
-      }
-      if (wallet && typeof wallet === "string") {
-        return wallet;
-      }
-      return null;
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
+      return keyToImplicitAddress2(publicKey.toString());
     } catch {
       return null;
     }
   }
-  getPublicKey() {
+  async getPublicKey() {
     try {
-      const keyPair = this.getKeyPair();
-      const publicKey = keyPair.getPublicKey();
+      const keypair = this.getKeyPair();
+      const publicKey = keypair.getPublicKey();
       return publicKey.toString();
     } catch {
       return null;
     }
   }
+  async signTransaction(tx) {
+    const keypair = this.getKeyPair();
+    return tx;
+  }
+  async signMessage(message) {
+    const keypair = this.getKeyPair();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = keypair.sign(messageBytes);
+    return bs582.encode(signature.signature);
+  }
+  getKeyPairInstance() {
+    return this.getKeyPair();
+  }
+  create(mnemonic) {
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const keyPair = KeyPair2.fromRandom("ed25519");
+    const publicKey = keyPair.getPublicKey();
+    const accountId = keyToImplicitAddress2(publicKey.toString());
+    return {
+      provider: "privateKey",
+      address: accountId,
+      privateKey: keyPair.toString(),
+      mnemonic
+    };
+  }
+  generate() {
+    const mnemonic = bip392.generateMnemonic(wordlist2);
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const keyPair = KeyPair2.fromRandom("ed25519");
+    const publicKey = keyPair.getPublicKey();
+    const accountId = keyToImplicitAddress2(publicKey.toString());
+    return {
+      provider: "privateKey",
+      address: accountId,
+      privateKey: keyPair.toString(),
+      mnemonic
+    };
+  }
   getKeyPair() {
+    if (this.keypair) return this.keypair;
     const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (privateKey) {
-      try {
-        try {
-          return KeyPair.fromString(privateKey);
-        } catch {
-        }
-        const keyPair = KeyPair.fromRandom("ed25519");
-        return keyPair;
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(`Invalid private key format: ${error.message}`);
-        }
-        throw new Error("Invalid private key format");
+    if (!privateKey) throw new Error("No private key provided");
+    try {
+      return KeyPair2.fromString(privateKey);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Invalid private key format: ${error.message}`);
       }
+      throw new Error("Invalid private key format");
     }
-    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
-    if (mnemonic) {
-      const seed = bip39.mnemonicToSeedSync(mnemonic);
-      const keyPair = KeyPair.fromRandom("ed25519");
-      return keyPair;
+  }
+};
+
+// src/WarpNearWallet.ts
+var WarpNearWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
+    this.nearConfig = {
+      networkId: this.config.env === "mainnet" ? "mainnet" : this.config.env === "testnet" ? "testnet" : "testnet",
+      nodeUrl: providerConfig.url,
+      keyStore: new keyStores4.InMemoryKeyStore()
+    };
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") throw new Error(`Wallet can not be used for signing: ${wallet}`);
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[wallet.provider];
+    if (providerFactory) return providerFactory(this.config, this.chain);
+    if (wallet.provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (wallet.provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${wallet.provider}`);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    const accountId = this.getAddress();
+    if (!accountId) throw new Error("No account ID available");
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const keyPair = this.walletProvider.getKeyPairInstance();
+      await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
+      const near = await connect4(this.nearConfig);
+      const account = await near.account(accountId);
+      if (tx.signature) {
+        return tx;
+      }
+      const signedTx = await account.signAndSendTransaction({
+        receiverId: tx.receiverId,
+        actions: tx.actions
+      });
+      return {
+        ...tx,
+        signature: signedTx.transaction.hash,
+        transactionHash: signedTx.transaction.hash
+      };
     }
-    throw new Error("No private key or mnemonic provided");
+    throw new Error("Wallet provider does not support signing transactions");
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return await this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    const accountId = this.getAddress();
+    if (!accountId) throw new Error("No account ID available");
+    if (tx.transactionHash) {
+      return tx.transactionHash;
+    }
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const keyPair = this.walletProvider.getKeyPairInstance();
+      await this.nearConfig.keyStore.setKey(this.nearConfig.networkId, accountId, keyPair);
+      const near = await connect4(this.nearConfig);
+      const account = await near.account(accountId);
+      const result = await account.signAndSendTransaction({
+        receiverId: tx.receiverId,
+        actions: tx.actions
+      });
+      return result.transaction.hash;
+    }
+    throw new Error("Wallet provider does not support sending transactions");
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  create(mnemonic) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return this.walletProvider.create(mnemonic);
+  }
+  generate() {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return this.walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
   }
 };
 
@@ -1090,7 +1208,7 @@ var NativeTokenNear = {
   decimals: 24,
   logoUrl: "https://joai.ai/images/tokens/near-black.svg"
 };
-var getNearAdapter = createNearAdapter("near", {
+var NearAdapter = createNearAdapter("near", {
   mainnet: {
     name: "near",
     displayName: "NEAR Mainnet",
@@ -1126,6 +1244,7 @@ export {
   ExplorerUrls,
   KnownTokens,
   NativeTokenNear,
+  NearAdapter,
   NearExplorerMap,
   NearExplorerNames,
   NearExplorerUrls,
@@ -1139,7 +1258,6 @@ export {
   WarpNearSerializer,
   WarpNearWallet,
   findKnownTokenById,
-  getKnownTokensForChain,
-  getNearAdapter
+  getKnownTokensForChain
 };
 //# sourceMappingURL=index.mjs.map