@anywalletkit/wallet-ton 0.2.2 → 0.2.3

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { Cell, StateInit, TupleReader, Address, TupleItem, Transaction, MessageRelaxed } from '@ton/core';
-import { SignerError, IWalletAccountReadOnly, IWalletAccount, Signer, TransferResult, WalletManager, FeeRates } from '@anywalletkit/core';
+import { SignerError, IWalletAccountReadOnly, IWalletAccount, Signer, WriteOptions, TransferResult, WalletManager, FeeRates } from '@anywalletkit/core';
 export { HistoryFetch, HistoryUnavailableError, TonChainTx, TonHistoryBackend, TonHistoryCursor, TonHistoryOptions, TonHistoryPage, TonHistoryRaw, TonHistorySource, TonapiAction, TonapiEvent, V3Transaction, createTonHistory, decodeCursor as decodeHistoryCursor, encodeCursor as encodeHistoryCursor, mapActions as mapTonapiActions, mapTonapiEvent, mapToncenterTransaction, rawTonAddress, tonExplorerTxUrl, valueFlowTransfers } from './history.cjs';
 
 /**
@@ -652,12 +652,12 @@ declare class WalletAccountTon extends WalletAccountReadOnlyTon implements IWall
     private prepare;
     private preflight;
     /** Sign without broadcasting. Returns the external-message BODY as base64 BoC (pass it back to sendTransaction as a Cell). */
-    signTransaction(tx: TonSendable): Promise<string>;
+    signTransaction(tx: TonSendable, options?: WriteOptions): Promise<string>;
     private broadcast;
     /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
-    sendTransaction(tx: TonSendable): Promise<TransferResult>;
+    sendTransaction(tx: TonSendable, options?: WriteOptions): Promise<TransferResult>;
     /** TON (no `token`) or jetton transfer. */
-    transfer(o: TonTransferOptions): Promise<TransferResult>;
+    transfer(o: TonTransferOptions, writeOptions?: WriteOptions): Promise<TransferResult>;
     /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
     toReadOnlyAccount(): IWalletAccountReadOnly;
     /** Disposes the signer: a local key is zeroized, an external one is released. */

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Cell, StateInit, TupleReader, Address, TupleItem, Transaction, MessageRelaxed } from '@ton/core';
-import { SignerError, IWalletAccountReadOnly, IWalletAccount, Signer, TransferResult, WalletManager, FeeRates } from '@anywalletkit/core';
+import { SignerError, IWalletAccountReadOnly, IWalletAccount, Signer, WriteOptions, TransferResult, WalletManager, FeeRates } from '@anywalletkit/core';
 export { HistoryFetch, HistoryUnavailableError, TonChainTx, TonHistoryBackend, TonHistoryCursor, TonHistoryOptions, TonHistoryPage, TonHistoryRaw, TonHistorySource, TonapiAction, TonapiEvent, V3Transaction, createTonHistory, decodeCursor as decodeHistoryCursor, encodeCursor as encodeHistoryCursor, mapActions as mapTonapiActions, mapTonapiEvent, mapToncenterTransaction, rawTonAddress, tonExplorerTxUrl, valueFlowTransfers } from './history.js';
 
 /**
@@ -652,12 +652,12 @@ declare class WalletAccountTon extends WalletAccountReadOnlyTon implements IWall
     private prepare;
     private preflight;
     /** Sign without broadcasting. Returns the external-message BODY as base64 BoC (pass it back to sendTransaction as a Cell). */
-    signTransaction(tx: TonSendable): Promise<string>;
+    signTransaction(tx: TonSendable, options?: WriteOptions): Promise<string>;
     private broadcast;
     /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
-    sendTransaction(tx: TonSendable): Promise<TransferResult>;
+    sendTransaction(tx: TonSendable, options?: WriteOptions): Promise<TransferResult>;
     /** TON (no `token`) or jetton transfer. */
-    transfer(o: TonTransferOptions): Promise<TransferResult>;
+    transfer(o: TonTransferOptions, writeOptions?: WriteOptions): Promise<TransferResult>;
     /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
     toReadOnlyAccount(): IWalletAccountReadOnly;
     /** Disposes the signer: a local key is zeroized, an external one is released. */

package/dist/index.js

@@ -934,7 +934,7 @@ function randomQueryId() {
 }
 
 // src/account.ts
-import { LocalSigner, requireCurve } from "@anywalletkit/core";
+import { LocalSigner, feeLimit, requireCurve } from "@anywalletkit/core";
 import { Cell as Cell5 } from "@ton/core";
 var toHex = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, "0")).join("");
 var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon {
@@ -1002,12 +1002,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 Cell5) {
-      await this.preflight(tx, this._config.transactionMaxFee, "transaction");
+      await this.preflight(tx, 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), feeLimit(this._config.transactionMaxFee, options), "transaction");
     return body.toBoc().toString("base64");
   }
   async broadcast(body) {
@@ -1017,16 +1017,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 Cell5 ? { 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 Cell5 ? { body: tx, fee: await this.preflight(tx, feeLimit(this._config.transactionMaxFee, options), "transaction") } : await this.prepare(this.toMessages(tx), 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], feeLimit(this._config.transferMaxFee, writeOptions), "transfer");
     return { hash: await this.broadcast(body), fee };
   }
   /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
@@ -1081,10 +1081,10 @@ var WalletManagerTon = class _WalletManagerTon extends WalletManager {
     const full = path.startsWith("m/") ? path : `${TON_BASE_PATH}/${path}`;
     const cached = this._accounts.get(full);
     if (cached) return cached;
-    const signer = LocalSigner2.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 = LocalSigner2.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) {
@@ -1093,22 +1093,18 @@ var WalletManagerTon = class _WalletManagerTon extends WalletManager {
   /** 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 (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 SignerError2(`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 SignerError2(`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) {