@vleap/warps-adapter-fastset 0.1.0-beta.47 → 0.1.0-beta.49

package/dist/index.mjs

@@ -16,9 +16,6 @@ function uint8ArrayToHex(uint8Array) {
 function hexToUint8Array(hex) {
   return new Uint8Array(Buffer.from(hex, "hex"));
 }
-function stringToUint8Array(str) {
-  return new Uint8Array(Buffer.from(str, "utf8"));
-}
 
 // src/helpers/general.ts
 import { getProviderConfig } from "@vleap/warps";
@@ -1932,16 +1929,19 @@ var WarpFastsetOutput = class {
 };
 
 // src/WarpFastsetWallet.ts
-import * as bip39 from "@scure/bip39";
 import {
-  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3,
-  getWarpWalletPrivateKeyFromConfig
+  initializeWalletCache
 } from "@vleap/warps";
 
+// src/providers/MnemonicWalletProvider.ts
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { getWarpWalletMnemonicFromConfig } from "@vleap/warps";
+
 // src/sdk/ed25519-setup.ts
 import * as ed25519 from "@noble/ed25519";
 
-// node_modules/@noble/hashes/utils.js
+// ../../node_modules/@noble/hashes/utils.js
 function isBytes2(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
@@ -1991,7 +1991,7 @@ var oidNist = (suffix) => ({
   oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
 });
 
-// node_modules/@noble/hashes/_md.js
+// ../../node_modules/@noble/hashes/_md.js
 var HashMD = class {
   constructor(blockLen, outputLen, padOffset, isLE) {
     __publicField(this, "blockLen");
@@ -2106,7 +2106,7 @@ var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
   327033209
 ]);
 
-// node_modules/@noble/hashes/_u64.js
+// ../../node_modules/@noble/hashes/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n = /* @__PURE__ */ BigInt(32);
 function fromBig(n, le = false) {
@@ -2141,7 +2141,7 @@ var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0
 var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
 var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
 
-// node_modules/@noble/hashes/sha2.js
+// ../../node_modules/@noble/hashes/sha2.js
 var K512 = /* @__PURE__ */ (() => split([
   "0x428a2f98d728ae22",
   "0x7137449123ef65cd",
@@ -2353,77 +2353,260 @@ var sha512 = /* @__PURE__ */ createHasher(
 ed25519.hashes.sha512 = sha512;
 var ed = ed25519;
 
-// src/WarpFastsetWallet.ts
-var WarpFastsetWallet = class {
+// src/providers/MnemonicWalletProvider.ts
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
   constructor(config, chain2) {
     this.config = config;
     this.chain = chain2;
-    this.client = getConfiguredFastsetClient(this.config, this.chain);
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
+    } catch {
+      return null;
+    }
   }
   async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
     const msg = Transaction.serialize(tx);
     const msgBytes = msg.toBytes();
     const prefix = new TextEncoder().encode("Transaction::");
     const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
     dataToSign.set(prefix, 0);
     dataToSign.set(msgBytes, prefix.length);
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
-    const privateKeyBytes = hexToUint8Array(privateKey);
-    const signature = ed.sign(dataToSign, privateKeyBytes);
+    const signature = ed.sign(dataToSign, privateKey);
     return { ...tx, signature };
   }
   async signMessage(message) {
-    const messageBytes = stringToUint8Array(message);
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
-    const privateKeyBytes = hexToUint8Array(privateKey);
-    const signature = ed.sign(messageBytes, privateKeyBytes);
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
     return uint8ArrayToHex(signature);
   }
-  async signTransactions(txs) {
-    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
-  }
-  async sendTransaction(tx) {
-    const { signature, ...transactionWithoutSignature } = tx;
-    const _cert = await this.client.submitTransaction(transactionWithoutSignature, signature ?? null);
-    return "TODO";
-  }
-  async sendTransactions(txs) {
-    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
-  }
   create(mnemonic) {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const privateKey = seed.slice(0, 32);
     const publicKey = ed.getPublicKey(privateKey);
     const address = FastsetClient.encodeBech32Address(publicKey);
-    return { provider: "privateKey", address, privateKey: uint8ArrayToHex(privateKey), mnemonic };
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: null,
+      mnemonic
+    };
   }
   generate() {
-    const privateKey = ed.utils.randomSecretKey();
+    const mnemonic = bip39.generateMnemonic(wordlist);
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const privateKey = seed.slice(0, 32);
     const publicKey = ed.getPublicKey(privateKey);
     const address = FastsetClient.encodeBech32Address(publicKey);
-    return { provider: "privateKey", address, privateKey: uint8ArrayToHex(privateKey), mnemonic: null };
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: null,
+      mnemonic
+    };
   }
-  getAddress() {
-    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.privateKey = seed.slice(0, 32);
+    return this.privateKey;
   }
-  getPublicKey() {
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (privateKey) {
-      const privateKeyBytes = hexToUint8Array(privateKey);
-      const publicKey = ed.getPublicKey(privateKeyBytes);
-      return uint8ArrayToHex(publicKey);
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/PrivateKeyWalletProvider.ts
+import { getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.privateKey = null;
+  }
+  async getAddress() {
+    try {
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return FastsetClient.encodeBech32Address(publicKey);
+    } catch {
+      return null;
     }
-    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
-    if (!address) return null;
+  }
+  async getPublicKey() {
     try {
-      const addressBytes = FastsetClient.decodeBech32Address(address);
-      return uint8ArrayToHex(addressBytes);
+      const privateKey = this.getPrivateKey();
+      const publicKey = ed.getPublicKey(privateKey);
+      return uint8ArrayToHex(publicKey);
     } catch {
       return null;
     }
   }
+  async signTransaction(tx) {
+    const privateKey = this.getPrivateKey();
+    const msg = Transaction.serialize(tx);
+    const msgBytes = msg.toBytes();
+    const prefix = new TextEncoder().encode("Transaction::");
+    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
+    dataToSign.set(prefix, 0);
+    dataToSign.set(msgBytes, prefix.length);
+    const signature = ed.sign(dataToSign, privateKey);
+    return { ...tx, signature };
+  }
+  async signMessage(message) {
+    const privateKey = this.getPrivateKey();
+    const messageBytes = new TextEncoder().encode(message);
+    const signature = ed.sign(messageBytes, privateKey);
+    return uint8ArrayToHex(signature);
+  }
+  create(mnemonic) {
+    throw new Error("PrivateKeyWalletProvider does not support creating wallets from mnemonics. Use MnemonicWalletProvider instead.");
+  }
+  generate() {
+    const privateKey = ed.utils.randomSecretKey();
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address,
+      privateKey: uint8ArrayToHex(privateKey),
+      mnemonic: null
+    };
+  }
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const privateKeyHex = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (!privateKeyHex) throw new Error("No private key provided");
+    this.privateKey = hexToUint8Array(privateKeyHex);
+    return this.privateKey;
+  }
+};
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
+
+// src/providers/ReadOnlyWalletProvider.ts
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3 } from "@vleap/warps";
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+  }
+  async getAddress() {
+    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async signTransaction(tx) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async signMessage(message) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  create(mnemonic) {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  generate() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/WarpFastsetWallet.ts
+var WarpFastsetWallet = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signTransaction(tx);
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    const signedTxs = [];
+    for (const tx of txs) {
+      signedTxs.push(await this.signTransaction(tx));
+    }
+    return signedTxs;
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    const { signature, ...transactionWithoutSignature } = tx;
+    const _cert = await this.client.submitTransaction(transactionWithoutSignature, signature ?? null);
+    return "TODO";
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  create(provider, mnemonic) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.create(mnemonic);
+  }
+  generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
+    }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
+  }
 };
 
 // src/main.ts