@ar.io/sdk 4.0.1 → 4.0.2-alpha.1

package/lib/esm/solana/io-writeable.js

@@ -1479,11 +1479,27 @@ export class SolanaARIOWriteable extends SolanaARIOReadable {
                 extend: CostIntent.ExtendLease,
                 increaseUndername: CostIntent.IncreaseUndernameLimit,
             };
+            // IncreaseUndernameLimit pricing requires the record's purchase type
+            // (lease vs permabuy) — undername cost differs by type, and the on-chain
+            // instruction reads it from the record. `get_token_cost` can't read the
+            // record (it only gets demandFactor + payer), so it prices from params and
+            // REQUIRES `purchase_type` for this intent (else InvalidParameter #6039).
+            // Pass the record's actual type so the estimate matches what the
+            // instruction will charge.
+            let purchaseType;
+            if (args.operation === 'increaseUndername') {
+                const record = await this.getArNSRecord({ name: args.params.name });
+                purchaseType =
+                    record.type === 'permabuy'
+                        ? PurchaseType.Permabuy
+                        : PurchaseType.Lease;
+            }
             const cost = await this._simulateTokenCost({
                 intent: intentMap[args.operation],
                 name: args.params.name,
                 years: args.years,
                 quantity: args.quantity,
+                purchaseType,
             });
             const plan = await this._resolveFundingPlan(args.params, cost);
             const buyerATA = await getAssociatedTokenAddressKit(arnsConfig.mint, this.signer.address);
@@ -1757,9 +1773,21 @@ export class SolanaARIOWriteable extends SolanaARIOReadable {
      * funding-source slice to ario-gar's pay_from_funding_plan via CPI.
      */
     async _buildPrimaryNameFromFundingPlanIx(args) {
+        // The primary-name fee is purchase-type-aware: the on-chain handler
+        // (ario-core `primary_name_base_fee`) reads the base record's purchase_type
+        // and charges 5x for permabuy vs lease. `get_token_cost` defaults a missing
+        // purchase_type to Lease, so for a permabuy base name the estimate would be
+        // 5x too low → FundingPlanAmountMismatch (#6066). Pass the base record's
+        // actual type so the plan total matches what the program charges.
+        const baseRecord = await this.getArNSRecord({
+            name: splitPrimaryName(args.params.name).baseName,
+        });
         const fee = await this._simulateTokenCost({
             intent: CostIntent.PrimaryNameRequest,
             name: args.params.name,
+            purchaseType: baseRecord.type === 'permabuy'
+                ? PurchaseType.Permabuy
+                : PurchaseType.Lease,
         });
         const plan = await this._resolveFundingPlan(args.params, fee);
         const garConfig = await this.getGarConfig();

package/lib/esm/solana/send.js

@@ -26,26 +26,67 @@
 import { ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS, getCloseLookupTableInstruction, getCreateLookupTableInstructionAsync, getDeactivateLookupTableInstruction, getExtendLookupTableInstruction, } from '@solana-program/address-lookup-table';
 import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from '@solana-program/compute-budget';
 import { appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, getAddressDecoder, getBase64EncodedWireTransaction, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
+/**
+ * Floor for the auto-estimated priority fee (micro-lamports per CU). Ensures a
+ * non-zero fee so message-modifying wallets (Phantom) leave the tx alone. The
+ * absolute cost stays tiny: `fee ≈ price * CU_limit / 1e6` lamports
+ * (e.g. 10_000 µ£/CU × 400k CU ≈ 4_000 lamports ≈ 0.000004 SOL).
+ */
+const MIN_PRIORITY_FEE_MICRO_LAMPORTS = 10000n;
+/** Cap so a spiky fee market can't blow up the fee unexpectedly. */
+const MAX_PRIORITY_FEE_MICRO_LAMPORTS = 2000000n;
+/**
+ * Estimate a compute-unit price from recent on-chain prioritization fees: the
+ * 75th percentile of recent non-zero per-slot fees, clamped to
+ * [{@link MIN_PRIORITY_FEE_MICRO_LAMPORTS}, {@link MAX_PRIORITY_FEE_MICRO_LAMPORTS}].
+ * Falls back to the floor when there's no data or the query fails. Matching the
+ * going rate both lands the tx and keeps Phantom from bumping (and thus
+ * rewriting) the fee.
+ */
+export async function estimatePriorityFeeMicroLamports(rpc) {
+    try {
+        const recent = await rpc.getRecentPrioritizationFees().send();
+        const fees = recent
+            .map((r) => BigInt(r.prioritizationFee))
+            .filter((f) => f > 0n)
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        if (fees.length === 0)
+            return MIN_PRIORITY_FEE_MICRO_LAMPORTS;
+        const p75 = fees[Math.min(fees.length - 1, Math.floor(fees.length * 0.75))];
+        if (p75 < MIN_PRIORITY_FEE_MICRO_LAMPORTS)
+            return MIN_PRIORITY_FEE_MICRO_LAMPORTS;
+        if (p75 > MAX_PRIORITY_FEE_MICRO_LAMPORTS)
+            return MAX_PRIORITY_FEE_MICRO_LAMPORTS;
+        return p75;
+    }
+    catch {
+        return MIN_PRIORITY_FEE_MICRO_LAMPORTS;
+    }
+}
 /**
  * Build, sign, send, and confirm a transaction in one call.
  *
  * The caller supplies the core instructions; a compute-unit-limit instruction
  * is prepended automatically.
  */
-export async function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment = 'confirmed', computeUnitLimit = 400_000, addressLookupTables, }) {
+export async function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment = 'confirmed', computeUnitLimit = 400_000, priorityFeeMicroLamports = 'auto', addressLookupTables, }) {
+    const microLamports = priorityFeeMicroLamports === 'auto'
+        ? await estimatePriorityFeeMicroLamports(rpc)
+        : priorityFeeMicroLamports === false
+            ? 0n
+            : BigInt(priorityFeeMicroLamports);
     const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
     const baseMessage = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
         getSetComputeUnitLimitInstruction({ units: computeUnitLimit }),
-        // Always pin the priority fee (even at 0) so wallets like Phantom
-        // don't silently *append* their own compute-budget instructions
-        // when the transaction is missing either limit or price. That
-        // mutation invalidates signatures already attached by paired
-        // keypair signers (e.g. the ANT mint signer in `spawnSolanaANT`),
-        // producing `Transaction did not pass signature verification` on
-        // the validator. Pre-supplying both keeps the wallet from
-        // rewriting the message, so signatures over the original bytes
-        // still verify.
-        getSetComputeUnitPriceInstruction({ microLamports: 0n }),
+        // Pin an explicit, NON-ZERO priority fee so wallets like Phantom
+        // don't rewrite the message to inject their own compute-budget
+        // instructions. Phantom treats a missing/zero fee as "unset" and
+        // overrides it on mainnet — that mutation invalidates the already-
+        // attached signatures (→ "Transaction did not pass signature
+        // verification" / preflight #-32002). A real, network-rate fee
+        // (see `microLamports` above) makes the wallet leave the message
+        // alone, so signatures over the original bytes still verify.
+        getSetComputeUnitPriceInstruction({ microLamports }),
         ...instructions,
     ], tx));
     // Compress against any supplied lookup tables (v0). No-op when none given.

