# Store a string for 1 storage epoch
curl -X PUT "https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs" \
  -d "some string"

# Store a file for 5 storage epochs
curl -X PUT "https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs?epochs=5" \
  --upload-file "some/file"

# Store a file and send the blob object to a specific address
curl -X PUT "https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs?send_object_to=${ADDRESS}" \
  --upload-file "some/file"

# Store a file as a deletable blob
curl -X PUT "https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs?deletable=true" \
  --upload-file "some/file"

import requests

# Set your endpoint key
endpoint_key = "your_endpoint_key"
publisher_url = f"https://walrus-mainnet-publisher.nami.cloud/{endpoint_key}/v1/blobs"

# Store a string
response = requests.put(publisher_url, data="some string")
print(response.json())

# Store a file for 5 epochs
with open("some/file", "rb") as file:
    response = requests.put(f"{publisher_url}?epochs=5", data=file)
    print(response.json())

// Store a string
fetch(`https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs`, {
  method: 'PUT',
  body: 'some string'
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

// Store a file for 5 epochs
const fs = require('fs');
const fileData = fs.readFileSync('some/file');
fetch(`https://walrus-mainnet-publisher.nami.cloud/${endpoint_key}/v1/blobs?epochs=5`, {
  method: 'PUT',
  body: fileData
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/namihq/walrus-go"
)

func main() {
	// Create a new client with default endpoints
	client := walrus.NewClient()

	// Or specify custom endpoints
	// client := walrus.NewClient(
	//     walrus.WithPublisherURLs([]string{"https://walrus-mainnet-publisher.nami.cloud/your-endpoint-key"}),
	// )

	// Example 1: Store a byte array
	data := []byte("Hello, Walrus!")
	resp, err := client.Store(data, &walrus.StoreOptions{
		Epochs: 5, // Store for 5 epochs
	})
	if err != nil {
		log.Fatalf("Error storing data: %v", err)
	}
	
	// The blobId can be used to retrieve the data later
	if resp.NewlyCreated != nil {
		fmt.Printf("Stored new blob with ID: %s\n", resp.NewlyCreated.BlobObject.BlobId)
		fmt.Printf("Storage cost: %d\n", resp.NewlyCreated.Cost)
	} else if resp.AlreadyCertified != nil {
		fmt.Printf("Blob already exists with ID: %s\n", resp.AlreadyCertified.BlobId)
		fmt.Printf("Valid until epoch: %d\n", resp.AlreadyCertified.EndEpoch)
	}

	// Example 2: Store a file
	filePath := "example.txt"
	fileResp, err := client.StoreFile(filePath, &walrus.StoreOptions{
		Epochs: 10, // Store for 10 epochs
	})
	if err != nil {
		log.Fatalf("Error storing file: %v", err)
	}
	
	if fileResp.NewlyCreated != nil {
		fmt.Printf("Stored file with blob ID: %s\n", fileResp.NewlyCreated.BlobObject.BlobId)
	}
	
	// Example 3: Store from URL
	urlResp, err := client.StoreFromURL("https://example.com/sample.jpg", &walrus.StoreOptions{
		Epochs: 3,
	})
	if err != nil {
		log.Fatalf("Error storing from URL: %v", err)
	}
	
	if urlResp.NewlyCreated != nil {
		fmt.Printf("Stored URL content with blob ID: %s\n", urlResp.NewlyCreated.BlobObject.BlobId)
	}
	
	// Example 4: Store with encryption
	encryptedResp, err := client.Store([]byte("Secret data"), &walrus.StoreOptions{
		Epochs: 5,
		Encryption: &walrus.EncryptionOptions{
			Key: []byte("a-32-byte-key-for-aes-256-encryption"), // 32 bytes for AES-256
		},
	})
	if err != nil {
		log.Fatalf("Error storing encrypted data: %v", err)
	}
	
	if encryptedResp.NewlyCreated != nil {
		fmt.Printf("Stored encrypted data with blob ID: %s\n", encryptedResp.NewlyCreated.BlobObject.BlobId)
	}
}