@ardrive/turbo-sdk 1.41.3 → 1.42.0-alpha.10

package/lib/cjs/cli/utils.js

@@ -124,7 +124,9 @@ async function privateKeyFromOptions({ mnemonic, privateKey, walletFile, token,
     }
     else if (walletFile !== undefined) {
         const wallet = JSON.parse((0, fs_1.readFileSync)(walletFile, 'utf-8'));
-        return token === 'solana' ? bs58_1.default.encode(wallet) : wallet;
+        return token === 'solana' || token === 'ario'
+            ? bs58_1.default.encode(wallet)
+            : wallet;
     }
     else if (privateKey !== undefined) {
         return privateKey;
@@ -138,8 +140,6 @@ function configFromOptions(options) {
     let paymentUrl = undefined;
     let uploadUrl = undefined;
     let gatewayUrl = undefined;
-    let processId = undefined;
-    let cuUrl = undefined;
     if (options.local && options.dev) {
         throw new Error('Cannot use both --local and --dev flags');
     }
@@ -148,10 +148,6 @@ function configFromOptions(options) {
         paymentUrl = index_js_1.developmentTurboConfiguration.paymentServiceConfig.url;
         uploadUrl = index_js_1.developmentTurboConfiguration.uploadServiceConfig.url;
         gatewayUrl = common_js_1.tokenToDevGatewayMap[token];
-        if (options.token === 'ario') {
-            processId = common_js_1.tokenToDevAoConfigMap[token].processId;
-            cuUrl = common_js_1.tokenToDevAoConfigMap[token].cuUrl;
-        }
     }
     else if (options.local) {
         // Use local endpoints
@@ -163,10 +159,6 @@ function configFromOptions(options) {
         // Use default endpoints
         paymentUrl = index_js_1.defaultTurboConfiguration.paymentServiceConfig.url;
         uploadUrl = index_js_1.defaultTurboConfiguration.uploadServiceConfig.url;
-        if (options.token === 'ario') {
-            processId = common_js_1.defaultProdAoConfigs[token].processId;
-            cuUrl = common_js_1.defaultProdAoConfigs[token].cuUrl;
-        }
     }
     // Override gateway, payment, and upload service default endpoints if provided
     if (options.gateway !== undefined) {
@@ -178,19 +170,11 @@ function configFromOptions(options) {
     if (options.uploadUrl !== undefined) {
         uploadUrl = options.uploadUrl;
     }
-    if (options.cuUrl !== undefined) {
-        cuUrl = options.cuUrl;
-    }
-    if (options.processId !== undefined) {
-        processId = options.processId;
-    }
     const config = {
         paymentServiceConfig: { url: paymentUrl },
         uploadServiceConfig: { url: uploadUrl },
         gatewayUrl,
         token,
-        processId,
-        cuUrl,
     };
     return config;
 }

package/lib/cjs/common/arnsActions.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildArNSCustodyMessage = buildArNSCustodyMessage;
+exports.arNSOwnerProofHeaders = arNSOwnerProofHeaders;
+exports.solanaOwnerSigner = solanaOwnerSigner;
+exports.emptySignatureSlots = emptySignatureSlots;
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const base64_js_1 = require("../utils/base64.js");
+/**
+ * Canonical ACTION-BOUND message for the owner proof.
+ *
+ * MUST match the bundler's `buildArNSCustodyMessage` byte for byte
+ * (newline-delimited) or every signature is rejected. The bundler rebuilds this
+ * from the request and verifies the signature over `message + nonce`, so a
+ * signature captured for one operation cannot authorize a different one, and
+ * the nonce is consumed on use so the same one cannot be replayed (e.g. to
+ * revert a record to an older value).
+ */
+function buildArNSCustodyMessage(action, fields) {
+    return ['arns', action, ...fields].join('\n');
+}
+/** Solana's signature-type discriminator in Turbo's signed-request scheme. */
+const SOLANA_SIGNATURE_TYPE = 4;
+/**
+ * The ANT owner's half of the envelope, in its own `x-owner-*` headers.
+ *
+ * Two signatures travel on a record action — the PAYER's signed request over
+ * `"" + nonce`, and the OWNER's action-bound proof over `message + nonce` —
+ * from two different keys, usually on two different chains. They cannot share
+ * one header set: whichever verifier ran second would reject a signature that
+ * was never meant for it.
+ */
+async function arNSOwnerProofHeaders(owner, message, nonce) {
+    const address = await owner.getAddress();
+    const signature = await owner.signMessage(Uint8Array.from(Buffer.from(message + nonce)));
+    return {
+        // A Solana address IS the base58-encoded 32-byte ed25519 public key, so
+        // decoding the address recovers exactly the bytes the bundler verifies
+        // against. Keeps ArNSOwnerSigner minimal — no separate getPublicKey().
+        'x-owner-public-key': (0, base64_js_1.toB64Url)(Buffer.from(bs58_1.default.decode(address))),
+        'x-owner-nonce': nonce,
+        'x-owner-signature': (0, base64_js_1.toB64Url)(Buffer.from(signature)),
+        'x-owner-signature-type': String(SOLANA_SIGNATURE_TYPE),
+    };
+}
+/**
+ * Build an {@link ArNSOwnerSigner} from a raw Solana secret key.
+ *
+ * For servers and tests. A browser wallet (Phantom, Solflare, or a console's
+ * embedded wallet) should implement the interface directly against its own
+ * `signTransaction` / `signMessage` rather than exposing a secret key.
+ *
+ * Note the owner needs a key to SIGN with, not a funded account: Turbo is the
+ * fee payer on every sponsored action, so this wallet's SOL balance can stay
+ * at zero for the entire life of the name.
+ */
+function solanaOwnerSigner(secretKey) {
+    const keypair = web3_js_1.Keypair.fromSecretKey(typeof secretKey === 'string' ? bs58_1.default.decode(secretKey) : secretKey);
+    return {
+        getAddress: () => keypair.publicKey.toBase58(),
+        signTransaction: async (transactionBase64) => {
+            const tx = web3_js_1.VersionedTransaction.deserialize(Buffer.from(transactionBase64, 'base64'));
+            // Sign the bytes as returned. Turbo's fee-payer signature already covers
+            // this exact message; rebuilding it from parts invalidates that and the
+            // submission is rejected.
+            tx.sign([keypair]);
+            return Buffer.from(tx.serialize()).toString('base64');
+        },
+        signMessage: async (message) => tweetnacl_1.default.sign.detached(message, keypair.secretKey),
+    };
+}
+/**
+ * Count the signature slots a prepared transaction still has empty.
+ *
+ * Turbo pre-signs as fee payer and leaves exactly one slot for the owner, so a
+ * client can assert that before prompting a wallet — a cheap way to catch a
+ * malformed or already-signed transaction before bothering the user.
+ */
+function emptySignatureSlots(transactionBase64) {
+    const tx = web3_js_1.VersionedTransaction.deserialize(Buffer.from(transactionBase64, 'base64'));
+    return tx.signatures.filter((sig) => sig.every((byte) => byte === 0)).length;
+}

package/lib/cjs/common/factory.js

@@ -46,7 +46,7 @@ class TurboBaseFactory {
             paymentService,
         });
     }
-    getAuthenticatedTurbo({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, logger, walletAdapter, processId, cuUrl, }) {
+    getAuthenticatedTurbo({ privateKey, signer: providedSigner, paymentServiceConfig = {}, uploadServiceConfig = {}, token, gatewayUrl, tokenMap, tokenTools, logger, walletAdapter, }) {
         token = token === 'pol' ? 'matic' : token;
         if (!token) {
             if (providedSigner) {
@@ -104,8 +104,6 @@ class TurboBaseFactory {
                 tokenTools = tokenMap.arweave;
             }
             tokenTools = index_js_1.defaultTokenMap[token]?.({
-                cuUrl,
-                processId,
                 gatewayUrl,
                 logger,
             });

package/lib/cjs/common/http.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TurboHTTPService = exports.defaultRetryConfig = void 0;
+exports.TurboHTTPService = exports.x402UploadEndpoints = exports.defaultRetryConfig = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -34,6 +34,18 @@ const defaultHeaders = {
     'x-turbo-source-version': version_js_1.version,
     'x-turbo-source-identifier': 'turbo-sdk',
 };
+/**
+ * Canonical x402 upload routes on the upload service.
+ *
+ * These were previously `/x402/data-item/{signed,unsigned}`. The service
+ * renamed them to `/x402/upload/*` and kept a `data-item/signed` alias, but not
+ * a `data-item/unsigned` one — so every unsigned x402 upload 404ed. Both
+ * canonical paths are served by all released upload-service versions.
+ */
+exports.x402UploadEndpoints = {
+    signed: '/x402/upload/signed',
+    unsigned: '/x402/upload/unsigned',
+};
 class TurboHTTPService {
     constructor({ url, logger, retryConfig = (0, exports.defaultRetryConfig)(logger), }) {
         this.logger = logger;
@@ -47,7 +59,7 @@ class TurboHTTPService {
             signal,
         }), allowedStatuses);
     }
-    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, x402Options, }) {
+    async post({ endpoint, signal, allowedStatuses = [200, 202], headers, data, x402Options, retry = true, }) {
         if (x402Options !== undefined) {
             return this.x402Post({
                 signal,
@@ -59,9 +71,10 @@ class TurboHTTPService {
         }
         // Convert all data types to fetch-compatible body
         const { body, duplex } = await toFetchBody(data);
-        // Use retry for Buffer/Uint8Array, tryRequest for streams
+        // Use retry for Buffer/Uint8Array, tryRequest for streams. Callers can opt
+        // out of retry for non-idempotent signed writes via `retry: false`.
         const isReusableData = data instanceof Buffer || data instanceof Uint8Array;
-        const requestFn = isReusableData
+        const requestFn = isReusableData && retry
             ? this.withRetry.bind(this)
             : this.tryRequest.bind(this);
         return requestFn(() => fetch(this.baseURL + endpoint, {
@@ -123,7 +136,9 @@ class TurboHTTPService {
         throw new errors_js_1.FailedRequestError('Max retries reached - ' + lastError?.message, lastError?.status);
     }
     async x402Post({ signal, allowedStatuses, headers, data, x402Options, }) {
-        const endpoint = '/x402/data-item/' + (x402Options.unsignedData ? 'unsigned' : 'signed');
+        const endpoint = x402Options.unsignedData
+            ? exports.x402UploadEndpoints.unsigned
+            : exports.x402UploadEndpoints.signed;
         this.logger.debug('Using X402 options for POST request', {
             endpoint,
             x402Options,

package/lib/cjs/common/index.js

@@ -31,6 +31,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./upload.js"), exports);
 __exportStar(require("./payment.js"), exports);
+// The ANT-owner helpers. Without this the documented
+// `import { solanaOwnerSigner } from '@ardrive/turbo-sdk'` does not resolve.
+__exportStar(require("./arnsActions.js"), exports);
 __exportStar(require("./turbo.js"), exports);
 __exportStar(require("./currency.js"), exports);
 __exportStar(require("./token/index.js"), exports);
+// Typed errors so consumers can `catch (e) { if (e instanceof InsufficientCreditsError) ... }`
+// e.g. to prompt a top-up on a 402 ArNS purchase.
+__exportStar(require("../utils/errors.js"), exports);