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

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { WarpChainAsset, ChainAdapterFactory, AdapterWarpExecutor, WarpClientConfig, WarpChainInfo, WarpExecutable, WarpAdapterGenericTransaction, AdapterWarpWallet, WarpWalletDetails } from '@vleap/warps';
+import { WarpChainAsset, ChainAdapterFactory, AdapterWarpExecutor, WarpClientConfig, WarpChainInfo, WarpExecutable, WarpAdapterGenericTransaction, AdapterWarpWallet, WarpWalletProvider, WarpWalletDetails } from '@vleap/warps';
 
 declare const NativeTokenSet: WarpChainAsset;
 declare const FastsetAdapter: ChainAdapterFactory;
@@ -18,16 +18,22 @@ declare class WarpFastsetWallet implements AdapterWarpWallet {
     private config;
     private chain;
     private client;
+    private walletProvider;
+    private cachedAddress;
+    private cachedPublicKey;
     constructor(config: WarpClientConfig, chain: WarpChainInfo);
     signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
-    signMessage(message: string): Promise<string>;
     signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
     sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
     sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
-    create(mnemonic: string): WarpWalletDetails;
-    generate(): WarpWalletDetails;
+    create(provider: WarpWalletProvider, mnemonic: string): WarpWalletDetails;
+    generate(provider: WarpWalletProvider): WarpWalletDetails;
     getAddress(): string | null;
     getPublicKey(): string | null;
+    private createProvider;
+    private initializeCache;
+    private createProviderForOperation;
 }
 
 export { FastsetAdapter, NativeTokenSet, WarpFastsetExecutor, WarpFastsetWallet };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { WarpChainAsset, ChainAdapterFactory, AdapterWarpExecutor, WarpClientConfig, WarpChainInfo, WarpExecutable, WarpAdapterGenericTransaction, AdapterWarpWallet, WarpWalletDetails } from '@vleap/warps';
+import { WarpChainAsset, ChainAdapterFactory, AdapterWarpExecutor, WarpClientConfig, WarpChainInfo, WarpExecutable, WarpAdapterGenericTransaction, AdapterWarpWallet, WarpWalletProvider, WarpWalletDetails } from '@vleap/warps';
 
 declare const NativeTokenSet: WarpChainAsset;
 declare const FastsetAdapter: ChainAdapterFactory;
@@ -18,16 +18,22 @@ declare class WarpFastsetWallet implements AdapterWarpWallet {
     private config;
     private chain;
     private client;
+    private walletProvider;
+    private cachedAddress;
+    private cachedPublicKey;
     constructor(config: WarpClientConfig, chain: WarpChainInfo);
     signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
-    signMessage(message: string): Promise<string>;
     signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
     sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
     sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
-    create(mnemonic: string): WarpWalletDetails;
-    generate(): WarpWalletDetails;
+    create(provider: WarpWalletProvider, mnemonic: string): WarpWalletDetails;
+    generate(provider: WarpWalletProvider): WarpWalletDetails;
     getAddress(): string | null;
     getPublicKey(): string | null;
+    private createProvider;
+    private initializeCache;
+    private createProviderForOperation;
 }
 
 export { FastsetAdapter, NativeTokenSet, WarpFastsetExecutor, WarpFastsetWallet };

package/dist/index.js

@@ -40,7 +40,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/main.ts
-var import_warps6 = require("@vleap/warps");
+var import_warps9 = require("@vleap/warps");
 
 // src/helpers/encode.ts
 var encoder = new TextEncoder();
@@ -51,9 +51,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
 var import_warps = require("@vleap/warps");
@@ -1957,13 +1954,17 @@ var WarpFastsetOutput = class {
 };
 
 // src/WarpFastsetWallet.ts
+var import_warps8 = require("@vleap/warps");
+
+// src/providers/MnemonicWalletProvider.ts
 var bip39 = __toESM(require("@scure/bip39"), 1);
+var import_english = require("@scure/bip39/wordlists/english");
 var import_warps5 = require("@vleap/warps");
 
 // src/sdk/ed25519-setup.ts
 var ed25519 = __toESM(require("@noble/ed25519"), 1);
 
-// 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";
 }
@@ -2013,7 +2014,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");
@@ -2128,7 +2129,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) {
@@ -2163,7 +2164,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",
@@ -2375,82 +2376,265 @@ 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 = (0, import_warps5.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 = (0, import_warps5.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(import_english.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 (0, import_warps5.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+  getPrivateKey() {
+    if (this.privateKey) return this.privateKey;
+    const mnemonic = (0, import_warps5.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 = (0, import_warps5.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
+var import_warps6 = require("@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 = (0, import_warps5.getWarpWalletAddressFromConfig)(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 = (0, import_warps6.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
+var import_warps7 = require("@vleap/warps");
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain2) {
+    this.config = config;
+    this.chain = chain2;
+  }
+  async getAddress() {
+    return (0, import_warps7.getWarpWalletAddressFromConfig)(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 = (0, import_warps7.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  generate() {
+    const address = (0, import_warps7.getWarpWalletAddressFromConfig)(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() {
+    (0, import_warps8.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
 var NativeTokenSet = {
-  chain: import_warps6.WarpChainName.Fastset,
+  chain: import_warps9.WarpChainName.Fastset,
   identifier: "SET",
   name: "SET",
   symbol: "SET",
@@ -2477,9 +2661,9 @@ function createFastsetAdapter(chainName, chainInfos) {
     };
   };
 }
-var FastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset, {
+var FastsetAdapter = createFastsetAdapter(import_warps9.WarpChainName.Fastset, {
   mainnet: {
-    name: import_warps6.WarpChainName.Fastset,
+    name: import_warps9.WarpChainName.Fastset,
     displayName: "FastSet",
     chainId: "1",
     blockTime: 1e3,
@@ -2489,7 +2673,7 @@ var FastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset, {
     nativeToken: NativeTokenSet
   },
   testnet: {
-    name: import_warps6.WarpChainName.Fastset,
+    name: import_warps9.WarpChainName.Fastset,
     displayName: "FastSet Testnet",
     chainId: "testnet",
     blockTime: 1e3,
@@ -2499,7 +2683,7 @@ var FastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset, {
     nativeToken: NativeTokenSet
   },
   devnet: {
-    name: import_warps6.WarpChainName.Fastset,
+    name: import_warps9.WarpChainName.Fastset,
     displayName: "FastSet Devnet",
     chainId: "devnet",
     blockTime: 1e3,