Migrating from S3 to Waldrop

// Before — S3
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";

const s3 = new S3Client({ region: "us-east-1" });
await s3.send(new PutObjectCommand({
  Bucket: "my-app-uploads",
  Key: `users/${userId}/report.pdf`,
  Body: bytes,
  ContentType: "application/pdf",
}));

// After — Waldrop
import { WaldropClient } from "@waldrop/sdk";

const waldrop = new WaldropClient({ network: "testnet" });
const { blobId } = await waldrop.blob.upload({
  data: bytes,
  fileName: "report.pdf",
  contentType: "application/pdf",
  epochs: 26,
  senderAddress, subscriptionId, signer,
});
// store `blobId` against userId in your DB — it's the new "key"

// Before — S3
const r = await s3.send(new GetObjectCommand({
  Bucket: "my-app-uploads",
  Key: `users/${userId}/report.pdf`,
}));
const bytes = await r.Body!.transformToByteArray();

// After — Waldrop (look up blobId from your DB by userId, then:)
const { bytes } = await waldrop.blob.fetch({ blobId });

// Before — S3
const objects = await s3.send(new ListObjectsV2Command({
  Bucket: "my-app-uploads",
  Prefix: `users/${userId}/`,
}));

// After — Waldrop (one BlobStore per user)
const blobs = await waldrop.blob.list({ owner: userAddress });
// blobs is BlobRef[] — already typed, no need to parse keys

// Before — S3 pre-signed URL
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
const url = await getSignedUrl(
  s3,
  new GetObjectCommand({ Bucket, Key }),
  { expiresIn: 3600 },
);

// After — Waldrop SEAL + per-blob share
const { blobId, sealMarker } = await waldrop.blob.upload({
  // … usual upload args
  encrypted: true,
  blobStoreId,
  initialShareViewers: [recipientAddress],
});
// `recipientAddress` can fetch + decrypt; nobody else can.

import { S3Client, ListObjectsV2Command, GetObjectCommand } from "@aws-sdk/client-s3";
import { readFileSync, writeFileSync, existsSync, appendFileSync } from "node:fs";
import { waldrop, senderAddress, signer } from "../src/lib/waldrop";   // see Node integration

const BUCKET = "my-app-uploads";
const STATE = "migrated.json";          // map: s3-key → blobId
const s3 = new S3Client({ region: "us-east-1" });
const migrated: Record<string, string> = existsSync(STATE)
  ? JSON.parse(readFileSync(STATE, "utf8"))
  : {};

async function* listAllKeys() {
  let token: string | undefined = undefined;
  do {
    const r = await s3.send(new ListObjectsV2Command({
      Bucket: BUCKET, ContinuationToken: token,
    }));
    for (const obj of r.Contents ?? []) yield obj.Key!;
    token = r.NextContinuationToken;
  } while (token);
}

for await (const key of listAllKeys()) {
  if (migrated[key]) {
    console.log(`skip ${key} → ${migrated[key]}`);
    continue;
  }

  const obj = await s3.send(new GetObjectCommand({ Bucket: BUCKET, Key: key }));
  const bytes = new Uint8Array(await obj.Body!.transformToByteArray());

  const r = await waldrop.blob.upload({
    data: bytes,
    fileName: key.split("/").pop()!,
    contentType: obj.ContentType ?? "application/octet-stream",
    epochs: 26,
    senderAddress,
    subscriptionId: process.env.WALDROP_SUBSCRIPTION_ID!,
    signer,
    onProgress: (e) => process.stdout.write(`\r${key} [${e.stage}] ${e.percent}%   `),
  });

  console.log(`\n✓ ${key} → ${r.blobId}`);
  migrated[key] = r.blobId;
  writeFileSync(STATE, JSON.stringify(migrated, null, 2));
}

console.log(`\nMigrated ${Object.keys(migrated).length} objects.`);