Migrate from IPFS to Arweave

{
  "type": "ipfs-to-arweave-migration",
  "version": "1.0.0",
  "project": "MyProject",
  "createdAt": "2026-05-27T12:00:00Z",
  "items": [
    {
      "cid": "bafybeig...",
      "txId": "Xj9k2Lm8Pq3Rn5Tv7Wz1Yb4Dc6Fg8Hj0Kl2Mn4Pq6Rs8",
      "gatewayUrl": "https://arweave.net/Xj9k2Lm8Pq3Rn5Tv7Wz1Yb4Dc6Fg8Hj0Kl2Mn4Pq6Rs8",
      "arUri": "ar://Xj9k2Lm8Pq3Rn5Tv7Wz1Yb4Dc6Fg8Hj0Kl2Mn4Pq6Rs8",
      "contentType": "image/png",
      "bytes": 48291
    }
  ]
}

const migrationIndex = JSON.parse(fs.readFileSync('./migration-index.json', 'utf-8'));

const indexUpload = await turbo.upload({
  data: Buffer.from(JSON.stringify(migrationIndex)),
  dataItemOpts: {
    tags: [
      { name: 'Content-Type', value: 'application/json' },
      { name: 'App-Name', value: PROJECT_TAG },
      { name: 'Data-Type', value: 'IPFS-Migration-Index' },
      { name: 'Source-Protocol', value: 'ipfs' },
    ],
  },
});

console.log(`Migration index: https://arweave.net/${indexUpload.id}`);
console.log(`Migration index: ar://${indexUpload.id}`);

import { TurboFactory } from '@ardrive/turbo-sdk';
import fs from 'fs';
import path from 'path';

const IPFS_GATEWAY = process.env.IPFS_GATEWAY ?? 'https://ipfs.io/ipfs';
const STATE_FILE = './migration-state.jsonl';
const CONCURRENCY = 5;
const PROJECT_TAG = 'MyProject-Migration-v1';

const jwk = JSON.parse(fs.readFileSync('./wallet.json', 'utf-8'));
const turbo = TurboFactory.authenticated({ privateKey: jwk, token: 'arweave' });

const inventory = JSON.parse(fs.readFileSync('./cids.json', 'utf-8'));
const completed = new Set(
  fs.existsSync(STATE_FILE)
    ? fs.readFileSync(STATE_FILE, 'utf-8')
        .trim()
        .split('\n')
        .filter(Boolean)
        .map((line) => JSON.parse(line))
        .filter((r) => r.status === 'success')
        .map((r) => r.cid)
    : [],
);

function appendState(record) {
  fs.appendFileSync(STATE_FILE, JSON.stringify(record) + '\n');
}

async function fetchFromIpfs(cid) {
  const response = await fetch(`${IPFS_GATEWAY}/${cid}`, { redirect: 'follow' });
  if (!response.ok) throw new Error(`Fetch failed: ${response.status}`);
  const buffer = Buffer.from(await response.arrayBuffer());
  const contentType = response.headers.get('content-type') ?? 'application/octet-stream';
  return { buffer, contentType };
}

async function migrateOne({ cid, contentType: declaredType }) {
  if (completed.has(cid)) {
    console.log(`Skipping ${cid} (already migrated)`);
    return;
  }

  try {
    const { buffer, contentType } = await fetchFromIpfs(cid);
    const result = await turbo.upload({
      data: buffer,
      dataItemOpts: {
        tags: [
          { name: 'Content-Type', value: declaredType ?? contentType },
          { name: 'App-Name', value: PROJECT_TAG },
          { name: 'Source-Protocol', value: 'ipfs' },
          { name: 'Source-CID', value: cid },
          { name: 'Migration-Date', value: new Date().toISOString() },
        ],
      },
    });

    appendState({
      cid,
      txId: result.id,
      contentType: declaredType ?? contentType,
      bytes: buffer.length,
      status: 'success',
      uploadedAt: new Date().toISOString(),
    });

    console.log(`Migrated ${cid} → ar://${result.id}`);
  } catch (error) {
    appendState({
      cid,
      status: 'failed',
      error: error.message,
      failedAt: new Date().toISOString(),
    });
    console.error(`Failed ${cid}:`, error.message);
  }
}

async function runPool(items, fn, concurrency) {
  const queue = [...items];
  const workers = Array.from({ length: concurrency }, async () => {
    while (queue.length > 0) {
      const item = queue.shift();
      if (item) await fn(item);
    }
  });
  await Promise.all(workers);
}

await runPool(inventory, migrateOne, CONCURRENCY);
console.log('Migration complete. Review migration-state.jsonl for results.');

async function validateUpload(txId, expectedBuffer) {
  const response = await fetch(`https://turbo-gateway.com/${txId}`);
  if (!response.ok) throw new Error(`Gateway fetch failed: ${response.status}`);

  const actual = Buffer.from(await response.arrayBuffer());

  if (actual.length !== expectedBuffer.length) {
    throw new Error(`Size mismatch: expected ${expectedBuffer.length}, got ${actual.length}`);
  }

  if (!actual.equals(expectedBuffer)) {
    throw new Error(`Content mismatch for ${txId}`);
  }

  console.log(`Validated ar://${txId} (${actual.length} bytes)`);
}