wative-core 2.5.0 → 2.5.2

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to `wative-core` are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.2] — 2026-09-18
+
+Adds two methods for signing bytes you built yourself.
+
+### Added
+- `address.signDigest(digest)` signs a 32-byte digest on an EVM address exactly as given, with no hashing and no prefix. It returns `r`, `s`, the recovery id (0 or 1), and a 65-byte `signature` with `v = 27 + recovery`. Build `v` from `recovery` for a typed or EIP-155 transaction.
+- `address.signBytes(message)` signs arbitrary bytes on an SVM address exactly as given, for example a serialized Solana transaction message. It returns the 64-byte signature as base58 and as hex.
+- Both take a `Uint8Array` or a `0x`-prefixed hex string of whole bytes, need the account unlocked, and sign whatever they are given, so pass only data you assembled yourself.
+
+## [2.5.1] — 2026-09-12
+
+Renames the transfer helper and improves fee handling.
+
+### Changed
+- BREAKING: `address.transfer(...)` is now `address.buildTransferPayload(...)`. It returns the transfer's parameters; pass them to `buildTransaction(...)` to sign and send — for example `buildTransaction({ ...buildTransferPayload({ to, asset, amount }), chainId }).send()`.
+- When you don't set gas fees, they are now chosen with more headroom, so a transaction is less likely to sit unconfirmed while network fees rise.
+- The built-in `evm` and `svm` chains can no longer be replaced through `registerDialect`; registering your own chain under a new name is unaffected.
+
 ## [2.5.0] — 2026-09-12
 
 Adds token-aware transfers and a public way to add your own chain.

package/README.md

@@ -477,7 +477,7 @@ const tx = evmAddr.buildTransaction({
   value: 1_000_000_000_000_000n,
   chainId: 1,
 });
-await evmAddr.signTransaction(tx);
+await tx.sign();                              // resolves once the signature exists
 const tracker = await evmAddr.sendTransaction(tx);
 
 tracker.on("change",    (state)   => console.log("state →", state.status));
@@ -491,20 +491,45 @@ const sim = await evmAddr.simulateTransaction(tx);
 console.log(sim.gasUsed);
 ```
 
-`transfer()` is the one-call path for moving value — it builds the right transaction for the asset, then you sign and send it like any other:
+`address.signTransaction(tx)` returns straight away and does not wait for the signature. To use the signed bytes (`tx.rawTransaction`, `tx.hash`), `await tx.sign()` first — it resolves once signing is done and is safe to call more than once.
+
+`buildTransferPayload()` is the one-call path for moving value — it works out the right payload for the asset (native value, ERC-20 calldata, or SPL instructions). You then pass that payload to `buildTransaction()` and send it like any other transaction:
 
 ```ts
 // native coin (omit `asset`)
-const native = evmAddr.transfer({ to: recipient, amount: 1_000_000_000_000_000n });
+const nativePayload = evmAddr.buildTransferPayload({ to: recipient, amount: 1_000_000_000_000_000n });
 // an ERC-20 / SPL token, by contract address or mint
-const token = evmAddr.transfer({ to: recipient, asset: { address: usdcAddress }, amount: 1_000_000n });
+const tokenPayload = evmAddr.buildTransferPayload({ to: recipient, asset: { address: usdcAddress }, amount: 1_000_000n });
 // or by symbol, resolved against the network's known tokens
-const bySymbol = evmAddr.transfer({ to: recipient, asset: { symbol: "USDC" }, amount: 1_000_000n });
+const bySymbol = evmAddr.buildTransferPayload({ to: recipient, asset: { symbol: "USDC" }, amount: 1_000_000n });
 
-await evmAddr.signTransaction(native);
+// build the transaction from the payload, then sign/send it
+const tx = evmAddr.buildTransaction({ ...nativePayload, chainId: 1 });
+await tx.sign();
 ```
 
-Amounts are in the token's smallest unit. An SPL transfer to a recipient without a token account prepends the account-creation step for you.
+Amounts are in the token's smallest unit. `buildTransaction` fills in nonce/gas/fees for you when you omit them, or uses the values you pass. An SPL transfer to a recipient without a token account prepends the account-creation step for you.
+
+#### Signing bytes you built yourself
+
+If you build and broadcast transactions yourself and only need a signature, two methods sign exactly the bytes you give them. Neither hashes its input, adds a prefix, or touches the network.
+
+```ts
+// EVM: sign a 32-byte digest you computed (for example the keccak of an encoded transaction)
+const { r, s, recovery, signature } = evmAddr.signDigest("0x" + "ab".repeat(32));
+// r, s: 32-byte hex (s is low); recovery: 0 or 1; signature: 65 bytes, v = 27 + recovery
+
+// SVM: sign arbitrary bytes, for example a serialized Solana transaction message
+const { signature: sig58, signatureHex } = svmAddr.signBytes(messageBytes);
+```
+
+- Both take a `Uint8Array` or a `0x`-prefixed hex string of whole bytes. Base64 and hex without the prefix are refused; decode base64 yourself first.
+- `signDigest` requires exactly 32 bytes.
+- `signBytes` accepts any length, including binary data that `signMessageEncoded(..., "ed25519")` cannot carry, because that method takes text.
+- The 65-byte `signature` uses the message-signing convention for `v`. For a typed transaction use `recovery` as the y-parity, and for a legacy EIP-155 transaction use `35 + 2 * chainId + recovery`.
+- `signDigest` works only on an EVM address and `signBytes` only on an SVM address. Each needs the account unlocked.
+
+> ⚠️ These sign anything you hand them, with none of the checks `signTypedData` applies. Only pass digests and bytes you assembled yourself.
 
 ### Network — pre-loaded networks + your own
 
@@ -579,7 +604,8 @@ const evmTx = new EvmTransaction({
   maxFeePerGas: 50_000_000_000n,
   maxPriorityFeePerGas: 1_000_000_000n,
 });
-await evmAddr.signTransaction(evmTx);
+evmAddr.signTransaction(evmTx);  // checks `from` and attaches the transaction to this address
+await evmTx.sign();               // resolves once the signature exists
 const evmTracker = await evmAddr.sendTransaction(evmTx);
 
 const receipt = await evmTracker.whenConfirmed();
@@ -791,7 +817,7 @@ class MyDialect extends ChainDialect {
 
   signMessage(ctx: ChainCtx, message: string): string { /* build a digest, sign via ctx._signBytes, format */ }
   buildTransaction(ctx, params) { /* return your chain's transaction */ }
-  transfer(ctx, req)            { /* lower { to, asset, amount } to a transaction */ }
+  buildTransferPayload(ctx, req) { /* lower { to, asset, amount } to a transfer payload */ }
   derive(seed, index)           { /* return { publicKey, privateKey } at this index */ }
   addressFromPrivateKey(pk)     { /* the address a key controls */ }
   privateKeyMatches(pk, publicKey) { /* whether a key controls an address */ }