package/lib/esm/solana/spawn-ant.js

@@ -30,13 +30,14 @@
  * `import_account` instruction — that's intentional and not what this SDK
  * helper is for.
  */
-import { addSignersToTransactionMessage, appendTransactionMessageInstructions, createTransactionMessage, generateKeyPairSigner, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
+import { addSignersToTransactionMessage, appendTransactionMessageInstructions, compileTransaction, createTransactionMessage, generateKeyPairSigner, getSignatureFromTransaction, isTransactionModifyingSigner, partiallySignTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
 import { getInitializeInstructionAsync } from '@ar.io/solana-contracts/ant';
 import { DataState, getCreateV1Instruction, } from '@ar.io/solana-contracts/mpl-core';
 import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from '@solana-program/compute-budget';
 import { SolanaANTRegistryWriteable } from './ant-registry-writeable.js';
 import { ARIO_ANT_PROGRAM_ID } from './constants.js';
 import { getAntRecordPDA } from './pda.js';
+import { estimatePriorityFeeMicroLamports } from './send.js';
 /** AR.IO logo Arweave TX — matches the Rust default in `ario_ant::initialize`. */
 export const ARIO_LOGO_TX_ID = 'AnYvLJTWcG9lr2Ll5MwYWZR2o5uTE39WbpYB0zCxwKM';
 /**
@@ -193,14 +194,17 @@ export async function spawnSolanaANT(params) {
     // them up from the account metadata roles: accounts marked as SIGNER roles
     // must have a matching `TransactionSigner` attached. We do that by placing
     // the mint signer on the message alongside the fee payer signer.
-    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const [{ value: latestBlockhash }, microLamports] = await Promise.all([
+        rpc.getLatestBlockhash().send(),
+        estimatePriorityFeeMicroLamports(rpc),
+    ]);
     const message = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
         getSetComputeUnitLimitInstruction({ units: computeUnitLimit }),
-        // Pin the priority fee (at 0) so wallets like Phantom don't
-        // silently append their own compute-budget instructions and
-        // invalidate the paired mint keypair signer's signature. See
-        // `sendAndConfirm` in `./send.js` for the full rationale.
-        getSetComputeUnitPriceInstruction({ microLamports: 0n }),
+        // Pin a non-zero priority fee (see `estimatePriorityFeeMicroLamports`).
+        // A real fee both lands the tx and, per Phantom's docs, stops the
+        // wallet from injecting its own fee. The paired mint-keypair signing
+        // is handled below.
+        getSetComputeUnitPriceInstruction({ microLamports }),
         createIx,
         initIx,
         ...aclIxs,
@@ -210,7 +214,26 @@ export async function spawnSolanaANT(params) {
     // metas and registers each matching signer by address, which is what
     // `signTransactionMessageWithSigners` then looks up to produce signatures.
     const withMintSigner = addSignersToTransactionMessage([mintSigner], message);
-    const signedTx = await signTransactionMessageWithSigners(withMintSigner);
+    // Multi-signer spawn (fee-payer wallet + fresh mint keypair). Browser wallets
+    // like Phantom REWRITE transactions that carry no signature yet (injecting
+    // priority-fee / Lighthouse-guard instructions) — which invalidates the mint
+    // keypair's signature → "address is not a signer" (#5663015). Per Phantom's
+    // docs it leaves a transaction alone once it already has a signature. So when
+    // the wallet is a modifying signer, sign with the mint keypair FIRST, then let
+    // the wallet sign: it sees the existing mint signature and won't rewrite,
+    // keeping both signatures valid. kit's own pipeline can't express this order
+    // (it always runs modifying signers before partial ones), so we orchestrate
+    // it manually here. Non-modifying signers (keypairs in node/tests) carry no
+    // rewrite risk and use kit's normal pipeline.
+    let signedTx;
+    if (isTransactionModifyingSigner(signer)) {
+        const compiled = compileTransaction(withMintSigner);
+        const mintPreSigned = await partiallySignTransaction([mintSigner.keyPair], compiled);
+        [signedTx] = await signer.modifyAndSignTransactions([mintPreSigned]);
+    }
+    else {
+        signedTx = await signTransactionMessageWithSigners(withMintSigner);
+    }
     const sendAndConfirmFactory = sendAndConfirmTransactionFactory({
         rpc,
         rpcSubscriptions,

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '4.0.1';
+export const version = '4.0.2-alpha.1';

package/lib/types/solana/send.d.ts

@@ -1,18 +1,40 @@
 import { type Address, type Commitment, type Instruction, type TransactionSigner } from '@solana/kit';
 import type { SolanaRpc, SolanaRpcSubscriptions } from './types.js';
+/**
+ * Estimate a compute-unit price from recent on-chain prioritization fees: the
+ * 75th percentile of recent non-zero per-slot fees, clamped to
+ * [{@link MIN_PRIORITY_FEE_MICRO_LAMPORTS}, {@link MAX_PRIORITY_FEE_MICRO_LAMPORTS}].
+ * Falls back to the floor when there's no data or the query fails. Matching the
+ * going rate both lands the tx and keeps Phantom from bumping (and thus
+ * rewriting) the fee.
+ */
+export declare function estimatePriorityFeeMicroLamports(rpc: SolanaRpc): Promise<bigint>;
 /**
  * Build, sign, send, and confirm a transaction in one call.
  *
  * The caller supplies the core instructions; a compute-unit-limit instruction
  * is prepended automatically.
  */
-export declare function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment, computeUnitLimit, addressLookupTables, }: {
+export declare function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment, computeUnitLimit, priorityFeeMicroLamports, addressLookupTables, }: {
     rpc: SolanaRpc;
     rpcSubscriptions: SolanaRpcSubscriptions;
     signer: TransactionSigner;
     instructions: Instruction[];
     commitment?: Commitment;
     computeUnitLimit?: number;
+    /**
+     * Compute-unit price (priority fee), in micro-lamports per CU.
+     * - `'auto'` (default): estimate from recent on-chain fees (see
+     *   {@link estimatePriorityFeeMicroLamports}). A NON-ZERO fee is essential:
+     *   wallets like Phantom treat a missing/zero fee as "unset" and rewrite the
+     *   transaction to inject their own, which invalidates already-attached
+     *   signatures (→ "Transaction did not pass signature verification"). A real,
+     *   network-rate fee makes the wallet leave the message untouched.
+     * - a `number`/`bigint`: pin exactly this price.
+     * - `false`: no priority fee (price 0) — only for environments with no fee
+     *   market (localnet) where wallet rewriting isn't a concern.
+     */
+    priorityFeeMicroLamports?: bigint | number | 'auto' | false;
     /**
      * Address Lookup Tables to compress the (v0) message against, as
      * `{ [tableAddress]: addresses }`. Accounts present in a table are referenced

package/lib/types/version.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const version = "4.0.0";
+export declare const version = "4.0.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ar.io/sdk",
-  "version": "4.0.1",
+  "version": "4.0.2-alpha.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ar-io/ar-io-sdk.git"