Arweave JS

Transactions are the building blocks of the Arweave permaweb. You can create data transactions (to store data) or wallet-to-wallet transactions (to transfer AR).

Workflow:

1. Call createTransaction to get an unsigned transaction object.
2. (Optional) Add metadata using addTag.
3. Call transactions.sign to sign the transaction with a key.
4. Call transactions.submit or use an uploader to send it to the network.

Important:

• Modifying a transaction object after signing it will invalidate the signature.
• If no key is passed to createTransaction, Arweave.js will attempt to use a browser-based wallet extension (like ArConnect).
• For large data uploads, use ArBundles instead of standard transactions.

let key = await arweave.wallets.generate();

// Create a data transaction
let transaction = await arweave.createTransaction({
    data: 'Hello World'
}, key);

// Add metadata tags
transaction.addTag('Content-Type', 'text/plain');

// Sign the transaction
await arweave.transactions.sign(transaction, key);

// Submit the transaction
const response = await arweave.transactions.post(transaction);

Arweave.js provides utilities to generate new wallets, derive addresses from private keys, and check wallet balances.

Security Warning: Private keys (JWK format) must be stored securely. Anyone with the key can spend the funds in the wallet. They can never be recovered if lost.

// Generate a new wallet and private key
arweave.wallets.generate().then((key) => {
    console.log(key);
});

// Get the wallet address for a private key
arweave.wallets.jwkToAddress(key).then((address) => {
    console.log(address);
});

// Get an address balance (returns value in winston)
arweave.wallets.getBalance('ADDRESS').then((balance) => {
    let winston = balance;
    let ar = arweave.ar.winstonToAr(balance);
    console.log(winston, ar);
});

// Get the last transaction ID from a wallet
arweave.wallets.getLastTransactionID('ADDRESS').then((transactionId) => {
    console.log(transactionId);
});

For large files, use the getUploader method to perform chunked uploading. This allows for progress updates and the ability to resume interrupted uploads.

Resuming an upload:

• From a saved uploader: You can persist an uploader object using JSON.stringify(uploader) and resume it later by passing the parsed object and the original data to getUploader().
• From a transaction ID: If an upload was interrupted and you didn't save the uploader, you can resume using the transaction ID and the original data (this will restart the upload from the beginning).
• Async Iterator: You can also use the arweave.transactions.upload(tx) async iterator for a cleaner syntax.

// Using the Uploader pattern
let data = fs.readFileSync('path/to/file.pdf');
let transaction = await arweave.createTransaction({ data: data }, key);
transaction.addTag('Content-Type', 'application/pdf');
await arweave.transactions.sign(transaction, key);

let uploader = await arweave.transactions.getUploader(transaction);
while (!uploader.isComplete) {
  await uploader.uploadChunk();
  console.log(`${uploader.pctComplete}% complete`);
}

// Using the Async Iterator pattern
for await (const uploader of arweave.transactions.upload(transaction)) {
  console.log(`${uploader.pctComplete}% Complete`);
}