@anywalletkit/wallet-ton 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -1061,12 +1061,12 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
     return sim.fees.total;
   }
   /** Sign without broadcasting. Returns the external-message BODY as base64 BoC (pass it back to sendTransaction as a Cell). */
-  async signTransaction(tx) {
+  async signTransaction(tx, options = {}) {
     if (tx instanceof import_core10.Cell) {
-      await this.preflight(tx, this._config.transactionMaxFee, "transaction");
+      await this.preflight(tx, (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
       return tx.toBoc().toString("base64");
     }
-    const { body } = await this.prepare(this.toMessages(tx), this._config.transactionMaxFee, "transaction");
+    const { body } = await this.prepare(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
     return body.toBoc().toString("base64");
   }
   async broadcast(body) {
@@ -1076,16 +1076,16 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
     return body.hash().toString("hex");
   }
   /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
-  async sendTransaction(tx) {
+  async sendTransaction(tx, options = {}) {
     this.requireRpc("send transactions");
-    const { body, fee } = tx instanceof import_core10.Cell ? { body: tx, fee: await this.preflight(tx, this._config.transactionMaxFee, "transaction") } : await this.prepare(this.toMessages(tx), this._config.transactionMaxFee, "transaction");
+    const { body, fee } = tx instanceof import_core10.Cell ? { body: tx, fee: await this.preflight(tx, (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction") } : await this.prepare(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
     return { hash: await this.broadcast(body), fee };
   }
   /** TON (no `token`) or jetton transfer. */
-  async transfer(o) {
+  async transfer(o, writeOptions = {}) {
     this.requireRpc("transfer tokens");
     const message = o.token ? await this.jettonTransferMessage(o) : this.transactionMessage({ to: o.recipient, value: o.amount, ...o.memo !== void 0 ? { body: o.memo } : {} });
-    const { body, fee } = await this.prepare([message], this._config.transferMaxFee, "transfer");
+    const { body, fee } = await this.prepare([message], (0, import_core9.feeLimit)(this._config.transferMaxFee, writeOptions), "transfer");
     return { hash: await this.broadcast(body), fee };
   }
   /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
@@ -1140,10 +1140,10 @@ var WalletManagerTon = class _WalletManagerTon extends import_core11.WalletManag
     const full = path.startsWith("m/") ? path : `${TON_BASE_PATH}/${path}`;
     const cached = this._accounts.get(full);
     if (cached) return cached;
-    const signer = import_core11.LocalSigner.leafFromSeed(this.seedBytes(), "ed25519", full);
-    const account = new WalletAccountTon(signer, signer.publicKey, full, this._config);
-    this._accounts.set(full, account);
-    return account;
+    return this.cachedAccount(full, () => {
+      const signer = import_core11.LocalSigner.leafFromSeed(this.seedBytes(), "ed25519", full);
+      return new WalletAccountTon(signer, signer.publicKey, full, this._config);
+    });
   }
   /** The one path a non-derivable signer answers to: its own, or 'external'. */
   singlePath(signer) {
@@ -1152,22 +1152,18 @@ var WalletManagerTon = class _WalletManagerTon extends import_core11.WalletManag
   /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
   async fromSigner(signer, path) {
     this.requireSigner("ed25519");
-    let leaf = signer;
+    let rel;
     let key = this.singlePath(signer);
     if ((0, import_core11.isSeedSigner)(signer)) {
       if (path === signer.path) key = path;
       else if (path.startsWith(`${signer.path}/`)) {
-        leaf = await (signer.deriveLeaf ?? signer.derive).call(signer, path.slice(signer.path.length + 1));
+        rel = path.slice(signer.path.length + 1);
         key = path;
       } else throw new import_core11.SignerError(`This signer yields a single account at path '${signer.path}'; it cannot provide ${path}.`);
     } else if (path !== `${TON_BASE_PATH}/0'` && path !== "external") {
       throw new import_core11.SignerError(`An external signer yields a single account; ${path} is not derivable from it.`);
     }
-    const cached = this._accounts.get(key);
-    if (cached) return cached;
-    const account = new WalletAccountTon(leaf, await leaf.getPublicKey(), key, this._config);
-    this._accounts.set(key, account);
-    return account;
+    return this.signerAccount(key, signer, rel, (leaf, publicKey) => new WalletAccountTon(leaf, publicKey, key, this._config));
   }
   /** Watch-only account for a public key (hex or bytes) — TON addresses derive from the key, not the other way round. */
   getReadOnlyAccount(publicKey) {