@ar.io/sdk 4.0.0 → 4.0.2

package/lib/esm/solana/clusters.js

@@ -90,10 +90,8 @@ export const MAINNET_ATTESTOR_PUBKEY = address('7XtUnotZAeYZNzVSYV5nb7S9YH9qHXyV
  * here for reference.
  */
 export const MAINNET_AUTHORITY_PUBKEY = address('45ZuEb1Jk7pbjshD1BVasBekAXhimdWuJjyswQzMyTB1');
-// TODO(mainnet): placeholder — this reuses the devnet mint and is WRONG for
-// mainnet. Replace with the real mainnet ARIO mint once it is known.
 /** ARIO SPL Token mint on Solana mainnet-beta. */
-export const MAINNET_ARIO_MINT = address('6vTw5CysRXQ4ybbHkDUiisHWVsBeMtUzYvJqs2iqHyaN');
+export const MAINNET_ARIO_MINT = address('DcNnMuFxwhgV4WY1HVSaSEgr92bv2b1vUvEKiNxWqHdF');
 /**
  * AR.IO program IDs deployed on Solana devnet (staging).
  *

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/version.js

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

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-alpha.4";
+export declare const version = "4.0.1";

package/package.json

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