permaweb-deploy 3.4.2 → 3.4.3

package/dist/chunks/upload-workflow-zlELdPNp.js

@@ -0,0 +1,930 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { TurboFactory, ETHToTokenAmount, ARIOToTokenAmount, OnDemandFunding } from '@ardrive/turbo-sdk';
+import chalk from 'chalk';
+import ora from 'ora';
+import { l as loadCache, u as uploadFile, c as cleanupCache, s as saveCache, a as uploadFolder } from './uploader-DDS_d-O_.js';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { Readable } from 'node:stream';
+import { createDataItemSigner, message } from '@permaweb/aoconnect';
+import { expandPath } from '../utils/path.js';
+import { createSigner } from '../utils/signer.js';
+
+class HyperbalanceError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "HyperbalanceError";
+    }
+}
+class MissingDiscoveryError extends HyperbalanceError {
+    attemptedUrls;
+    constructor(attemptedUrls) {
+        super(`No hyperbalance discovery endpoint found: ${attemptedUrls.join(", ")}`);
+        this.attemptedUrls = attemptedUrls;
+        this.name = "MissingDiscoveryError";
+    }
+}
+class PaymentRequiredError extends HyperbalanceError {
+    required;
+    available;
+    constructor(message, required, available) {
+        super(message);
+        this.required = required;
+        this.available = available;
+        this.name = "PaymentRequiredError";
+    }
+}
+
+const DEFAULT_DISCOVERY_PATHS = ["/.well-known/hyperbalance"];
+function normalizeNodeUrl(nodeUrl) {
+    return nodeUrl.replace(/\/+$/, "");
+}
+async function discoverPaymentProfile(nodeUrl, options = {}) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const base = normalizeNodeUrl(nodeUrl);
+    const paths = options.paths ?? DEFAULT_DISCOVERY_PATHS;
+    const attemptedUrls = [];
+    for (const path of paths) {
+        const url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+        attemptedUrls.push(url);
+        const response = await fetcher(url, { headers: { accept: "application/json" } }).catch(() => undefined);
+        if (!response?.ok)
+            continue;
+        const profile = (await response.json());
+        validateProfile(profile);
+        return profile;
+    }
+    throw new MissingDiscoveryError(attemptedUrls);
+}
+function validateProfile(profile) {
+    if (!profile || typeof profile !== "object") {
+        throw new Error("Invalid hyperbalance profile: expected object");
+    }
+    if (!Array.isArray(profile.ledgers)) {
+        throw new Error("Invalid hyperbalance profile: ledgers must be an array");
+    }
+    if (!Array.isArray(profile.tokens)) {
+        throw new Error("Invalid hyperbalance profile: tokens must be an array");
+    }
+}
+
+function getLedger(profile, ledgerId) {
+    const ledger = profile.ledgers.find((candidate) => candidate.id === ledgerId);
+    if (!ledger) {
+        throw new Error(`Ledger not found in payment profile: ${ledgerId}`);
+    }
+    return ledger;
+}
+function getToken(profile, tokenId) {
+    const token = profile.tokens.find((candidate) => candidate.id === tokenId);
+    if (!token) {
+        throw new Error(`Token not found in payment profile: ${tokenId}`);
+    }
+    return token;
+}
+
+async function parseBalanceResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const raw = await response.text();
+    if (contentType.includes("application/json")) {
+        const parsed = JSON.parse(raw);
+        return parseBalanceValue(parsed);
+    }
+    return BigInt(raw.trim());
+}
+async function parseQuoteResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const raw = await response.text();
+    if (contentType.includes("application/json")) {
+        const parsed = JSON.parse(raw);
+        const quote = parseQuoteValue(parsed);
+        return { ...quote, raw: parsed };
+    }
+    return { amount: BigInt(raw.trim()), raw };
+}
+function parseBalanceValue(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number")
+        return BigInt(value);
+    if (typeof value === "string")
+        return BigInt(value);
+    if (value && typeof value === "object") {
+        const record = value;
+        for (const key of ["balance", "value", "amount", "ok"]) {
+            if (key in record)
+                return parseBalanceValue(record[key]);
+        }
+    }
+    throw new Error("Could not parse ledger balance response");
+}
+function parseQuoteValue(value) {
+    if (typeof value === "bigint" || typeof value === "number" || typeof value === "string") {
+        return { amount: BigInt(value) };
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const amountKey = ["amount", "price", "quote", "value", "ok"].find((key) => key in record);
+        if (!amountKey) {
+            throw new Error("Could not parse quote amount response");
+        }
+        const quote = parseQuoteValue(record[amountKey]);
+        const ledgerId = typeof record.ledgerId === "string" ? record.ledgerId : undefined;
+        const tokenId = typeof record.tokenId === "string" ? record.tokenId : undefined;
+        return {
+            amount: quote.amount,
+            ...(ledgerId !== undefined && { ledgerId }),
+            ...(tokenId !== undefined && { tokenId }),
+        };
+    }
+    throw new Error("Could not parse quote amount response");
+}
+
+function applyTemplate(template, values) {
+    return template.replaceAll(/\{([A-Za-z0-9_-]+)\}/g, (_match, key) => {
+        const value = values[key];
+        if (value === undefined) {
+            throw new Error(`Missing template value: ${key}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+function applyTemplateMap(templates, values) {
+    if (!templates)
+        return {};
+    return Object.fromEntries(Object.entries(templates).map(([key, template]) => [key, applyTemplate(template, values)]));
+}
+
+class HyperbalanceClient {
+    fetch;
+    nodeUrl;
+    constructor(options) {
+        this.fetch = options.fetch ?? globalThis.fetch;
+        this.nodeUrl = normalizeNodeUrl(options.nodeUrl);
+    }
+    discover(options = {}) {
+        return discoverPaymentProfile(this.nodeUrl, { ...options, fetch: this.fetch });
+    }
+    async getBalance(request) {
+        const ledger = getLedger(request.profile, request.ledgerId);
+        const path = applyTemplate(ledger.balancePath, { address: request.address });
+        const response = await this.fetch(this.absoluteUrl(path), {
+            headers: { accept: "application/json, text/plain" },
+        });
+        if (response.status === 404) {
+            return {
+                address: request.address,
+                ledger,
+                value: 0n,
+            };
+        }
+        if (!response.ok) {
+            throw new Error(`Balance request failed: ${response.status} ${response.statusText}`);
+        }
+        return {
+            address: request.address,
+            ledger,
+            value: await parseBalanceResponse(response),
+        };
+    }
+    async ensureCredit(request) {
+        const token = getToken(request.profile, request.tokenId);
+        const ledger = getLedger(request.profile, request.ledgerId);
+        const before = await this.getBalance({
+            address: request.recipient,
+            ledgerId: ledger.id,
+            profile: request.profile,
+        });
+        if (before.value >= request.minimumBalance) {
+            return {
+                after: before,
+                before,
+                shortfall: 0n,
+            };
+        }
+        const shortfall = request.minimumBalance - before.value;
+        const depositAddress = token.depositAddress ?? request.profile.node?.operator;
+        if (!depositAddress) {
+            throw new PaymentRequiredError("Payment is required, but the node did not advertise a deposit address", request.minimumBalance, before.value);
+        }
+        if (token.transfer?.kind && token.transfer.kind !== request.transferAdapter.kind) {
+            throw new Error(`Transfer adapter kind mismatch: token expects ${token.transfer.kind}, got ${request.transferAdapter.kind}`);
+        }
+        const sender = await request.transferAdapter.inferSender?.();
+        const transferRequest = {
+            amount: shortfall,
+            depositAddress,
+            recipient: request.recipient,
+            token,
+        };
+        if (sender !== undefined)
+            transferRequest.sender = sender;
+        const transfer = await request.transferAdapter.transfer(transferRequest);
+        const importRequest = {
+            amount: shortfall,
+            ledger,
+            profile: request.profile,
+            recipient: request.recipient,
+            token,
+            transfer,
+        };
+        const importSender = transfer.sender ?? sender;
+        if (importSender !== undefined)
+            importRequest.sender = importSender;
+        const imported = await this.importDeposit(importRequest);
+        const after = await this.getBalance({
+            address: request.recipient,
+            ledgerId: ledger.id,
+            profile: request.profile,
+        });
+        return {
+            after,
+            before,
+            imported,
+            shortfall,
+            transfer,
+        };
+    }
+    async ensureCreditAuto(request) {
+        const profile = request.profile ?? (await this.discover());
+        const targetOptions = {
+            transferKind: request.transferAdapter.kind,
+        };
+        if (request.ledgerId !== undefined)
+            targetOptions.ledgerId = request.ledgerId;
+        if (request.tokenId !== undefined)
+            targetOptions.tokenId = request.tokenId;
+        const { ledger, token } = selectFundingTarget(profile, targetOptions);
+        return this.ensureCredit({
+            ledgerId: ledger.id,
+            minimumBalance: request.minimumBalance,
+            profile,
+            recipient: request.recipient,
+            tokenId: token.id,
+            transferAdapter: request.transferAdapter,
+        });
+    }
+    async quote(request) {
+        const descriptor = request.profile.pricing?.find((candidate) => candidate.action === request.action);
+        if (!descriptor?.quotePath) {
+            throw new Error(`No quote path advertised for action: ${request.action}`);
+        }
+        const values = request.params ?? {};
+        const url = new URL(this.absoluteUrl(applyTemplate(descriptor.quotePath, values)));
+        for (const [key, value] of Object.entries(applyTemplateMap(descriptor.query, values))) {
+            url.searchParams.set(key, value);
+        }
+        const bodyValues = applyTemplateMap(descriptor.body, values);
+        const hasBody = Object.keys(bodyValues).length > 0;
+        const init = {
+            headers: { accept: "application/json, text/plain" },
+            method: descriptor.method ?? (hasBody ? "POST" : "GET"),
+        };
+        if (hasBody) {
+            init.body = JSON.stringify(bodyValues);
+            init.headers = { ...init.headers, "content-type": "application/json" };
+        }
+        const response = await this.fetch(url, init);
+        if (!response.ok) {
+            throw new Error(`Quote request failed: ${response.status} ${response.statusText}`);
+        }
+        return parseQuoteResponse(response);
+    }
+    async quoteAuto(request) {
+        const quoteRequest = {
+            action: request.action,
+            profile: request.profile ?? (await this.discover()),
+        };
+        if (request.params !== undefined)
+            quoteRequest.params = request.params;
+        return this.quote(quoteRequest);
+    }
+    async importDeposit(request) {
+        const descriptor = request.token.import;
+        if (!descriptor) {
+            throw new Error(`Token does not advertise a deposit import flow: ${request.token.id}`);
+        }
+        const values = {
+            ledgerId: request.ledger.id,
+            messageId: request.transfer.messageId,
+            quantity: request.amount,
+            recipient: request.recipient,
+            sender: request.sender,
+            slot: request.transfer.slot,
+            tokenId: request.token.id,
+        };
+        const url = new URL(this.absoluteUrl(descriptor.path));
+        for (const [key, value] of Object.entries(applyTemplateMap(descriptor.query, values))) {
+            url.searchParams.set(key, value);
+        }
+        const bodyValues = applyTemplateMap(descriptor.body, values);
+        const hasBody = Object.keys(bodyValues).length > 0;
+        const init = {
+            method: descriptor.method ?? "POST",
+        };
+        if (hasBody) {
+            init.body = JSON.stringify(bodyValues);
+            init.headers = { "content-type": "application/json" };
+        }
+        const response = await this.fetch(url, init);
+        if (!response.ok) {
+            throw new Error(`Deposit import failed: ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        if (!text.trim())
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    absoluteUrl(pathOrUrl) {
+        if (/^https?:\/\//.test(pathOrUrl))
+            return pathOrUrl;
+        return `${this.nodeUrl}${pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`}`;
+    }
+}
+function selectFundingTarget(profile, options = {}) {
+    const token = options.tokenId
+        ? getToken(profile, options.tokenId)
+        : profile.tokens.find((candidate) => (!options.transferKind || candidate.transfer?.kind === options.transferKind) &&
+            (!options.ledgerId || candidate.ledgerId === options.ledgerId));
+    if (!token) {
+        throw new Error("No matching funding token found in payment profile");
+    }
+    const ledgerId = options.ledgerId ?? token.ledgerId;
+    if (!ledgerId) {
+        throw new Error(`Funding token does not specify a ledger: ${token.id}`);
+    }
+    return {
+        ledger: getLedger(profile, ledgerId),
+        token,
+    };
+}
+
+class AoTokenTransferAdapter {
+    options;
+    kind = "ao";
+    inferSender;
+    constructor(options) {
+        this.options = options;
+        if (options.inferSender) {
+            this.inferSender = options.inferSender;
+        }
+    }
+    async transfer(request) {
+        const transfer = request.token.transfer;
+        assertAoTransferDescriptor(request.token, transfer);
+        const tags = buildAoTransferTags(request, transfer);
+        const messageId = await this.options.message({
+            data: "",
+            process: transfer.processId,
+            tags,
+        });
+        const slot = await this.options.waitForAssignmentSlot?.(messageId, {
+            processId: transfer.processId,
+        });
+        const result = { messageId };
+        if (request.sender !== undefined)
+            result.sender = request.sender;
+        if (slot !== undefined)
+            result.slot = slot;
+        return result;
+    }
+}
+async function waitForAoAssignmentSlot(options) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const stateUrl = (options.stateUrl ?? "https://state.forward.computer").replace(/\/+$/, "");
+    const pollMs = options.pollMs ?? 5000;
+    const timeoutMs = options.timeoutMs ?? 360000;
+    const fromSlot = Math.max(0, (await currentSlot(fetcher, stateUrl, options.processId)) - 5);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const toSlot = (await currentSlot(fetcher, stateUrl, options.processId)) + 20;
+        const url = `${stateUrl}/${options.processId}~process@1.0/schedule` +
+            `?from=${fromSlot}&to=${toSlot}&accept=application/aos-2`;
+        const response = await fetcher(url);
+        if (!response.ok) {
+            throw new Error(`AO schedule request failed: ${response.status} ${response.statusText}`);
+        }
+        const schedule = (await response.json());
+        for (const edge of schedule.edges ?? []) {
+            if (edge.node?.message?.Id === options.messageId) {
+                const slot = edge.node.assignment?.Tags?.find((tag) => tag.name === "Nonce")?.value;
+                if (!slot) {
+                    throw new Error(`AO assignment is missing Nonce for message ${options.messageId}`);
+                }
+                return slot;
+            }
+        }
+        await sleep(pollMs);
+    }
+    throw new Error(`AO message did not appear in schedule: ${options.messageId}`);
+}
+async function currentSlot(fetcher, stateUrl, processId) {
+    const response = await fetcher(`${stateUrl}/${processId}~process@1.0/slot/current`);
+    if (!response.ok) {
+        throw new Error(`AO current slot request failed: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    const match = text.match(/\d+/);
+    if (!match) {
+        throw new Error(`Could not parse AO current slot: ${text}`);
+    }
+    return Number(match[0]);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildAoTransferTags(request, transfer) {
+    const tags = applyTemplateMap(transfer.tags, {
+        depositAddress: request.depositAddress,
+        quantity: request.amount,
+        recipient: request.recipient,
+        sender: request.sender,
+        tokenId: request.token.id,
+    });
+    return Object.entries(tags).map(([name, value]) => ({ name, value }));
+}
+function assertAoTransferDescriptor(token, transfer) {
+    if (!transfer) {
+        throw new Error(`AO token does not advertise a transfer flow: ${token.id}`);
+    }
+    if (transfer.kind !== "ao") {
+        throw new Error(`Token transfer kind is not AO: ${transfer.kind}`);
+    }
+    if (!transfer.processId) {
+        throw new Error(`AO token is missing transfer.processId: ${token.id}`);
+    }
+}
+
+const DEFAULT_AO_TOKEN_ID = "0syT13r0s0tgPmIed95bJnuSqaD29HQNN8D3ElLSrsc";
+const HYPERBEAM_AO_BUNDLER_QUOTE_ACTION = "hyperbeam-upload";
+const HYPERBEAM_DEFAULT_LEDGER_ID = "default";
+const HYPERBEAM_DEFAULT_LEDGER_ROUTE = "/ledger~node-process@1.0";
+async function discoverHyperbeamAoBundlerProfile(options) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const nodeUrl = normalizeNodeUrl(options.nodeUrl);
+    const ledgerId = options.ledgerId ?? HYPERBEAM_DEFAULT_LEDGER_ID;
+    const ledgerRoute = options.ledgerRoute ?? HYPERBEAM_DEFAULT_LEDGER_ROUTE;
+    const tokenId = options.tokenId ?? DEFAULT_AO_TOKEN_ID;
+    const depositAddress = await fetchHyperbeamOperatorAddress(fetcher, nodeUrl);
+    return {
+        ledgers: [
+            {
+                balancePath: `${ledgerRoute}/now/balance/{address}`,
+                id: ledgerId,
+                route: ledgerRoute,
+                type: "process-ledger@1.0",
+                unit: "AO",
+            },
+        ],
+        node: {
+            operator: depositAddress,
+            url: nodeUrl,
+        },
+        pricing: [
+            {
+                action: HYPERBEAM_AO_BUNDLER_QUOTE_ACTION,
+                query: {
+                    amount: "{bytes}",
+                    resource: "arweave-bytes",
+                },
+                quotePath: "/~metering@1.0/quote",
+            },
+        ],
+        tokens: [
+            {
+                decimals: 12,
+                depositAddress,
+                id: tokenId,
+                import: {
+                    method: "POST",
+                    path: "/~ao-payment@1.0/ingest",
+                    query: {
+                        "message-id": "{messageId}",
+                        quantity: "{quantity}",
+                        recipient: "{recipient}",
+                        sender: "{sender}",
+                        slot: "{slot}",
+                        token: "{tokenId}",
+                    },
+                },
+                ledgerId,
+                network: "ao",
+                ticker: "AO",
+                transfer: {
+                    kind: "ao",
+                    processId: tokenId,
+                    tags: {
+                        Action: "Transfer",
+                        Quantity: "{quantity}",
+                        Recipient: "{depositAddress}",
+                    },
+                },
+            },
+        ],
+        version: "hyperbalance@0.1",
+    };
+}
+async function fetchHyperbeamOperatorAddress(fetcher, nodeUrl) {
+    const response = await fetcher(`${nodeUrl}/~meta@1.0/info/address`, {
+        headers: { accept: "text/plain" },
+    });
+    if (!response.ok) {
+        throw new Error(`HyperBEAM operator address request failed: ${response.status} ${response.statusText}`);
+    }
+    const address = (await response.text()).trim();
+    if (!address) {
+        throw new Error("HyperBEAM operator address response was empty");
+    }
+    return address;
+}
+
+const require$1 = createRequire(import.meta.url);
+const { ArweaveSigner, DataItem, createData } = require$1("@dha-team/arbundles");
+async function readableToBuffer(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function streamToBuffer(stream) {
+  if (Buffer.isBuffer(stream)) {
+    return stream;
+  }
+  if (stream instanceof Uint8Array) {
+    return Buffer.from(stream);
+  }
+  if (stream instanceof Readable) {
+    return readableToBuffer(stream);
+  }
+  if (stream && typeof stream.getReader === "function") {
+    return readableToBuffer(Readable.fromWeb(stream));
+  }
+  throw new Error("Unsupported upload stream type");
+}
+function toBase64Url(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return Buffer.from(value).toString("base64url");
+}
+function normalizeUploadUrl(base, uploadPath) {
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  const cleanPath = uploadPath.startsWith("/") ? uploadPath.slice(1) : uploadPath;
+  return new URL(cleanPath, normalizedBase).toString();
+}
+function arweaveAddressFromJwk(jwk) {
+  if (typeof jwk.n !== "string") {
+    throw new TypeError('Arweave JWK is missing modulus field "n"');
+  }
+  return createHash("sha256").update(Buffer.from(jwk.n, "base64url")).digest("base64url");
+}
+function parseHyperbeamFundAmount(value) {
+  if (!/^[1-9]\d*$/.test(value)) {
+    throw new Error("--hyperbeam-fund-amount must be a positive integer in token base units");
+  }
+  return BigInt(value);
+}
+async function ensureHyperbeamCredit(options, profile) {
+  const jwk = JSON.parse(Buffer.from(options.deployKey, "base64").toString("utf8"));
+  const recipient = arweaveAddressFromJwk(jwk);
+  const signer = createDataItemSigner(jwk);
+  const client = new HyperbalanceClient({ nodeUrl: options.uploader });
+  const adapter = new AoTokenTransferAdapter({
+    async inferSender() {
+      return recipient;
+    },
+    async message(input) {
+      return message({
+        data: input.data ?? "",
+        process: input.process,
+        signer,
+        tags: input.tags
+      });
+    },
+    async waitForAssignmentSlot(messageId, context) {
+      return waitForAoAssignmentSlot({
+        messageId,
+        pollMs: options.aoPollMs,
+        processId: context.processId,
+        stateUrl: options.aoStateUrl,
+        timeoutMs: options.aoTimeoutMs
+      });
+    }
+  });
+  return client.ensureCreditAuto({
+    ledgerId: options.ledgerId,
+    minimumBalance: options.minimumBalance,
+    profile,
+    recipient,
+    tokenId: options.tokenId ?? DEFAULT_AO_TOKEN_ID,
+    transferAdapter: adapter
+  });
+}
+async function autoFundQuotedHyperbeamLedger(options) {
+  const profile = await discoverHyperbeamAoBundlerProfile({
+    ledgerId: options.ledgerId,
+    nodeUrl: options.uploader,
+    tokenId: options.tokenId
+  });
+  const client = new HyperbalanceClient({ nodeUrl: options.uploader });
+  let { ledgerId } = options;
+  let { minimumBalance } = options;
+  let { tokenId } = options;
+  if (minimumBalance === void 0) {
+    const quote = await client.quoteAuto({
+      action: options.quoteAction ?? "hyperbeam-upload",
+      params: { bytes: options.signedBytes },
+      profile
+    });
+    minimumBalance = quote.amount;
+    ledgerId ??= quote.ledgerId;
+    tokenId ??= quote.tokenId;
+  }
+  return ensureHyperbeamCredit(
+    {
+      aoPollMs: options.aoPollMs,
+      aoStateUrl: options.aoStateUrl,
+      aoTimeoutMs: options.aoTimeoutMs,
+      deployKey: options.deployKey,
+      ledgerId,
+      minimumBalance,
+      tokenId,
+      uploader: options.uploader
+    },
+    profile
+  );
+}
+function hyperbeamBundlerLink(uploader, id) {
+  const normalizedBase = uploader.endsWith("/") ? uploader : `${uploader}/`;
+  return new URL(`~arweave@2.9/raw=${encodeURIComponent(id)}`, normalizedBase).toString();
+}
+function responseId(headers, body) {
+  const headerId = headers.get("id");
+  if (headerId) {
+    return headerId;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.id || parsed.body?.id;
+  } catch {
+    return void 0;
+  }
+}
+class HyperbeamBundlerClient {
+  autoFund;
+  signer;
+  uploader;
+  uploadUrl;
+  constructor({ autoFund, deployKey, uploadPath, uploader }) {
+    const jwk = JSON.parse(Buffer.from(deployKey, "base64").toString("utf8"));
+    this.autoFund = autoFund;
+    this.signer = new ArweaveSigner(jwk);
+    this.uploader = uploader;
+    this.uploadUrl = normalizeUploadUrl(uploader, uploadPath);
+  }
+  async uploadFile(args) {
+    const data = args.file ? typeof args.file === "string" ? fs.readFileSync(args.file) : args.file : await streamToBuffer(args.fileStreamFactory?.() ?? Readable.from([]));
+    const tags = args.dataItemOpts?.tags ?? [];
+    const item = createData(data, this.signer, { tags });
+    await item.sign(this.signer);
+    const raw = Buffer.from(item.getRaw());
+    const localId = item.id || toBase64Url(new DataItem(raw).id);
+    if (this.autoFund) {
+      await autoFundQuotedHyperbeamLedger({
+        ...this.autoFund,
+        signedBytes: raw.length
+      });
+    }
+    const res = await fetch(this.uploadUrl, {
+      body: raw,
+      headers: {
+        accept: "application/json, text/plain, */*",
+        "content-type": "application/octet-stream"
+      },
+      method: "POST"
+    });
+    const body = await res.text();
+    if (!res.ok) {
+      const preview = body.replaceAll(/\s+/g, " ").trim().slice(0, 300);
+      const paymentHint = res.status === 402 ? await this.paymentHint() : void 0;
+      throw new Error(
+        [
+          `HyperBEAM bundler upload failed with HTTP ${res.status}${preview ? `: ${preview}` : ""}`,
+          paymentHint
+        ].filter(Boolean).join("\n\n")
+      );
+    }
+    return { id: responseId(res.headers, body) || localId };
+  }
+  async paymentHint() {
+    try {
+      return hyperbeamAoFundingHint(
+        await discoverHyperbeamAoBundlerProfile({ nodeUrl: this.uploader })
+      );
+    } catch {
+      return void 0;
+    }
+  }
+}
+function hyperbeamAoFundingHint(profile) {
+  const lines = profile.tokens.map((token) => {
+    const depositAddress = token.depositAddress ?? profile.node?.operator;
+    if (!depositAddress) return;
+    const label = token.ticker ? `${token.ticker} (${token.id})` : token.id;
+    const ledger = token.ledgerId ? profile.ledgers.find((candidate) => candidate.id === token.ledgerId) : void 0;
+    const ledgerInfo = ledger ? ` Local ledger: ${ledger.id}${ledger.route ? ` at ${ledger.route}` : ""}.` : "";
+    return `- ${label}: send funds to ${depositAddress}.${ledgerInfo}`;
+  }).filter(Boolean);
+  if (lines.length === 0) return void 0;
+  return [
+    "The HyperBEAM node requires AO in its local ledger:",
+    ...lines,
+    "Use --hyperbeam-auto-fund to transfer AO and import the credit automatically before upload."
+  ].join("\n");
+}
+
+function getFolderSize(folderPath) {
+  let totalSize = 0;
+  for (const item of fs.readdirSync(folderPath)) {
+    const fullPath = path.join(folderPath, item);
+    const stats = fs.statSync(fullPath);
+    totalSize += stats.isDirectory() ? getFolderSize(fullPath) : stats.size;
+  }
+  return totalSize;
+}
+async function runUploadWorkflow(deployKey, config, io) {
+  const spinner = ora();
+  const uploaderType = config["uploader-type"] ?? "turbo";
+  let uploadClient;
+  let turbo;
+  if (uploaderType === "hyperbeam") {
+    if (config["sig-type"] !== "arweave") {
+      io.error("HyperBEAM uploads require --sig-type arweave");
+    }
+    if (!config.uploader) {
+      io.error("HyperBEAM uploads require --uploader <node-url>");
+    }
+    if (config["on-demand"]) {
+      io.error("HyperBEAM uploads do not support Turbo --on-demand payments");
+    }
+    let autoFund;
+    if (config["hyperbeam-auto-fund"]) {
+      autoFund = {
+        deployKey,
+        uploader: config.uploader
+      };
+      if (config["hyperbeam-ao-state-url"]) autoFund.aoStateUrl = config["hyperbeam-ao-state-url"];
+      if (config["hyperbeam-ledger-id"]) autoFund.ledgerId = config["hyperbeam-ledger-id"];
+      if (config["hyperbeam-token-id"]) autoFund.tokenId = config["hyperbeam-token-id"];
+      if (config["hyperbeam-fund-amount"]) {
+        autoFund.minimumBalance = parseHyperbeamFundAmount(config["hyperbeam-fund-amount"]);
+      }
+    }
+    spinner.start("Initializing HyperBEAM bundler");
+    uploadClient = new HyperbeamBundlerClient({
+      autoFund,
+      deployKey,
+      uploadPath: config["hyperbeam-upload-path"] ?? "/~bundler@1.0/item?codec-device=ans104@1.0",
+      uploader: config.uploader
+    });
+    spinner.succeed(`HyperBEAM bundler initialized (${chalk.cyan(config.uploader)})`);
+  } else {
+    spinner.start("Creating signer");
+    const { signer, token } = createSigner(config["sig-type"], deployKey);
+    spinner.succeed(`Signer created (${chalk.cyan(config["sig-type"])})`);
+    spinner.start("Initializing Turbo");
+    const turboFactoryArgs = { signer, token };
+    if (config.uploader) {
+      turboFactoryArgs.uploadServiceConfig = { url: config.uploader };
+    }
+    turbo = TurboFactory.authenticated(turboFactoryArgs);
+    uploadClient = turbo;
+    spinner.succeed("Turbo initialized");
+  }
+  let fundingMode;
+  if (config["on-demand"] && config["max-token-amount"]) {
+    const tokenType = config["on-demand"];
+    const maxAmount = Number.parseFloat(config["max-token-amount"]);
+    let maxTokenAmount;
+    switch (tokenType) {
+      case "ario": {
+        maxTokenAmount = ARIOToTokenAmount(maxAmount);
+        break;
+      }
+      case "base-eth": {
+        maxTokenAmount = ETHToTokenAmount(maxAmount);
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported on-demand token type: ${tokenType}`);
+      }
+    }
+    fundingMode = new OnDemandFunding({
+      maxTokenAmount,
+      topUpBufferMultiplier: 1.1
+    });
+  }
+  if (!fundingMode && turbo) {
+    spinner.start("Checking Turbo credits for upload");
+    try {
+      const uploadBytes = config["deploy-file"] ? (() => {
+        const filePath = expandPath(config["deploy-file"]);
+        return fs.statSync(filePath).size;
+      })() : (() => {
+        const folderPath = expandPath(config["deploy-folder"]);
+        return getFolderSize(folderPath);
+      })();
+      const FREE_THRESHOLD_BYTES = 107520;
+      if (uploadBytes >= FREE_THRESHOLD_BYTES) {
+        const [uploadCost] = await turbo.getUploadCosts({ bytes: [uploadBytes] });
+        const balance = await turbo.getBalance();
+        const requiredWinc = BigInt(uploadCost.winc);
+        const currentWinc = BigInt(balance.winc);
+        if (requiredWinc > currentWinc) {
+          spinner.fail("Insufficient Turbo credits");
+          io.error(
+            [
+              "Insufficient Turbo credits for this upload.",
+              `Required: ${requiredWinc.toString()} winc, available: ${currentWinc.toString()} winc.`,
+              "",
+              "Top up your Turbo balance (or re-run with --on-demand and --max-token-amount)."
+            ].join(" ")
+          );
+        }
+      }
+      spinner.succeed("Turbo credits check passed");
+    } catch (balanceError) {
+      spinner.fail("Failed to check Turbo credits");
+      const errorMessage = balanceError instanceof Error ? balanceError.message : String(balanceError);
+      io.error(`Failed to check Turbo credits: ${errorMessage}`);
+    }
+  }
+  let txOrManifestId;
+  try {
+    if (config["deploy-file"]) {
+      const filePath = expandPath(config["deploy-file"]);
+      spinner.start(`Uploading file ${chalk.yellow(config["deploy-file"])}`);
+      let cache = config["dedupe-cache-max-entries"] > 0 ? loadCache() : {};
+      const uploadResult = await uploadFile(uploadClient, filePath, { cache, fundingMode });
+      if (!uploadResult.transactionId) {
+        spinner.fail("File upload failed: no transaction ID returned");
+        io.error("File upload failed: no transaction ID returned");
+      }
+      txOrManifestId = uploadResult.transactionId;
+      if (uploadResult.updatedCache && config["dedupe-cache-max-entries"] > 0) {
+        cache = cleanupCache(uploadResult.updatedCache, config["dedupe-cache-max-entries"]);
+        saveCache(cache);
+      }
+      if (uploadResult.cacheHit) {
+        spinner.succeed(`File cache hit - reusing transaction ${chalk.green(txOrManifestId)}`);
+      } else {
+        const cacheMsg = config["dedupe-cache-max-entries"] > 0 ? chalk.gray("(cached for future uploads)") : "";
+        spinner.succeed(`File uploaded: ${chalk.green(txOrManifestId)} ${cacheMsg}`.trim());
+      }
+    } else {
+      const folderPath = expandPath(config["deploy-folder"]);
+      spinner.start(`Uploading folder ${chalk.yellow(config["deploy-folder"])}`);
+      let cache = config["dedupe-cache-max-entries"] > 0 ? loadCache() : {};
+      const uploadResult = await uploadFolder(uploadClient, folderPath, {
+        cache,
+        concurrency: config["hyperbeam-auto-fund"] ? 1 : void 0,
+        fundingMode,
+        throwOnFailure: true
+      });
+      if (!uploadResult.transactionId) {
+        spinner.fail("Folder upload failed: no transaction ID returned");
+        io.error("Folder upload failed: no transaction ID returned");
+      }
+      txOrManifestId = uploadResult.transactionId;
+      if (uploadResult.updatedCache && config["dedupe-cache-max-entries"] > 0) {
+        cache = cleanupCache(uploadResult.updatedCache, config["dedupe-cache-max-entries"]);
+        saveCache(cache);
+      }
+      const { cacheHits, totalFiles, uploaded } = uploadResult;
+      const statsMsg = cacheHits > 0 ? chalk.gray(` (${cacheHits}/${totalFiles} files cached, ${uploaded} uploaded)`) : "";
+      if (uploadResult.cacheHit) {
+        spinner.succeed(`All ${totalFiles} files cached - manifest: ${chalk.green(txOrManifestId)}`);
+      } else {
+        const cacheMsg = config["dedupe-cache-max-entries"] > 0 ? chalk.gray(" (files cached for future uploads)") : "";
+        spinner.succeed(`Folder uploaded: ${chalk.green(txOrManifestId)}${statsMsg}${cacheMsg}`);
+      }
+    }
+  } catch (uploadError) {
+    spinner.fail("Upload failed");
+    const errorMessage = uploadError instanceof Error ? uploadError.message : String(uploadError);
+    io.error(`Upload failed: ${errorMessage}`);
+  }
+  return txOrManifestId;
+}
+
+export { hyperbeamBundlerLink as h, runUploadWorkflow as r };
+//# sourceMappingURL=upload-workflow-zlELdPNp.js.map