DEV Community: Robert

How to use libvmaf_cuda on Windows: an easy-to-follow guide (WSL2 + Docker + NVIDIA)

Robert — Wed, 16 Sep 2026 19:21:17 +0000

TL;DR: Running GPU-accelerated VMAF on Windows is surprisingly painful. After spending hours fighting broken builds and undocumented errors, the only reliable path I found is WSL2 + Docker Desktop + NVIDIA Container Toolkit + a CUDA-enabled FFmpeg. This guide walks you through the whole setup using the easyVmaf project, so you can skip the trial-and-error I went through.

This guide uses easyVmaf, a project that ships a Dockerfile.cuda specifically built for this purpose. We'll run it inside WSL2, with Docker Desktop and the NVIDIA Container Toolkit handling the GPU passthrough.

The result: VMAF running at ~15x real-time speed on an RTX 3060 Mobile. A 46-minute video gets analyzed in about 3 minutes. On CPU, the same task would take like an hour.

⚠️ AMD and Intel GPUs will not work with this guide. libvmaf_cuda is NVIDIA-exclusive.

The Problem
Prerequisites
Part 1 — Setting up the environment
- 1.1 Install WSL2
- 1.2 Accessing Windows drives from WSL
- 1.3 Verify GPU access from WSL
- 1.4 Install Docker Desktop
- 1.5 Install the NVIDIA Container Toolkit
Part 2 — Building the easyVmaf image
- 2.1 Clone the repository
- 2.2 Critical fix: pin nv-codec-headers
- 2.3 Build the image
- 2.4 Verify the libvmaf_cuda filter
Part 3 — Running VMAF with GPU acceleration
- 3.1 capabilities=video
- 3.2 Full analysis command
Troubleshooting
Conclusion
References
Let's Connect

The Problem

If you've ever tried to calculate VMAF on Windows, you already know that:

The standard libvmaf filter works, but it runs on the CPU (slow).
libvmaf_cuda does not exist in any prebuilt Windows binary (not in gyan.dev, not in BtbN, not anywhere that I know).
Most information online is scattered, outdated, or simply missing.

Prerequisites

Before starting, make sure you have:

Component	Minimum requirement
Windows	Windows 10 (version 2004+) or Windows 11
NVIDIA GPU	Any CUDA-capable GPU (I'm using an RTX 3060 Mobile)
NVIDIA drivers	Version 525+ (for CUDA 12.x) — download here
Disk space	~30 GB free (WSL + Docker + images)
RAM	16 GB recommended (WSL2 is memory-hungry)

⚠️ Do not install NVIDIA drivers inside WSL. WSL automatically uses the drivers from Windows. Installing Linux drivers inside WSL will break GPU passthrough.

Part 1 — Setting up the environment

This part covers everything needed to get a working Linux + Docker + GPU stack: WSL2, Docker Desktop, and the NVIDIA Container Toolkit.

1.1 Install WSL2

Open PowerShell as Administrator and run

wsl --install

This command will:

download and install WSL2 kernel
install Ubuntu distro by default

Restart Windows when prompted.

After the restart, open PowerShell again and verify:

wsl --list --verbose

Expected output:

  NAME      STATE           VERSION
* Ubuntu    Running         2

Make sure VERSION is 2. If it says 1, upgrade with:

wsl --set-version Ubuntu 2
wsl --set-default-version 2

Ubuntu update

Open your Ubuntu terminal either by typing in PowerShell

ubuntu

wsl

Once in Ubuntu terminal enter:

sudo apt update && sudo apt upgrade -y

1.2 Accessing Windows drives from WSL

If you're new to Linux, one of the first things to understand is that WSL doesn't use C:\, D:\, etc. Instead, it mounts every Windows drive under /mnt/.

Windows path	WSL path
`C:\Users\YourName\Videos`	`/mnt/c/Users/YourName/Videos`
`D:\Movies`	`/mnt/d/Movies`
`E:\Backups\2026`	`/mnt/e/Backups/2026`

1.3 Verify GPU access from WSL

if you already have installed NVIDIA drivers on Windows, run:

nvidia-smi

You should see the nvidia-smi table with your GPU listed. If it doesn't work, your Windows drivers are outdated or WSL isn't configured properly.

Wed Sep 16 09:30:35 2026
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 615.71.08              KMD Version: 616.92        CUDA UMD Version: 13.4     |
+-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 3060 ...    On  |   00000000:01:00.0  On |                  N/A |
| N/A   55C    P8             14W /  115W |    1085MiB /   6144MiB |      6%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+

1.4 Install Docker Desktop

Download Docker Desktop from: https://www.docker.com/products/docker-desktop/

During installation, make sure to check "Use WSL 2 instead of Hyper-V".

Configure WSL2 integration

Once installed, open Docker Desktop and go to Settings

General tab:

Check Use the WSL 2 based engine
Click Apply & Restart

Resources → WSL Integration:

Check Enable integration with my default WSL distro
Turn on the Ubuntu toggle

Resources → Advanced (optional):

Uncheck "Enable Resource Saver"

If "Resource Saver" is enabled, Docker will suspend WSL2 after inactivity, and you'll have to restart it manually.

Verify Docker works in WSL

In your Ubuntu terminal:

docker --version

Expected output:

Docker version 27.3.1, build ce12230

⚠️ If you get var/run/docker.sock: connect: permission denied. jump to the Troubleshooting section.

1.5 Install the NVIDIA Container Toolkit

This is the component that allows Docker containers to access the GPU.

Install

In your WSL Ubuntu terminal:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg && \
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit

Configure the Docker runtime

sudo nvidia-ctk runtime configure --runtime=docker

Expected output:

INFO[0000] Config file does not exist; using empty config
INFO[0000] Wrote updated config to /etc/docker/daemon.json
INFO[0000] It is recommended that docker daemon be restarted.

Restart Docker

Restart Docker Desktop from Windows (either via the restart icon or by quitting and reopening it).

Verify Docker can see the GPU

Once Docker Desktop is running again, execute in your WSL terminal:

docker run --rm --gpus all nvidia/cuda:12.3.2-base-ubuntu22.04 nvidia-smi

You should see the nvidia-smi table with your GPU listed.

+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 615.71.08              KMD Version: 616.92        CUDA UMD Version: 13.4     |
+-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 3060 ...    On  |   00000000:01:00.0  On |                  N/A |
| N/A   55C    P8             14W /  115W |    1085MiB /   6144MiB |      6%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+

Part 2 — Building the easyVmaf image

We'll use the easyVmaf project, which ships a Dockerfile.cuda configured for GPU-accelerated VMAF.

2.1 Clone the repository

cd ~
git clone --depth 1 https://github.com/gdavila/easyVmaf.git
cd easyVmaf

2.2 Critical fix: pin nv-codec-headers

💡 This step is undocumented anywhere else. I figured it out after spending hours debugging the compilation error with the help of AI. Skip it and your build will fail.

The original Dockerfile.cuda clones the latest version of nv-codec-headers, which is incompatible with FFmpeg 8.1. You'll get this error during the build:

libavcodec/nvenc.c:2529:42: error: 'NV_ENC_CLOCK_TIMESTAMP_SET' 
has no member named 'countingType'; did you mean 'countingTypeLSB'?

In recent versions, NVIDIA renamed countingType to countingTypeLSB/countingTypeMSB, but FFmpeg 8.1 still uses countingType.

The fix: Pin nv-codec-headers to version n12.1.14.0, which still uses countingType and already includes the modern CUDA functions (cuStreamCreateWithPriority, cuMemHostAlloc, etc.) that libvmaf_cuda needs.

Edit the Dockerfile:

nano Dockerfile.cuda

Press CTRL+W, type nv-codec-headers, press ENTER. You'll land on this line:

RUN git clone --depth 1 https://git.videolan.org/git/ffmpeg/nv-codec-headers.git && \
    cd nv-codec-headers && \
    make install

Change it by adding n12.1.14.0 before --depth:

RUN git clone --branch n12.1.14.0 --depth 1 https://git.videolan.org/git/ffmpeg/nv-codec-headers.git && \
    cd nv-codec-headers && \
    make install

Save with CTRL+X, then Y, then ENTER.

2.3 Build the image

docker build -f Dockerfile.cuda -t easyvmaf:cuda .

2.4 Verify the `libvmaf_cuda` filter

⚠️ The easyvmaf:cuda image defines easyVmaf (its own CLI) as the ENTRYPOINT. To run raw ffmpeg, you must override the entrypoint.

docker run --rm --gpus all --entrypoint ffmpeg easyvmaf:cuda -filters | grep -E "libvmaf|scale_cuda"

Expected output:

.. libvmaf           VV->V      Calculate the VMAF between two video streams.
.. libvmaf_cuda      VV->V      Calculate the VMAF between two video streams.
.. scale_cuda        V->V       GPU accelerated video resizer

If you see libvmaf_cuda, you're done with the setup.

Part 3 — Running VMAF with GPU acceleration

3.1 capabilities=video

By default, --gpus all alone only grants the compute and utility capabilities. It does not mount the video decode/encode libraries libnvcuvid.so.1 (NVDEC) and libnvidia-encode.so.1 (NVENC). Since we tell FFmpeg to decode with -hwaccel cuda, it needs those libraries. Without them, FFmpeg fails with:

Cannot load libnvcuvid.so.1
Failed loading nvcuvid.
Failed setup for format cuda: hwaccel initialisation returned error.

The fix: explicitly request the video capability:

--gpus all,capabilities=video

Now Docker mounts libcuda.so.1 (CUDA compute), libnvcuvid.so.1 (NVDEC), and libnvidia-encode.so.1 (NVENC). FFmpeg can then decode, filter, and analyze entirely on the GPU.

3.2 Full analysis command

docker run --gpus all,capabilities=video --rm --entrypoint ffmpeg \
  -v "/path/to/your/videos":/videos \
  easyvmaf:cuda \
  -hwaccel cuda -hwaccel_output_format cuda \
  -i "/videos/distorted.mkv" \
  -hwaccel cuda -hwaccel_output_format cuda \
  -i "/videos/reference.mkv" \
  -filter_complex "[0:v]scale_cuda=format=yuv420p[dis];[1:v]scale_cuda=format=yuv420p[ref];[dis][ref]libvmaf_cuda=log_fmt=json:log_path=/videos/vmaf_full.json" \
  -f null -

Real-world result

Here's the output from a test on a 46-minute video file:

[Parsed_libvmaf_cuda_2 @ 0x760b44004f80] VMAF score: 93.558906
speed=14.9x elapsed=0:03:05.05
[out#0/null @ 0x5ef225e22140] video:27438KiB audio:2072848KiB subtitle:0KiB
frame=66265 fps=350 q=-0.0 Lsize=N/A time=00:46:03.79 bitrate=N/A speed=14.6x elapsed=0:03:09.43

3 minutes for a 46-minute video at ~15x real-time speed. That's the whole point of using libvmaf_cuda.

Troubleshooting

`var/run/docker.sock: connect: permission denied`

docker: permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Head "http://%2Fvar%2Frun%2Fdocker.sock/_ping": dial unix /var/run/docker.sock: connect: permission denied.

Your user doesn't belong to the docker group, which owns /var/run/docker.sock.

fix:

enter this command in your WSL Ubuntu terminal

sudo usermod -aG docker $USER

This adds your user to the docker group. Then close and reopen WSL (group changes only apply to new sessions), and verify:

groups

Expected output:

youruser adm cdrom sudo dip plugdev users docker

`Cannot load libnvcuvid.so.1`

Missing ,capabilities=video in the --gpus flag. See section 3.1.

`NV_ENC_CLOCK_TIMESTAMP_SET has no member named 'countingType'`

You didn't pin nv-codec-headers to n12.1.14.0. See section 2.2.

WSL2 hangs after inactivity

Edit C:\Users\YOUR_USER\.wslconfig:

[wsl2]
vmIdleTimeout=-1

Then run wsl --shutdown in PowerShell. Also disable "Resource Saver" in Docker Desktop (see section 1.3).

Conclusion

Setting up libvmaf_cuda on Windows was a long journey. At the start, I couldn't find much information about it — most guides either stop at "use libvmaf on CPU" or assume you're on Linux. Even though this isn't 100% native to Windows (it runs through WSL2 + Docker), it's a solid alternative that is absolutely worth the effort.

Once it's working, you get VMAF analysis at 15x real-time speed, which completely changes what's practical for video quality workflows.

References

easyVmaf — the project powering this guide
NVIDIA Container Toolkit docs
WSL2 GPU support
Netflix VMAF

Let's Connect

If you found this post useful and you're looking for a Full Stack Developer or a technical writer, feel free to reach out!

GitHub
Telegram: @rtaglia

Thanks for reading! 🙌

How I Fixed My HLS Seeking Lag with One Keyframe Trick (GOP explained)

Robert — Wed, 09 Sep 2026 19:14:34 +0000

Introduction

I’ve been building a self‑hosted HLS streaming system from scratch – Node.js + TypeScript on the backend, React and hls.js on the frontend, and FFmpeg doing the heavy lifting. Adaptive bitrate, multiple qualities, audio tracks, subtitles, the whole thing.

Everything worked perfectly until I clicked anywhere on the progress bar.

The audio resumed instantly. But the video? It took 5 to 7 seconds to catch up.

After a deep dive, I discovered a concept I should have understood from day one: GOP (Group of Pictures).

The Problem

My HLS segments were 2 seconds long. But I hadn’t set the GOP size explicitly in my FFmpeg command. FFmpeg’s default GOP is usually 250 frames (around 10 seconds for 25 fps). This meant that keyframes were far apart, and most segments didn’t start with one.

When you click on the progress bar, the player requests a new segment at that timestamp. If that segment doesn’t begin with a keyframe, the player cannot decode it immediately. It has to wait for the next keyframe inside that segment – which could be several seconds away.

The audio is independent, so it plays right away. The video waits.

What is GOP?

GOP = Group of Pictures. It’s the distance between two keyframes (I‑frames) in a video stream.

A GOP contains three types of frames:

Frame	What it is?
I‑frame (Intra)	Complete, standalone image
P‑frame (Predictive)	Only changes from previous frame
B‑frame (Bi‑directional)	Changes from both past and future frames

The smaller the GOP, the more I‑frames you have. More I‑frames = larger file size, but better seeking and faster quality switches.

How GOP affects HLS streaming?

In HLS, segments are independent files. For a segment to be playable from scratch, it must start with an I‑frame.

If your GOP is larger than your segment duration:

Segments often start with a P‑frame or B‑frame.
The player must wait until the next I‑frame within that segment.
This introduces seeking delay in adaptive bitrate streaming.

The Fix

I changed two settings in my FFmpeg pipeline:

Set GOP size = 2 seconds (matching my segment duration)
Forced keyframes at segment boundaries (using -force_key_frames)

This ensures that every segment starts with an I‑frame.

ffmpeg -i input.mp4 \
  -g 48 \     # 48 frames at 24 fps = 2 seconds
  -force_key_frames "expr:gte(t,n_forced*2)" \
  -hls_time 2 \
  -hls_segment_type fmp4 \
  -hls_flags independent_segments+program_date_time \
  output.m3u8

After those changes:

Seeking is now instant and smooth
Quality changes in adaptive bitrate are fluid (no more stutter)

What I learned

In HLS, the relationship between segment duration and GOP size is critical.
Always align your GOP with your segment duration for VOD content.

Conclusion

Building a streaming system from scratch is a fantastic way of learning video fundamentals. If you’re working with HLS, take a moment to check your GOP settings – it could save you hours of debugging later.

Have you ever struggled with seeking or adaptive bitrate switching? I’d like to hear(read) your experience

Github Repo

Construyendo un audio track remover con Node.js, React y FFmpeg

Robert — Wed, 02 Sep 2026 19:54:43 +0000

No he escrito en dev.to desde el 2022. Ha habido muchos cambios en estos 4 años. Nuevos empleos, nuevos proyectos, nuevas tecnologías, etc. He regresado con un proyecto que me ha causado mucho interes

Tabla de Contenido

Introducción
El Problema
Tecnologías
Retos y Soluciones
Conclusión
Contacto

Introducción

¿Alguna vez has querido eliminar una o varias pistas de audio de un video?

Quizas tienes una pelicula o el episodio de alguna serie con mas de un audio pero quieres conservarlo solo con la pista de audio que te interesa. O tambien esta la posibilidad de que quisieras dejarlo sin pistas de audio para poder editarlo o por motivos de accesibilidad

para esa cuestión ejecutaba un comando como este:

ffmpeg -i test-video.1080p-Dual.mkv -map 0:v -map 0:a:1 -c copy D:test-video.es.mkv

¿Qué hace el comando?

Parte	Explicación
`ffmpeg`	El programa que ejecuta el comando
`-i test-video.1080p-Dual.mkv`	Archivo de entrada (el video original)
`-map 0:v`	Selecciona todas las pistas de video del archivo 0
`-map 0:a:1`	Selecciona la pista de audio número 1 del archivo 0 (en este caso, español)
`-c copy`	Copia los codecs (sin re-codificar)
`D:test-video.es.mkv`	Archivo de salida (el video procesado)

El Problema

Los archivos de video suelen contener múltiples pistas de audio:

Diferentes idiomas (inglés, español, francés, etc.)
Pistas de comentarios
Descripciones de audio para accesibilidad
Múltiples formatos o bitrates

La mayoría de los editores de video son excesivos para esta tarea. Quería una herramienta ligera, rápida y gratuita que:

Funcione localmente (sin subir archivos a la nube)
Procese varios videos a la vez
Muestre el progreso en tiempo real
Recuerde las selecciones de pistas por video
Tenga una interfaz limpia y fácil de usar

Tecnologías

Capa (Layer)	Tecnología
Frontend	React, TypeScript, Vite
Backend	Node.js, Express, TypeScript
Procesamiento de Video	FFmpeg (fluent-ffmpeg)
Actualizaciones en Tiempo Real	Server-Sent Events (SSE)
Colas	Cola de procesamiento en memoria
Tests	Vitest

Retos y Soluciones

1. Procesar videos sin subirlos

Como esta es una herramienta local, no quería subir archivos a un servidor. El backend lee los videos directamente del sistema de archivos usando la ruta configurada en .env.

// config.ts
const getVideoFolder = (): string => {
    const envPath = process.env.VIDEO_FOLDER_PATH;
    return envPath ? path.resolve(envPath) : path.join(__dirname, '../videos');
};

¿Por qué importa? La herramienta es 100% local. No hay subidas, no hay límites de tamaño, no hay dependencia de internet y tus archivos nunca salen de tu computadora.

2. Progreso en tiempo real con SSE

FFmpeg emite eventos de progreso, pero necesitaba transmitirlos al frontend. Elegí Server-Sent Events en lugar de WebSockets porque es más simple para comunicación unidireccional.

// Backend - emitiendo eventos de progreso
command.on('progress', (progress) => {
    const percent = Math.round(progress.percent || 0);
    this.emit('job-progress', item, percent);
});

// Frontend - escuchando eventos
const eventSource = new EventSource(`/api/events?jobId=${jobId}`);
eventSource.onmessage = (event) => {
    const data = JSON.parse(event.data);
    setProcessProgress(data.progress);
};

¿Por qué SSE? Está integrado en los navegadores, maneja reconexiones automáticamente y es perfecto para actualizaciones servidor-cliente.

3. Persistencia de selección de pistas por video

Necesitaba recordar qué pistas seleccionó el usuario para cada video. Usé un Map en el estado del frontend:

const [selectedTracksMap, setSelectedTracksMap] = useState<Map<string, number[]>>(new Map());

Al cambiar entre videos, las pistas seleccionadas/deseleccionadas se mantienen.

4. Procesamiento por lotes con cola

Procesar varios videos simultáneamente saturaría el sistema. Por lo que implementé una cola simple en memoria

5. Manejo de videos sin pistas de audio

Quise colocar la opción de poder eliminar todas las pistas de audio solo para probar. El backend soporta tracksToKeep: [] usando el flag -an de FFmpeg.

Conclusión

Este proyecto empezo como una solucion personal a un problema, ejecutar manualmente comandos para eliminar pistas de audio o tener que crear scripts para lotes de videos era muy repetitivo. Este proyecto termino siendo un ejercicio practico para construir una aplicacion local.

Lo que hace este proyecto interesante:

Integracion con FFmpeg – Trabajar con una herramienta CLI desde Node.js me enseñó a como manejar subprocesos, analiza la salida, y streamear eventos de progreso.
comunicación en tiempo real – Los eventos Server-sent demostraron ser una simple pero efectiva alternativa a websockets, es el segundo proyecto donde hago uso de esa herramienta.
Architectura – Separar el frontend en componentes y custom hooks, y el backend en controladores y servicios hace que el codigo sea mantenible y escalable.
Local-first – Desde mi punto de vista tiene mucho valor haber construido una herramienta útil como esta que se ejecuta completamente en la máquina del usuario sin depender de la nube.

El proyecto es de código abierto. Siéntete libre de usarlo, modificarlo, o aprender de el.

GitHub Repository

Video Demo

Contacto

Si te ha parecido interesante este proyecto y estás buscando un desarrollador Full Stack, no dudes en contactarme.

GitHub: github.com/rtagliaviaz
Telegram: @rtagliajs
Discord: appulino
Email: rtagliavia.pp@gmail.com

¡Gracias por leer! 🙌

I haven't posted in 4 years. Here's what I built: A Local Audio Track Remover with React, Node.js, and FFmpeg

Robert — Wed, 02 Sep 2026 19:44:48 +0000

I haven't written on Dev.to since 2022. A lot has changed in 4 years — new jobs, new projects, and new tech. I'm back with a project I'm genuinely excited about.

Introduction
The Problem
Tech Stack
Key Challenges & Solutions
Conclusion
Let's Connect

Introduction

Have you ever wanted to remove one or more audio tracks from a video?

Maybe you have a movie or a TV series episode with multiple audio tracks, but you only want to keep the one you need. Or perhaps you want to remove all audio tracks for editing purposes or accessibility reasons.

To solve this, I used to run a command like this:

ffmpeg -i test-video.1080p-Dual.mkv -map 0:v -map 0:a:1 -c copy D:test-video.es.mkv

What does this command do?

Part	Explanation
`ffmpeg`	The program that executes the command
`-i test-video.1080p-Dual.mkv`	Input file (the original video)
`-map 0:v`	Selects all video tracks from file 0
`-map 0:a:1`	Selects audio track number 1 from file 0 (in this case, Spanish)
`-c copy`	Copies the codecs (no re-encoding)
`D:test-video.es.mkv`	Output file (the processed video)

It worked, but every time I had to remember the syntax, check which track was which, and wait without knowing the progress. It was tedious and error-prone.

So I built a tool that does the same thing, but with a clean UI, real-time progress, and batch processing.

The Problem

Video files often contain multiple audio tracks:

Different languages (English, Spanish, French, etc.)
Commentary tracks
Audio descriptions for accessibility
Multiple formats or bitrates

Most video editors are overkill for this task. I wanted a lightweight, fast, and free tool that:

Works locally (no uploads to the cloud)
Processes multiple videos at once
Shows real-time progress
Remembers track selections per video
Has a clean and easy-to-use interface

Tech Stack

Layer	Tech
Frontend	React, TypeScript, Vite
Backend	Node.js, Express, TypeScript
Video Processing	FFmpeg (fluent-ffmpeg)
Real-time Updates	Server-Sent Events (SSE)
Queue	In-memory processing queue
Testing	Vitest

Key Challenges & Solutions

1. Processing Videos Without Uploading

Since this is a local tool, I didn't want to upload files to a server. The backend reads videos directly from the filesystem using the path configured in .env.

// config.ts
const getVideoFolder = (): string => {
    const envPath = process.env.VIDEO_FOLDER_PATH;
    return envPath ? path.resolve(envPath) : path.join(__dirname, '../videos');
};

Why does this matter? The tool is 100% local. There are no uploads, no file size limits, no internet dependency, and your files never leave your computer.

2. Real-time Progress with SSE

FFmpeg emits progress events, but I needed to stream them to the frontend. I chose Server-Sent Events over WebSockets because it's simpler for one-way communication.

// Backend - emitting progress events
command.on('progress', (progress) => {
    const percent = Math.round(progress.percent || 0);
    this.emit('job-progress', item, percent);
});

// Frontend - listening for events
const eventSource = new EventSource(`/api/events?jobId=${jobId}`);
eventSource.onmessage = (event) => {
    const data = JSON.parse(event.data);
    setProcessProgress(data.progress);
};

Why SSE? It's built into browsers, handles reconnections automatically, and is perfect for server-to-client updates.

3. Each video remembers its own track choices

I needed to remember which tracks the user selected for each video. I used a Map in the frontend state:

const [selectedTracksMap, setSelectedTracksMap] = useState<Map<string, number[]>>(new Map());

When you switch between videos, the selected/deselected tracks are preserved.

4. Batch Processing with a Queue

Processing multiple videos simultaneously would overwhelm the system. So I implemented a simple in-memory queue.

5. Handling Videos with No Audio Tracks

I wanted to add the option to remove all audio tracks just to try it out. The backend supports tracksToKeep: [] using FFmpeg's -an flag.

Conclusion

This project started as a personal solution to a problem: manually running commands to remove audio tracks or having to create scripts for video batches was very repetitive. This project ended up being a practical exercise in building a local application.

What makes this project interesting:

FFmpeg integration – Working with a powerful CLI tool from Node.js taught me how to handle subprocesses, parse output, and stream progress events.
Real-time communication – Server-Sent Events proved to be a simple yet effective alternative to WebSockets for pushing progress updates to the client.
Architecture – Separating the frontend into components and custom hooks, and the backend into controllers and services, kept the codebase maintainable as the project grew.
Local-first – Building a tool that runs entirely on the user's machine without cloud dependencies has real value for privacy and speed.

The project is open source. Feel free to use it, modify it, or learn from it.

GitHub Repository

Video Demo

Let's Connect

If you found this project interesting and are looking for a Full Stack Developer, feel free to reach out!

GitHub: github.com/rtagliaviaz
Telegram: @rtaglia
Discord: appulino
Email: rtagliavia.pp@gmail.com

Thanks for reading! 🙌

¿Cómo mintear NFTs en Solana?

Robert — Mon, 19 Sep 2022 13:59:05 +0000

En el siguiente post explicaré paso a paso a como "mintear" un NFT en Solana.

Para seguir este post no es necesario utilizar el CLI de Metaplex, en caso de contar con una alternativa, te agradeceria mucho que me la comentaras

Prerrequisitos

El equipo de Metaplex ha dejado de actualizar el CLI, pero sigue funcionando y no tendrás ningún problema para seguir este post. Planeo incluir otra opción si puedo encontrarla más adelante

Metaplex CLI

Para instalar Metaplex CLI debemos hacer lo siguiente:

Dirigirnos al siguiente link
Clonar el proyecto con $ git clone https://github.com/metaplex-foundation/deprecated-clis.git
Ubicarnos en la carpeta del proyecto e instalar las dependencias

Tabla de Contenido

Creación de cartera local
Agregar saldo a nuestra cartera
Subir la imagen que usaremos como NFT
Crear y Subir la metadata de nuestro NFT
Mintear el Token
Agregar nuestra cartera local a Phantom
Quemar NFTs en Phantom
Conclusion

1. Creación de cartera local

Asumiendo que ya instalaste Solana CLI, lo primero que debemos hacer es apuntar a la mainnet con el siguiente comando:

$ solana config set --url https://api.mainnet-beta.solana.com

Obtendremos un mensaje similar al siguiente:

Config File: C:\Users\Rob\.config\solana\cli\config.yml
RPC URL: https://api.mainnet-beta.solana.com
WebSocket URL: wss://api.mainnet-beta.solana.com/ (computed)

Una vez hecho esto procederemos a crear la cartera local con el siguiente comando:

$ solana-keygen new --outfile ~/.solana/tu-cartera.json

A continuación nos pedirá que ingresemos una frase de acceso (passphrase) que usaremos para recuperar la cartera.

For added security, enter a BIP39 passphrase

NOTE! This passphrase improves security of the recovery seed phrase NOT the
keypair file itself, which is stored as insecure plain text

BIP39 Passphrase (empty for none):

Una vez ingresada obtendremos el siguiente mensaje:

Wrote new keypair to /Users/Rob/.config/solana/[wallet_name].json ==================================================================== pubkey: [wallet_pub_key] ==================================================================== Save this seed phrase and your BIP39 passphrase to recover your new keypair:
[REDACTED] ====================================================================

La pubkey sera nuestra wallet address

Ahora procederemos a asignarla como nuestra cartera predeterminada con el siguiente comando:

$ solana config set --keypair ~/.solana/tu-cartera.json

2. Agregar saldo a nuestra cartera

Para poder realizar todo el proceso necesitaremos menos de 2 USD en SOL

En caso de tener una cartera con SOL en Phantom podemos simplemente enviar SOL a la nueva cartera.

Caso contrario podemos adquirir SOL usando FTX siguiendo los siguientes pasos:

1. Crear una cuenta

2. Dirigirnos a la página de wallet

3. Depositar USD o EUR

En la página de Wallet nos ubicamos en la moneda (USD o EUR) que deseemos depositar y haremos click en DEPOSIT

Seguido de esto Seleccionaremos tarjeta de débito, seguiremos los pasos y confirmaremos el depósito

4. Convertir a SOL

Una vez realizado el paso anterior y que ya tengamos disponible el saldo en USD o EUR, podemos convertirlo a SOL haciendo click en CONVERT

Seguido de esto seleccionaremos la moneda a la que deseemos convertir, en este caso SOL

5. Pasaremos la cantidad que convertimos a SOL a nuestra cartera local

Ahora nos ubicamos en el icono de búsqueda y buscaremos SOL, y procederemos a hacer clic en retirar WITHDRAW, colocaremos el monto que deseemos retirar y la pubkey que es nuestra wallet address

Una vez hayamos pasado fondos a nuestra cartera local podemos chequearlos haciendo uso del siguiente comando:

$ solana balance pubkey

3. Subir la imagen que usaremos como NFT

Para este ejemplo usaremos el Logo de Code&Jobs, siéntete libre de usar o crear la imagen que desees

Subiremos la imagen haciendo uso de arloader CLI, pero en caso de que desees hacerlo manualmente puedes seguir las instrucciones en el siguiente post

Con el siguiente comando especificaremos la ruta de la imagen que vamos a subir, y que realizaremos el pago con nuestra cartera de Solana:

$ arloader upload <logo-de-codenjobs.png> --with-sol --sol-keypair-path ~/.config/solana/tu-cartera.json --ar-default-keypair --no-bundle

Vamos a obtener el siguiente mensaje por consola:

id:             [tx_id]
status:         Submitted
file_path:      [ruta/de/la/imagen.png]
created_at:     2022-08-21 15:43:13
last_modified:  2022-08-21 15:43:13
Uploaded 1 files. Run `arloader update-status  --file-paths ` to confirm transaction(s).

Asegurate de guardar el tx_id

Una vez hecho esto tendremos que esperar un poco para que el archivo esté disponible, podemos revisar el estado con el siguiente comando $ arloader get-status [tx_id] o con la siguiente URL https://arweave.net/tx_id (en caso de estar confirmada podremos obtener la imagen)

Mientras esperamos podemos avanzar con el siguiente paso

4. Crear y Subir la metadata de nuestro NFT

A continuación crearemos la metadata de nuestro NFT utilizando el estándar de METAPLEX. Para esto debemos abrir un editor de código y crear un archivo que llevará por nombre metadata.json, copiaremos lo siguiente dentro de ese archivo.

{
    "name": "NFT MINT TEST",
    "symbol": "ANYSYMBOL",
    "description": "TEST NFT",
    "seller_fee_basis_points": 1000,
    "image": "https://arweave.net/[tx_id]?ext=png",
    "external_url": "https://www.codenjobs.com/user/rtagliavia",
    "attributes":
    [
        {
            "trait_type": "Whatever Trait 1",
            "value": "Fire"
        },
        {
            "trait_type": "Whatever Trait 2",
            "value": "Sunglasses"
        }
    ],
    "properties":
    {
        "files":
        [
            {
                "uri": "https://arweave.net/[tx_id]?ext=png",
                "type": "image/png"
            }
        ],
        "category": "image",
        "creators":
        [
            {
                "address": "[pub_key]",
                "share": 100
            }
        ]
    }
}

En esta línea colocaremos el transaction ID que recibimos en el paso anterior, y la estension puede ser .jpg o .png

"image": "https://arweave.net/[tx_id]?ext=png",

Igualmente en la siguientes

"uri": "https://arweave.net/[arweave_img_tx_id]?ext=png",
"type": "image/png"

En esta línea debemos agregar el pubKey de nuestra cartera local

"address": "[pub_key]",

Una vez que se hayan llenado debidamente los campos y guardado nuestro archivo, procederemos a subirlo de la misma manera que subimos la imagen en el paso anterior.

$ arloader upload [ruta/de/la/metadata.json] --with-sol --sol-keypair-path ~/.config/solana/tu-cartera.json --ar-default-keypair --no-bundle

Obtendremos un mensaje similar a este:

id:             [tx_id]
status:         Submitted
file_path:      [ruta/de/la/metadata.json]
created_at:     2022-08-21 15:48:49
last_modified:  2022-08-21 15:48:49
Uploaded 1 files. Run `arloader update-status  --file-paths ` to confirm transaction(s).

Nuevamente debemos esperar por las confirmaciones, podremos chequear el avance con el siguiente comando $ arloader get-status [tx_id] o con la siguiente URL https://arweave.net/tx_id (si se muestra la metadata quiere decir que ya esta listo)

5. Mintear el Token

Finalmente para mintear nuestro token vamos a usar MetaPlex CLI (como mencione anteriormente esta obsoleto pero funciona perfectamente) una vez instalado nos ubicamos en la carpeta del proyecto

C:\Users\User\deprecated-clis

Una vez en el proyecto debemos ir a la carpeta src y ejecutar los siguiente comandos

$ cd src
$ ts-node cli-nft.ts mint --env mainnet-beta --keypair ~/.config/solana/tu-cartera.json --url https://arweave.net/[tx_id] --max-supply 1

En esta linea debemos agregar el tx-id que obtuvimos al subir la metadata

https://arweave.net/[tx_id]

Obtendremos dos URL una nos mostrará los detalles de la transacción y la otra el Token que acabamos de mintear:

6. Agregar nuestra cartera local a Phantom

En caso de que deseemos añadir nuestra cartera local a Phantom, el proceso es muy sencillo, basta con seguir estos sencillos pasos:

Abrir la extensión de Phantom en nuestro navegador
Hacer clic en el botón de la esquina superior izquierda

Hacer clic en "Add / Connect Wallet"

Ahora haremos clic en import private key

Por último abriremos nuestra cartera local dirigiéndonos a la carpeta donde esta ubicada y abriendo el archivo .json con un editor de código, copiaremos todo el contenido y lo pegaremos en el campo private key

Con esto podremos visualizar nuestros NFT desde la extensión de wallet, así como poder incluirlos en la sección de crypto de Code&Jobs y escoger uno para mostrarlo en nuestro perfil de usuario.

Te dejo información mas detallada de como realizar esto en la documentacion oficial

7. Quemar NFTs en Phantom

Phantom cuenta con la opción de poder quemar nuestros NFTs, con esto eliminaremos el nft y obtendremos el reembolso del dinero al momento de mintear el Token, para esto debemos seguir los siguientes pasos

Abrir la extensión de Phantom Wallet.
Hacer click en el botón de Your Collectibles en la barra inferior.

Seguido de esto seleccionaremos el NFT que queramos quemar.

Haremos clic en el botón con los tres puntos ....

Ahora clic en burn all tokens tokens.

Aparecerá una ventana de confirmación, tendremos que tildar la casilla seguido de hacer clic en Burn.

Veremos un mensaje diciendo que el token fue quemado y el importe en SOL que fue depositado en la cartera.

8. Conclusión

Aprendimos a mintear un NFT en la red SOLANA manualmente con ayuda de varias herramientas.

Realmente espero que hayas podido llegar hasta aquí sin ningún problema, en caso de que hayas encontrado algún obstáculo por favor házmelo saber con un comentario o sientete libre de contactarme por telegram o agregandome a Discord como Appu#9136

Muchas gracias por tu tiempo

How to mint a NFT on Solana?

Robert — Mon, 19 Sep 2022 13:56:59 +0000

We will learn how to mint a NFT manually on Solana.

To follow this post it is not necessary to use the Metaplex CLI, if you have an alternative, I would be very grateful if you could tell me about it.

Prerequisites

Metaplex CLI was deprecated by Metaplex team but still works and you will have no issue following this post. I plan to include another option if I can find it later

Metaplex CLI

In order to install Metaplex CLI we need to do the following:

Open this link
Clone the project with $ git clone https://github.com/metaplex-foundation/deprecated-clis.git
Locate the project folder and install the dependencies with $ yarn install or $ npm i

Creation of the local wallet
Buy Solana for our wallet
Upload the image we will use as NFT
Create and Upload the metadata of our NFT
Minting the Token
Add our local wallet to Phantom
Burn NFTs in Phantom
Conclusion

1. Creation of the local wallet

Assuming you have already installed Solana CLI), the first thing to do is to point to the mainnet with the following command:

$ solana config set --url https://api.mainnet-beta.solana.com

We will get a message similar to the following:

Config File: C:\Users\Rob\.config\solana\cli\config.yml
RPC URL: https://api.mainnet-beta.solana.com
WebSocket URL: wss://api.mainnet-beta.solana.com/ (computed)

Once this is done we will proceed to create the local wallet with the following command:

$ solana-keygen new --outfile ~/.solana/your-wallet.json

We will then be asked to enter a passphrase that we will use to retrieve the wallet.

For added security, enter a BIP39 passphrase

NOTE! This passphrase improves security of the recovery seed phrase NOT the
keypair file itself, which is stored as insecure plain text

BIP39 Passphrase (empty for none):

Once entered we will get the following message:

Wrote new keypair to /Users/Rob/.config/solana/your-wallet.json ==================================================================== pubkey: [wallet_pub_key] ==================================================================== Save this seed phrase and your BIP39 passphrase to recover your new keypair:
[REDACTED] ====================================================================

The pubkey will be our wallet address.

Now we will proceed to assign it as our default wallet with the following command:

$ solana config set --keypair ~/.solana/your-wallet.json

2. Buy Solana for our wallet

To be able to perform the whole process we will need less than 2 USD in SOL.

In case we have a Phantom Wallet with SOL in it we can just send SOL to the new wallet.

Otherwise we can acquire SOL using FTX by following the steps below:

1. Create an account

2. Go to wallet page

3. Deposit USD or EUR

In the Wallet page we go to the currency (USD or EUR) we want to deposit and click on DEPOSIT.

After that we will select debit card, follow the steps and confirm the deposit.

4. Convert to SOL

Once we have done the previous step and we have the balance available in USD or EUR, we can convert it to SOL by clicking on CONVERT.

After this we will select the currency to which we want to convert, in this case SOL.

5. We will pass the amount we converted to SOL to our local wallet.

Now we go to the search icon and search for SOL, and proceed to click on withdraw WITHDRAW, enter the amount we want to withdraw and the pubkey which is our wallet address

Once we have transferred funds to our local wallet we can check them using the following command:

$ solana balance pubkey

3. Upload the image we will use as NFT

For this example we will use the Code&Jobs Logo, feel free to use or create the image of your choice.

We will upload the image using arloader CLI, but in case you want to do it manually you can follow the instructions in the following post

With the following command we will specify the path of the image that we are going to upload, and that we will make the payment with our Solana wallet:

$ arloader upload <code&jobs_logo.png> --with-sol --sol-keypair-path ~/.config/solana/your-wallet.json --ar-default-keypair --no-bundle

We are going to get the following message by console:

id:             <tx_id>
status:         Submitted
file_path:      <code&jobs_logo.png>
created_at:     2022-08-21 15:43:13
last_modified:  2022-08-21 15:43:13
Uploaded 1 files. Run `arloader update-status  --file-paths ` to confirm transaction(s).

Be sure to save the tx_id.

Once this is done we will have to wait a bit for the file to be available, we can check the status with the following command $ arloader get-status [tx_id] or with the following URL https://arweave.net/tx_id (in case it is confirmed we will be able to get the image)

While we wait we can move on to the next step.

4. Create and Upload the metadata of our NFT .

Next we will create the metadata of our NFT using the metaplex standard. For this we must open a code editor and create a file named metadata.json, we will copy the following inside that file.

{
    "name": "Your Solana NFT",
    "symbol": "ANYSYMBOL",
    "description": "Your first Solana NFT",
    "seller_fee_basis_points": 1000,
    "image": "https://arweave.net/<tx_id>?ext=png",
    "external_url": "https://www.codenjobs.com/user/rtagliavia",
    "attributes":
    [
        {
            "trait_type": "Whatever Trait 1",
            "value": "Fire"
        },
        {
            "trait_type": "Whatever Trait 2",
            "value": "Sunglasses"
        }
    ],
    "properties":
    {
        "files":
        [
            {
                "uri": "https://arweave.net/<tx_id>?ext=png",
                "type": "image/png"
            }
        ],
        "category": "image",
        "creators":
        [
            {
                "address": "[pub_key]",
                "share": 100
            }
        ]
    }
}

In this line we will place the transaction ID we received in the previous step, and the extension can be .jpg or .png.

"image": "https://arweave.net/[tx_id]?ext=png",

Also in the following

"uri": "https://arweave.net/[arweave_img_tx_id]?ext=png",
"type": "image/png"

In this line we must add the pubKey of our local wallet

"address": "[pub_key]",

Once the fields have been filled and our file has been saved, we will proceed to upload it in the same way as we uploaded the image in the previous step.

$ arloader upload [ruta/de/la/metadata.json] --with-sol --sol-keypair-path ~/.config/solana/[nombre-de-la-cartera].json --ar-default-keypair --no-bundle

We will get a message similar to this one:

id:             [tx_id]
status:         Submitted
file_path:      [ruta/de/la/metadata.json]
created_at:     2022-08-21 15:48:49
last_modified:  2022-08-21 15:48:49
Uploaded 1 files. Run `arloader update-status  --file-paths ` to confirm transaction(s).

Again we must wait for the confirmations, we can check the progress with the following command $ arloader get-status [tx_id] or with the following URL https://arweave.net/tx_id (if the metadata is shown it means it is ready)

5. Minting the Token

Finally we will mint our token we are going to use MetaPlex CLI as I mentioned before it is obsolete but works perfectly fine, once installed we go to the project folder

C:\Users\User\deprecated-clis

Once in the project we must go to the src folder and execute the following commands

$ cd src
$ ts-node cli-nft.ts mint --env mainnet-beta --keypair ~/.config/solana/[nombre-de-la-cartera].json --url https://arweave.net/[tx_id] --max-supply 1

In this line we must add the tx-id we obtained when uploading the metadata.

https://arweave.net/[tx_id]

We will get two URLs, one will show us the details of the transaction and the other the token we just minted:

6. Add our local wallet to Phantom

In case we want to add our local wallet to Phantom, the process is very simple, just follow these steps:

Open the Phantom extension in our browser.
Click on the button in the upper left corner.

Click on "Add / Connect Portfolio"

Now click on import private key

Finally we will open our local wallet by going to the folder where it is located and opening the .json file with a code editor, copy all the content and paste it in the private key field.

With this we will be able to visualize our NFTs from the wallet extension, as well as being able to include them in the crypto section of Code&Jobs and choose one to show it in our user profile.

7. Burn NFTs in Phantom

Phantom has the option of being able to burn our NFTs, with this we will eliminate the NFT and we will obtain the refund of the money at the moment of mining the Token, for this we must follow the following steps.

Open the Phantom Wallet extension.
Click on the Your Collectibles button in the bottom bar.

Next select the NFT you want to burn.

Click on the button with the three dots ....

Now click on burn all tokens tokens.

A confirmation window will appear, we will have to check the box followed by clicking Burn.

We will see a message saying that the token was burned and the amount in SOL that was deposited in the wallet.

8. Conclusion

We learned how to mint an NFT on the Solana network manually with the help of various tools.

I really hope you were able to get this far without any problems, in case you encountered any issues please let me know with a comment or feel free to contact me by telegram or by adding me on Discord as Appu#9136.

Thank you very much for your time.

Bot de criptomonedas de discord con discord.js y node.js

Robert — Thu, 15 Sep 2022 15:47:51 +0000

En este post aprenderemos a crear un bot de discord para obtener el valor de criptomonedas en moneda local, para eso estaremos usando la API de Coingecko.

En caso de que te interese aprender a realizar el mismo bot para Telegram has clic aqui.

Me puedes contactar por telegram en caso de que necesites un Full Stack developer o si necesitas un bot de discord para tu servidor.

También puedes agregarme a discord como Appu#9136.

Te dejo el repo del proyecto en caso de que quieras clonarlo.

Prerrequisitos

Node.js instalado
Una cuenta de Discord

Creación del proyecto

Abre la consola y escribe los siguientes comandos.

$ mkdir node-telegram-tut
$ cd node-telegram-tut
$ npm init --y

Abre el proyecto con tu editor de código de preferencia.

Dependencias

axios
dotenv
discord.js

Para instalar las dependencias abriremos la consola y nos ubicamos en la carpeta del proyecto, y luego escribiremos los siguientes comandos.

$ npm i axios dotenv discord.js

Abriremos el archivo package.json y agregaremos esto.

  "scripts": {
    "start": "node ./src index.js"
  },

Estrucutra del proyecto

cryptocurrency-discord-bot/
├── node_modules/
├── src/
│ └── index.js
├── .env
└── package.json

Tabla de Contenido

Creación de nuestro servidor de Discord
Creación del bot y añadirlo a nuestro servidor
Programando nuestro bot
Comandos del bot
Conclusión

1. Creación de nuestro servidor de Discord

Para poder probar nuestro bot, primero debemos crear un servidor de discord, para eso debemos seguir los siguientes pasos.

Abriremos Discord.
Haremos clic en el botón de + en la parte inferior izquierda.
Seleccionaremos Crear un servidor y seleccionaremos la opción para mi y mis amigos.

Después de crear el servidor, haremos clic en el icono de engranaje para abrir los ajustes de usuario, luego haremos clic en la opción Avanzado, y activamos el modo desarrollador.

2. Creacion del bot y añadirlo a nuestro servidor

Abriremos nuestro explorador y nos dirigiremos a Discord Developer Portal, y haremos clic donde dice Applications, luego haremos clic en New Application, nos mostrara un modal donde podremos elegir el nombre de nuestra nueva aplicación.

Ahora en el panel izquierdo hacemos clic en Bot y luego en Add Bot. En esta parte podremos elegir el nombre y el icono que tendrá nuestro bot, abajo veremos el token, lo vamos a copiar y guardar en un archivo de texto, ya que lo necesitaremos más adelante.

Deslizamos hacia abajo y haremos clic en Privileged Gateway Intents, aquí tildamos algunos intents para que se nos haga posible interactuar con nuestro bot.

Ahora iremos a OAuth2 -> URL Generator, encontraremos un panel con la etiqueta SCOPES, tildamos donde dice bot y se generará una URL, la copiaremos y la pegaremos en una nueva pestaña de nuestro explorador.

Podremos observar algo similar a la imagen de abajo, ahora seleccionaremos nuestro servidor y haremos clic en el boton Authorize.

Finalmente podremos ver que el bot esta en nuestro servidor, ahora podemos emepzar a programarlo.

3. Programando nuestro Bot

Empezaremos a programar nuestro bot, primero crearemos un archivo .env en la raíz de nuestro proyecto, agregaremos una variable de entorno llamada BOT_TOKEN y le asignaremos el token que guardamos en la sección anterior.

BOT_TOKEN = colocar-el-token-aqui

Ahora iremos a index.js, y vamos a importar los discord.js, axios y dotenv.

const axios = require("axios");
const Discord = require("discord.js");
require("dotenv").config();

Luego crearemos un objeto client desde la clase Discord utilizando el constructor Client, y pasaremos los intents de la siguiente manera.

const client = new Discord.Client({
  intents: [
    "GUILDS",
    "GUILD_MEMBERS",
    "GUILD_MESSAGES",
    "GUILD_MESSAGE_REACTIONS",
  ],
});

Ahora haremos que nuestro bot aparezca online usando el método login y agregaremos un event listener para que nos muestre un mensaje en la consola cuando el bot esté listo.

client.on("ready", () => {
  console.log(`Hello my name is ${client.user.tag}!`);
});

client.login(process.env.BOT_TOKEN);

Deberíamos obtener un mensaje como este.

Hello my name is cryptocurrency-bot#0235!

4. Creando los comandos de nuestro bot

Para este ejemplo solo creare tres comandos.

!help para obtener un listado de todos los comandos asi como una descripción.
!currencies para obtener todas las monedas disponibles.
!crypto_price para obtener el precio de la criptomoneda en la moneda deseada.

1. Empecemos creando nuestro comando !help.

Usaremos el objeto cliente con el escuchador de eventos, estaremos escuchando el evento messageCreate que se emitirá cada vez que un mensaje sea creado, y usaremos async/await porque estaremos haciendo peticiones HTTP a la API de Coingecko.

Por favor asegurate de leer la documentación de discord.js y discord

Con msg.content podremos obtener el texto que envió el usuario, si el mensaje es igual a !help entonces responderemos al usuario con los comandos y la descripción de cada uno.

Los Embeds son una manera de darle formato y estilos a nuestro a mensajes, puedes encontrar mas informacion en la documentación

client.on("messageCreate",  async (msg) => {
  if(msg.content === '!help'){
    const embed1 = new Discord.MessageEmbed()
      .setTitle("Command list")
      .setDescription(
        '**!help** - shows the command list \n\n' +
        '**!currencies** to get all the suppported currencies. \n\n' +
        '**!crypto_price** *<currencies>* *<cryptocurrencies>* to get the value of the cryptocurrency in another currency, to use it first type the **currency** and then the **cryptocurrency** e.g. (**!crypto_price usd bitcoin**), can also add more currencies and cryptos separating them with commas but without spaces e.g. (**!crypto_price usd,eur,btc bitcoin,ethereum**) \n\n'
      );

    msg.channel.send({ embeds: [embed1] });
  }
});

Ahora si probamos nuestro comando !help obtendremos algo similar a esto.

2. Sigamos con nuestro comando !currencies.

Volvamos a nuestro codigo, y en lugar de un bloque if, usaremos un bloque switch con msg.content de esta manera, y de momento solo enviamos un mensaje que diga !currencies command cuando el usuario escriba !currencies.

client.on("messageCreate",  async (msg) => {

  switch (msg.content) {
    case "!help" || "!commands":
      const embed1 = new Discord.MessageEmbed()
      .setTitle("Command list")
      .setDescription(
        '**!help** or **!commands** - shows the command list \n\n' +
        '**!currencies** to get all the suppported currencies. \n\n' +
        '**!crypto_price** *<currencies>* *<cryptocurrencies>* to get the value of the cryptocurrency in another currency, to use it first type the **currency** and then the **cryptocurrency** e.g. (**!crypto_price usd bitcoin**), can also add more currencies and cryptos separating them with commas but without spaces e.g. (**!crypto_price usd,eur,btc bitcoin,ethereum**) \n\n'
      );

    msg.channel.send({ embeds: [embed1] });
      break;
    case "!currencies":
      msg.channel.send('!currencies command')
      break;
  }
});

Ahora borraremos esta linea msg.channel.send('!currencies command'), y haremos una petición GET a la API de Coingecko y obtendremos todas las monedas disponibles.

Utilice el método map para obtener cada moneda en cursiva y luego asignarla a una constante llamada currencies, luego cree un nuevo embed.

  const res = await axios.get("https://api.coingecko.com/api/v3/simple/supported_vs_currencies");

  const currencies = res.data.map((currency) => `*${currency}*`)

  const embed2 = new Discord.MessageEmbed()
    .setTitle("Supported Currencies")
    .setDescription(currencies.join(", "))
    .setColor("#0099ff")
    .setFooter("Powered by CoinGecko");

  msg.channel.send({ embeds: [embed2] });

Ahora si probamos el comando !currencies obtendremos esto.

3. Por último el comando !crypto_price.

Para este comando el usuario enviará un mensaje como este !crypto_price usd,eur bitcoin, por lo que debemos separar el string por espacios con .split(' '). Esto va a separar el string en tres partes.

La primera parte será !crypto_price.
La segunda parte será usd,eur.
La tercera parte será bitcoin.

Crearemos dos variables, una llamada curencies y otra llamada *cryptoCurrencies y asignaremos a cada una los valores correspondientes.

Para obtener las palabras después de !crypto_proce debemos hacer uso de msg.content.startsWith("!crypto_price") de otra manera el comando no funcionará.

Antes del bloque switch usaremos un bloque if, si el mensaje empieza con !crypto_price entonces ejecutaremos nuestro comando:

client.on("messageCreate",  (msg) => {
  if (msg.content.startsWith("!crypto_price")) {

  } else {
    switch (msg.content) {
     .
     .
     .
    }
  }
});

Ahora asignamos los valores respectivos de currencies y cryptoCurrenciesseparando el string.

Necesitamos crear una condicional en caso de que el usuario coloque los datos de forma incorrecta, o en caso de que el usuario no coloque ningún dato en el comando. Si este es el caso necesitamos enviar un mensaje al usuario, en este caso enviaremos un mensaje al usuario para que recuerde cómo hacer uso del comando.

Ahora haremos una petición GET a la API, además debemos chequear si el objeto que recibimos de la respuesta no este vacío, en caso de estarlo es por algun dato fue escrito de forma incorrecta, en este caso enviaremos nuevamente el mismo mensaje al usuario para que haga uso adecuado del comando.

Obtendremos los datos de la siguiente manera.

data: {
    bitcoin: { usd: 21816, eur: 20872 },
    ethereum: { usd: 1177.46, eur: 1126.54 }
  }

usaremos un for loop dentro de otro for loop para manipular los datos, luego usaremos un embed para darle formato al texto.

if (msg.content.startsWith("!crypto_price")) {
  const currencies = msg.content.split(" ")[1];
  const cryptoCurrencies = msg.content.split(" ")[2];

  if (cryptoCurrencies === undefined || currencies === undefined) {
    const embed = new Discord.MessageEmbed()
      .setTitle("Error")
      .setDescription("Please provide a currency and a cryptocurrency, remember to separate them with commas but without spaces e.g. (!crypto_price usd,eur bitcoin,ethereum)")
      .setColor("#ff0000");

    msg.channel.send({ embeds: [embed] });
    return
  }

  axios.get( `https://api.coingecko.com/api/v3/simple/price?ids=${cryptoCurrencies}&vs_currencies=${currencies}`)
  .then((res) => {
    if (res) {

      //if res is empty
      if(Object.keys(res.data).length === 0) {
        const embed = new Discord.MessageEmbed()
        .setTitle("Error")
        .setDescription("Please enter the **currency** and the **cryptocurrency** you want to convert to, remember to separate them with commas but without spaces e.g. (*!crypto_price usd,eur,btc bitcoin,ethereum*).")
        .setColor("#ff0000");

        msg.channel.send({ embeds: [embed] });
      }

      const response = res.data;

      for (let cryptoCurrency in response) {
        for (let currency in response[cryptoCurrency]) {
          const embed = new Discord.MessageEmbed()
          .setDescription(`**${cryptoCurrency}** price in **${currency.toUpperCase()}** ➡️ ${response[cryptoCurrency][currency]}`)

          msg.channel.send({ embeds: [embed] });
        }
      }
    }
  })
}

Si intentamos usar !crypto_price obtendremos algo similar a esto.

5. Conclusión

En este post aprendimos a crear un bot de criptomonedas para discord, utilizando discord.js y node.js.

Realmente espero que hayas podido llegar hasta aquí, en caso de que hayas tenido algún problema por favor no dudes en ponerte en contacto o dejar un comentario.

Puedes contactarme a traves de Telegram o puedes encontrarme en Discord como Appu#9136.

Gracias por tu tiempo.

How to get started with cryptocurrencies?

Robert — Fri, 02 Sep 2022 21:34:04 +0000

How to get started with cryptocurrencies?

The following post is made in order to understand in a simple way what cryptocurrencies are, how to buy/sell them, what benefits are obtained from them, and what can be done with them.

I have written this post with the intention of helping users to start with cryptocurrencies, and also to those who want to learn how to use them, because nowadays there are many jobs or sources of income that make payments only through cryptocurrencies (in case you are interested in Code&Jobs you can find jobs that pay with cryptocurrencies) and perhaps due to lack of knowledge users prefer to discard these offers.

What are cryptocurrencies?

To explain it briefly we could say that cryptocurrencies are digital currencies that are characterized by being decentralized, that is to say they are not regulated by any organization, they do not need to go through an intermediary to be transferred (banks).

What are stable cryptocurrencies?

They are a solution to try to reduce the volatility of cryptocurrencies.

Imagine living in a country where the currency is constantly devaluating and you cannot save money, and in addition to this it is difficult to buy foreign currency or open a bank account to save it.

A simple solution would be to buy stable cryptocurrencies, such as (USDT, USDC) are cryptocurrencies whose value is backed by the dollar or euro, i.e. 1 dollar would be 1 USDT or USDC for example.

Where to buy cryptocurrencies?

Today there are several ways to get cryptocurrencies, among the most popular are Binance and FTX.

I will explain how to use Binance as it is the option I personally use the most and the most popular at present.

How to buy cryptocurrencies on Binance?

Below I will explain step by step how to buy your first cryptocurrencies in Binance in a very simple way.

1. Account creation

The first thing we will do is to create our account in Binance.

2. Identification

Once registered we will go to the identification section, where we must follow a series of steps, this will be necessary to start buying and selling cryptocurrencies.

3. Buy cryptocurrencies

Once the previous step has been completed and verified we will go to the Trade the clic on P2P. Perhaps the interface may look a bit overwhelming but it is very simple to use.

Steps to follow.

We are going to find a Buy/Sell switch button, as we are going to buy we will leave it on Buy.
Next we will see eight cryptocurrencies with which we can trade, we will leave it in USDT or BUSD which are stable cryptocurrencies (its value is backed by to the value of the dollar, ie 1 USDT = $1).

Optionally select the amount of FIAT or local currency we are going to use to buy the cryptocurrencies, this will help us to better filter the search.
We will select the FIAT which will be the currency we are going to use to buy the cryptocurrencies, by clicking you can find Euro, US Dollar, Mexican Peso, Argentine Peso, Bolivar, etc.
We can also filter by payment method, by clicking we will be able to see a list of banks, as well as other payment methods such as in Venezuela Pago Móvil, or in Argentina MercadoPago, etc.

After this we will see a list of advertisers, where we can see information such as number of transactions made, and percentage of transaction completion use this as a guide before making any transaction, if a person has low percentage I recommend jumping to another advertiser with higher percentage to avoid being scammed.

The price at which the advertiser sells the cryptocurrency, in the example of the image we can see that the advertiser sells each unit of USDT at 1.003 EUR.
The limit and availability, in the first line we can see how much USDT he has, and in the next one the minimum and maximum we can buy.
The type of payment we will use in this transaction.
After agreeing with the price, limit, and being sure we want to buy from the advertiser we will proceed to click Buy USDT.
When clicking on Buy USDT a page with two sections will be displayed, on the left we will be able to see the data we saw before, followed by the advertiser's Terms and Conditions, and on the right two fields, the first of how much we are going to pay, and the second will automatically show us when we are going to receive according to what we have paid. It remains to click again on Buy USDT and complete the transaction.

Once the previous operation is successfully completed, we will be able to see our USDT in the following link, or by clicking on Wallet and then on Funding.

4. Selling cryptocurrencies

The process to sell cryptocurrencies is similar to buying them, here are a series of steps.

Assign a payment method

The first thing we must do is to assign a payment method that we will use to get the money from the sale.

We must go to our User Panel and once there look in the left panel for the Payment option.

In the Payment page we will be able to observe a button Add a payment method in which we must click.

A window will open where we will be able to choose between multiple methods, we can search by Letter or use the search engine to make a more exact search.

After choosing, it will take us to a form that we must fill with the required data. Once filled we will click on confirm, and we will have our payment method added.

Steps to follow to sell.

Now click on Trade followed by P2P.

We will click on the switch button and leave it on Sell.

We will select among the options of cryptocurrencies to sell.
We will be able to indicate the Amount, the FIAT or the currency that we are going to receive, and the method of payment that we will use to receive the money of our sale.

Next we will see a list of advertised number of orders placed and the completion rate of the transactions, followed by the price, the availability and limit, and the method of payment.

Once we are sure of which advertiser to make the transaction with, we will click on sell.
A window divided in two panels will be shown, where on the left it will show us the information we read previously, and on the right two fields, in the first one the amount of cryptocurrency we will sell, and in the second one the amount we will receive will be shown. Once this is confirmed we will click again on Sell.

Once the advertiser has confirmed that the payment has been made, we must check that the funds are available in our bank account and we will proceed to release the cryptocurrencies.

5. Convert cryptocurrencies

When buying cryptocurrencies we can only choose between 8 options in the P2P section, so in case we need another cryptocurrency we can take advantage of this functionality.

We will click on convert or we will go to the following link where we can see a window with two fields, in the first one we can select which cryptocurrency we want to convert, in this case the USDT we bought in the previous step, and we will place the amount, and in the second field we can select to which cryptocurrency we want to convert, Finally we click on convert.

6. How to receive cryptocurrencies?

It may be the case that we have found a job that pays in cryptocurrencies, like many of those we can find in Code&Jobs or that we simply want someone to pay us in cryptocurrencies. In order to receive, we simply need to search in the Wallet for the cryptocurrency we want to receive and click on Deposit.

For example, if we want to receive Solana we look for SOL or solana, and click on Deposit, once here we will see a window with two fields, the first one corresponds to the cryptocurrency, and the second one to the network from where the cryptocurrencies will be sent to us, once we select the network we will obtain the address of our wallet which we will copy and send to the person who is going to send us the cryptocurrencies.

Coingecko

Coingecko is a website, which provides information about the performance of a large number of available cryptocurrencies. It uses real time data, shows price fluctuation in various time periods.

In short for those who need to check the price of a cryptocurrency can use this web application.

PancakeSwap

PancakeSwap is a decentralized exchange platform DEX for tokens within the Binance Smart Chain or also known as BSC.

PancakeSwap cuts out the intermediaries on centralized exchanges, letting other users take those commissions instead. If you're willing to lock up your tokens for a while, the rewards can be very plentiful, especially with some of the liquidity pools and betting options.

PancakeSwap may be a bit of a challenge for those new to cryptocurrencies, but it may be worth checking out.

Sites that accept payments in cryptocurrency

Coinsbee in this site you can find a variety of gift cards (Amazon, Google Play, Steam, Netflix, etc).

Bitrefill is a site similar to Coinsbee, with sales of gift cards.

Newegg Here you can buy PC components, laptops, monitors, game consoles, gadgets, etc.

Terms

Bitcoin

When we talk about Bitcoin, we talk about the first platform based on blockchain that sought from its beginnings to be a secure, fast and decentralized payment method. And the cryptocurrency also known as BTC, whose current value you can check here

Blockchain

Blockchain is a chain of blocks, which contain encrypted information of a transaction that was made on the network. And being in chain allows data to be transferred securely thanks to cryptographic encryption.

Exchange

They are sites where we can buy and sell cryptocurrencies. Currently there are many, some with more catalog than others, as well as higher commissions on some than others. Some examples of these sites are Binance, FTX, LocalBitcoins, etc.

Fiat

Fiat is a government approved currency that is backed by physical commodities, e.g. USD, EUR, your country's local currency, etc.

P2P

Its acronym stands for "Peer to Peer", and in the context of Blockchain it refers to a network of computers that are connected to each other without the need for a server or centralized entity. In other words, it is a direct connection between two computers or users.

Transaction

Any action that is performed within a blockchain. Example: receive or send cryptocurrencies to another person.
another person.

Wallet

We can think of a wallet as an account or address to receive cryptocurrencies. They can be online, physical or a local application.

Wallets

Wallets are instruments to receive and send cryptocurrencies. They exist online, physical or local applications.

Among the most popular ones we can find the following.

Metamask

It is a browser extension that also works as a wallet serves to receive and send cryptocurrencies. as well as to be able to interact with web applications that are based on the Ethereum blockchain as PancakeSwap for example.

Phantom

As well as Metamask, Phantom is a browser extension that works as a wallet serves to receive and send cryptocurrencies in Solana.

It is required to interact with web applications that use the Solana blockchain, such as Code&Jobs.

This wallet has a special functionality that consists of Burn NFTs this is a process in which the NFT is removed and the wallet owner is refunded the amount that was used at the time of Burning the NFT.

If you are interested in learning more about it you can go to the following post

Conclusion

In this post we learned a little about cryptocurrencies, what we can do with them, how to acquire them, sell them and even learned about some stores where we can use them directly.

If you have any questions or suggestions feel free to leave a comment on this post, I will answer as soon as possible.

Feel free to contact me by telegram or adding me to Discord as Appu#9136.

Thank you very much for your time.

¿Cómo iniciar con las criptomonedas?

Robert — Fri, 02 Sep 2022 21:33:03 +0000

¿Cómo iniciar con las criptomonedas?

El siguiente post está hecho con el fin de entender de una forma sencilla qué son las criptomonedas, como comprarlas/venderlas, qué beneficios se obtienen de las mismas, y que es lo que se puede hacer con ellas.

Este post lo he escrito con la intención de ayudar a los usuarios a iniciar con las criptomonedas, y también a los que quieren aprender a usarlas, ya que en la actualidad hay muchos empleos o fuentes de ingresos que realizan pagos únicamente mediante criptomonedas (en caso de que te interese en Code&Jobs puedes encontrar empleos que paguen con criptomonedas) y quizás por falta de conocimiento los usuarios prefieren descartar estas ofertas.

¿Qué son las criptomonedas?

Para explicarlo de forma breve se podría decir que las criptomonedas son monedas digitales que se caracterizan por ser descentralizadas es decir no están reguladas por ninguna organización, no necesitan pasar por un intermediario para ser transferidas (bancos).

¿Qué son las criptomonedas estables?

Son una solución para tratar de reducir la volatilidad de las criptomonedas.

Imaginemos estar en la situación de vivir en un país donde la moneda se devalúa constantemente y no puedas ahorrar dinero, y sumado a esto se dificulte comprar divisas o aperturar una cuenta bancaria para el ahorro de estas.

Una solución sencilla sería comprar criptomonedas estables, como por ejemplo (USDT, USDC) son criptomonedas cuyo valor está respaldado por el dólar o euro, es decir 1 dólar sería igual a 1 USDT o USDC por ejemplo.

¿Dónde comprar criptomonedas?

A día de hoy existen varias formas de conseguir criptomonedas, entre las más populares estan Binance y FTX.

Explicaré como usar Binance ya que personalmente es la opción que más uso y la más popular en la actualidad.

¿Cómo comprar criptomonedas en Binance?

Creación de cuenta
Identificación
Comprar criptomonedas
Vender criptomonedas
Convertir criptomonedas
Recibir criptomonedas

A continuación te explicaré paso a paso cómo comprar tus primeras criptomonedas en Binance de forma muy sencilla.

1. Creación de cuenta

Lo primero que haremos será crear nuestra cuenta en Binance.

2. Identificación

Una vez registrados nos dirigiremos a la sección de identificación, donde debemos seguir una serie de pasos, esto será necesario para empezar a comprar y vender criptomonedas.

3. Comprar criptomonedas

Una vez se haya completado y verificado el paso anterior nos vamos a dirigir a la sección de Trade y cuenta P2P. Quizás la interfaz pueda lucir un poco abrumadora pero es muy sencilla de usar.

Pasos a seguir.

Vamos a encontrarnos un botón switch de Buy/Sell, como vamos a comprar lo dejaremos en Buy.
Seguido veremos ocho criptomonedas con las que podremos tradear, no es necesario que te hagas mucha cabezas con esto, vamos a dejarlo en USDT o BUSD que son criptomonedas estables (su valor está anclado al valor del dólar, es decir 1 USDT = $1).

Una vez seleccionemos opcionalmente la cantidad de FIAT o moneda local que vamos a utilizar para comprar las criptomonedas, esto nos ayudará a filtrar mejor la búsqueda.
Seleccionaremos el FIAT que será la moneda que vamos a utilizar para comprar las criptomonedas, al hacer clic podras encontrar Euro, Dolar americano, Peso Mexicano, Peso Argentino, Bolívares, etc.
También podemos filtrar por medio de pago, al hacer clic podremos ver un listado de bancos, así como otros medio de pago como por ejemplo en Venezuela Pago Móvil, o en Argentina MercadoPago, etc.

Después de esto veremos una lista de anunciantes, donde podremos ver información como cantidad de transacciones realizadas, y porcentaje de completación de transacciones usa esto de guía antes de realizar cualquier transacción, si una persona tiene porcentaje bajo recomiendo saltar a otro anunciantes con mayor porcentaje para evitar ser estafado.

El precio en el que anunciante vende la criptomoneda, en el ejemplo de la imagen podemos ver que el anunciante vende cada unidad de USDT a 1.003 EUR.
El límite y la disponibilidad, en la primera línea podemos ver de cuanto USDT dispone, y en la siguiente el mínimo y el máximo que podemos comprar.
El tipo de pago que utilizaremos en esta transacción.
Después de estar de acuerdo con el precio, límite, y estar seguros de querer comprar al anunciante procederemos a hacer clic en Buy USDT
Al hacer clic en Buy USDT se desplegará una página con dos secciones, a la izquierda podremos observar los datos que vimos anteriormente, seguido de Términos y Condiciones del anunciante, y a la derecha dos campos, el primero de cuanto vamos a pagar, y el segundo nos mostrará de forma automática cuando vamos a recibir según lo pagado. Queda hacer clic nuevamente en Buy USDT y completar la transacción.

Una vez completada con éxito la operación anterior, podremos ver nuestros USDT en el siguiente enlance, o haciendo clic en Wallet y luego en Funding.

4. Vender criptomonedas

El proceso para vender criptomonedas es similar al de comprarlas, a continuación dejaré una serie de pasos.

Asignar un método de pago

Lo primero que debemos hacer es asignar un método de pago que usaremos para que nos llegue el dinero de la venta.

Debemos ir a nuestro Panel de usuario y una vez ahí buscar en el panel izquierdo la opción de Pago.

En la página de Pago podremos observar un botón de Agregar un método de pago en el que debemos hacer clic.

Se abrirá una ventana donde podremos elegir entre múltiples métodos, podemos buscar por Letra o usar el buscador para hacer una búsqueda más exacta.

Después de elegir, nos llevará a un formulario que debemos llenar con los datos requeridos. Una vez llenado haremos clic en confirmar, y ya tendremos nuestro método de pago añadido.

Pasos a seguir para vender.

Ahora haremos clic en Trade seguido de cuenta P2P.

Haremos clic en el botón de switch y lo dejaremos en Venta.

Seleccionaremos entre las opciones de criptomonedas para vender.
Podremos señalar el Monto, el FIAT o la moneda que vamos a recibir, y el método de pago que usaremos para recibir el dinero de nuestra venta.

A continuación veremos una lista de anunciarse con número de órdenes realizadas y el porcentaje de completación de las transacciones, seguido del precio, la disponibilidad y el límite, y el método de pago.

Una vez estemos seguros de con qué anunciante realizar la transacción, haremos clic en vender.
Se mostrará una ventana dividida en dos paneles, donde a la izquierda nos mostrará la información que leímos anteriormente, y en el derecho dos campos, en el primero la cantidad de criptomoneda que venderemos, y en el segundo se mostrará la cantidad que recibiremos. Una vez confirmado esto haremos clic nuevamente en Vender.

Una vez el anunciate haya confirmado que realizado el pago, debemos revisar que los fondos estén disponibles en nuestra cuenta y procederemos a liberar las criptomonedas.

5. Convertir criptomonedas

Al momento de comprar criptomonedas solo podemos elegir entre 8 opciones en la sección de P2P, por lo que en caso de necesitar otra criptomoneda podemos aprovechar esta funcionalidad.

Haremos clic en convert o nos dirigiremos al siguiente enlace donde podremos observar una ventana con dos campos, en el primero podremos seleccionar que criptomoneda deseamos convertir, en este caso los USDT que compramos en el paso anterior, y colocaremos la cantidad, y en el segundo campo podremos seleccionar a que criptomoneda deseamos convertir, Finalmente hacemos clic en convertir.

6. ¿Cómo recibir criptomonedas?

Puede darse el caso de que hayamos encontrado un empleo que pague en criptomonedas, como muchos de los que podemos encontrar en Code&Jobs o que simplemente queramos que alguien nos pague en criptomonedas. Para poder recibir simplemente debemos buscar en el Wallet la criptomoneda que deseemos recibir y hacer clic en Deposit.

Por ejemplo, si queremos recibir Solana buscamos SOL o solana, y hacemos clic en Deposit, una vez aquí veremos una ventana con dos campos, el primero corresponde a la criptomoneda, y el segundo a la red desde donde nos enviaran las criptomonedas, una vez seleccionemos la red obtendremos la dirección de nuestro wallet la cual copiaremos y enviaremos a la persona que nos va a enviar las criptomonedas.

Coingecko

Coingecko es un sitio web, que nos brinda la información acerca del rendimiento de una gran cantidad de criptomonedas disponibles. Usa datos en tiempo real, muestra fluctuación de precios en varios periodos de tiempo.

En resumen para los que necesiten consultar el precio de una criptomoneda pueden usar esta aplicación web.

PancakeSwap

PancakeSwapes una plataforma de intercambio descentralizada (DEX) de tokens dentro la Binance Smart Chain o tambien conocida BSC

PancakeSwap elimina a los intermediarios de los intercambios centralizados, dejando que otros usuarios se hagan con esas comisiones en su lugar. Si estás dispuesto a bloquear tus tokens durante un tiempo, los premios pueden ser muy abundantes, sobre todo con algunos de los pools de liquidez y opciones de apuestas.

Quizas pancakeSwap sea un poco dificil para aquellos que se esten iniciando en el mundo de las criptomonedas, pero quias valga la pena revisarla.

Sitios ue aceptan pagos en criptomonedas

Coinsbee en esta página podrás encontrar distinta variedad de gift cards (Amazon, Google Play, Steam, Netflix, etc)

Bitrefill Es un sitio similar a Coinsbee, con ventas de gift cards

Newegg Aqui podras comprar componentes de PC, Laptops, Monitores, Consola de Videojuegos, gadgets, etc.

Terminos

Bitcoin

Cuando se habla de Bitcoin se habla tanto de la primera plataforma basada en blockchain que busco desde sus inicios se una forma de pago segura, rapida y descentralizada. Y de la criptomoneda tambien conocida como BTC, cuyo valor actual puedes consultar aqui

Blockchain

Blockchain es una cadena de bloques, los cuales contienen informacion cifrada de una transaccion que se realizo en la red. y al estar en cadena permiten que los datos puedan transferirse de forma seguro gracias a la codificacion criptografica.

Exchange

Son sitios donde podemos comprar y vender criptomonedas. En la actualdiad hay muchos, unos con mayor catalogo que otros, asi como comisiones mayores en unas que otros. Algunos ejemplos de estos sitios serian Binance, FTX, LocalBitcoins, etc.

Fiat

El Fiat es la moneda aprobada por un gobierno que estan respaldadas por mercancia fisica, por ejemplo el USD, el EUR, la moneda local de tu pais, etc.

P2P

Sus siglas significan "Peer to Peer" (en español red entre pares), y en el contexto de Blockchain se refiere a una red de ordenadores que estan conectados entre si si necesidad de que haya un servidor o ente centralizado. Es decir es una conexion directa entre los dos ordenadores o usuarios.

Transaccion

Cualquier accion que se realice dentro de una blockchain. Ejemplo: recibir o enviar criptomonedas a
otra persona.

Wallet

Podemos pensar que una wallet es cuenta o direccion para recibir criptomonedas. Pueden ser en linea, fisicas o una aplicación local.

Wallets

Las wallets son instrumentos para poder recibir y enviar criptomonedas. Existen en línea, físicas o aplicaciones locales.

Entre los más populares podemos encontrar los siguientes.

Metamask

Es una extensión para el navegador que también funciona como wallet sirve para recibir y enviar criptomonedas. así como para poder interactuar con aplicaciones web que estén basadas en el blockchain de Ethereum como PancakeSwap por ejemplo.

Phantom

Así como Metamask, Phantom es una extensión del navegador que funciona como wallet sirve para recibir y enviar criptomonedas en Solana.

Es necesaria para interactuar con aplicaciones web que utilicen el blockchain de Solana, como es el caso de Code&Jobs

Esta wallet cuenta con una funcionalidad especial que consiste en Quemar NFTs esto es un proceso en el que se elimina el NFT y se reembolsa al propietario de la wallet el importe que se utilizó al momento de Mintear el NFT.

Si estás interesado en aprender mas al respecto puedes dirigirte al siguiente post

Conclusión

En este post aprendimos un poco sobre las criptomonedas, que podemos hacer con ellas, como adquirirlas, venderlas e incluso aprendimos de algunos comercios donde podemos usarlas directamente.

Si tienes alguna duda o sugerencia no dudes en dejar un comentario en el post, te responderé lo mas pronto posible.

Sientete libre de contactarme por telegram o agregandome a Discord como Appu#9136.

Muchas gracias por tu tiempo.

¿Cómo subir archivos con ardrive manualmente y con ardrive CLI?

Robert — Thu, 25 Aug 2022 12:50:00 +0000

En el siguiente post voy a hablar sobre Arweave, como crear una billetera o wallet, y también como subir archivos de forma manual y con su CLI.

Para este ejemplo voy a subir algunas imágenes gratuitas de unsplash.

¿Qué es Arweave?

Según la página oficial de Arweave, Arweave es un protocolo que permite alojar datos de forma permanente, sustentable y con una única cuota inicial.

podemos considerarlo como una alternativa a IPFS

Con Ardrive, podremos subir y compartir achivos, ademas también disponen de una calculadora de tarifas en caso de que desees saber cuanto tendrás que pagar para subir la cantidad de datos que desees.

Si deseas enconntrar mas contenido o empleos relacionados a blockchain te recomiendo que entres y te registres en Code&Jobs

Prerrequisitos

Node.js instalado
Arweave Wallet
Ardrive CLI instalado

Creando nuestro Proyecto

Abre la consola y escribe los siguiente comandos
mkdir ardrive-tutorial
cd ardrive-tutorial
npm init --y
Ahora abre el proyecto con tu editor de código preferido.

Dependencias

Para instalar las dependencias nos ubicaremos en la carpeta de tu proyecto con la consola y escribe los siguientes comandos.

npm i ardrive-core-js dotenv prompt-sync

Usarémos import por lo que debemos abrir package.json y agregar la siguiente linea "type" : "module",

"type" : "module",
"scripts": {
  "start": "node ./src index.js"
},

Estructura del proyecto

arDrive-tutorial/
├── node_modules/
├── tutorial-images/
├── src/
│   └── index.js
├── .env
└── package.json

Tabla de contenidos

Autenticación en ArDrive
Subir archivos a ArDrive
Subir archvivos con ArDrive CLI
Script para crear un .json con la información de los archivos
Conclusión

1. Autenticación en ArDrivee

Este no es un paso complejo, asumiré que ya creaste tu wallet, así que lo siguiente es ir a la página de autenticación de Ardrive, y autenticarte con tu wallet.

el usuario y constraseña se utilizan para las carpetas privadas al momento de compartirlas

2. Subir archivos a ArDrive

Recuerda que todos los archivos serán alojados de forma permanente por lo que los archivos no podrán ser borrados.

Lo primero que haremos será crear un nuevo drive haciendo clic en el botón New.

Luego colocaremos un nombre y escogeremos entre público o privado, yo voy a elegir público

Luego vamos a hacer clic nuevamente en el botón New, y esta vez vamos a seleccionar "upload folder" porque vamos a subir una carpeta con archivos, como dije anteriormente en este ejemplo voy a subir algunas imágenes de unsplash. Eres libre de escoger el archivo que desees, solo asegurate de que tengas los permisos necesarios para hacerlo.

También podrás observar el precio para subir esos archivos, así podrás decidir si subirlos o no.

Ahora podrás ver la nueva carpeta creada en el drive, y si la abrimos los archivos que estan en ella, vamos a poder descargarlos, ver más información sobre ellos, un link para previsualizar, un link para comaprtir, etc.

3. Subir archvivos con ArDrive CLI

Vamos a repetir el proceso anterior, pero esta vez haciendo uso de ardrive CLI, para eso lo primero que vamos a hacer será abrir nuestra terminal y verificar de que este instalado con el siguiente comando:

ardrive --version

Si esta instalado verás un mensaje similar a este.

1.19.0

Para obtener mas informacion sobre los comandos que pueden ser usados escribe el siguiente comando ardrive -h o en caso de que desees mas información de como usar cierto comando, solo escribe el comando seguido de -h, por ejemplo ardrive create-drive -h

Ahora crearemos un nuevo drive, para eso debemos especificar la ruta donde se encuentra el archivo de nuestro Wallet, y el nombre que le vamos a asignar a nuestro drive.

ardrive create-drive -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> -n cli-tut

Deberías obtener un objeto con la información del nuevo drive parecido al siguiente

{
  "created": [
    {
      "type": "drive",
      "metadataTxId": "0fzTAOPqIK4Imk2xGf3e9CDCXxO_k-xFFlOkAA-IXRg",
      "entityId": "5e219c5e-ed6a-497d-b225-b5d621eed097",
      "bundledIn": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk",
      "entityName": "cli-tut"
    },
    {
      "type": "folder",
      "metadataTxId": "LGeONqTaoiE1m6_OXK2RcmsBZbkN0yxl-AKNUEn4ahs",
      "entityId": "1739f7e2-baa2-491a-a2ab-f406d778041a",
      "bundledIn": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk",
      "entityName": "cli-tut"
    },
    {
      "type": "bundle",
      "bundleTxId": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk"
    }
  ],
  "tips": [],
  "fees": {
    "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk": "52221667"
  }
}

Ahora lo que vamos a hacer es subir algunos archivos (pueden ser los mismos archivos del ejemplo anterior), si deseamos subirlos a la carpeta raíz como en el caso anterior debemos especificar el entityId de esta, vas a poder encontrarlo en el objeto que obtuvimos anteriormente en el objeto que contiene "type": "folder", y luego la información que estamos buscando esta en entityId.

De todas maneras si abres la página de arDrive vas a encontrar el nuevo drive, y podrás obtener el id de la carpeta raíz de la siguiente manera.

Tabién vamos a necesitar especificar la ubicación del archivo o carpeta que vamos a subir.

ardrive upload-file -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> --local-path <FILE\OR\FOLDER\LOCATION\THAT\WANT\TO\UPLOAD> -F <folder-id>

vas a obtener un mensaje como este.

{
  "created": [
    {
      "type": "folder",
      "entityId": "4de053e3-cf7f-4da6-88bc-e238e7478226",
      "metadataTxId": "rhML7VdZDfm2R1sASWwiCVt-_eeGb38VOFMUOszgvlM",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "entityName": "ardrive-cli-files",
    },
    {
      "type": "file",
      "entityName": "1.jpg",
      "entityId": "6cb92418-bf77-4edd-a271-a4981abb92bc",
      "dataTxId": "8y5PVi1V2WAF4etKv0lgbfx2tO2P_ekDu7PBFjhu4us",
      "metadataTxId": "LD2QI5erLPuvM39ptN0-G9vpLEGh4VXIdglhzS_oHEI",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
    },
    {
      "type": "file",
      "entityName": "2.jpg",
      "entityId": "48c33090-a7e6-47d3-b974-924a09defbb4",
      "dataTxId": "oMEPmy2LIKL0RI2WSfMyT3XEo2aZ86zqDQrEcfteqVo",
      "metadataTxId": "m3cDLllbgTwg4rlKF_FivP5nSHRd7BZ9WIUY31NVlxE",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "sourceUri": "file://C:\\Users\\Rob\\Downloads\\ardrive-cli-files\\2.txt"
    },
    {
      "type": "bundle",
      "bundleTxId": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4"
    }
  ],
  "tips": [
    {
      "recipient": "aVHpFhSorIljeZ9so8unOEnPkW3YqRbqG5cfM4aXxBI",
      "txId": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "winston": "10000000"
    }
  ],
  "fees": {
    "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4": "52221667"
  }
}

Entonces como pudiste observar, una nueva carpeta fue creada, y también dos archivos (en mi caso)

Ahora descargarrmos esa carpeta de archivos (se va a descargar en la ubicación actual de la terminal) con el siguiente comando:

ardrive download-folder -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> -f <folder-id>

4. Script para crear un .json con la información de los archivos

Ahora vamos a crear un script personalizado para obtener la información de los archivos y carpetas que hayamos subido, finalmente vamos a crear un archivo .json que va a contener toda esta información esto será de ayuda en un proyecto real de NFT

Lo primero que vamos a hacer es crear un archivo .env en la raíz de nuestro proyecto, y crearemos una variable WALLET_PATH que le asignaremos la ubicación de nuestro wallet C:\\YOUR\\WALLET\\PATH

Luego iremos a la carpeta src y vamos a abrir index.js, copia y pega el siguiente código, no te preocupes lo voy a explicar paso a paso.

Yo usare la carpeta que subimos en el ejemplo anterior, pero este script también puede funcionar con una estructura similar a la que voy a enseñarte a continuación

driveName
├── imagesFolder/ //si queremos la información de imagesFolder entonces 
│   ├── folder1/  //debemos dar el folder id correspondiente
│   │   ├── 0.jpg
│   │   └── 1.jpg
│   ├── folder2/
│   │   ├── 2.jpg
│   │   └── 3.jpg
│   ├── folder3/
│   │   ├── 4.jpg
│   │   └── 5.jpg
│   ├── folder4/
│   │   ├── 6.jpg
│   │   └── 7.jpg
│   └── folder5/
│       ├── 8.jpg
│       └── 9.jpg
├── metadatasFolder/
└── anotherFolder/

Vamos a importar import {readJWKFile, arDriveFactory} from 'ardrive-core-js'. readJWKFile nos va a permitir poder leer el archivo de nuestro wallet, y con arDriveFactory vamos a poder realizar operaciones de arDrive.
Vamos a crear un archivo .json file al final del script por lo que vamos a necesitar utilizar fs
El script va a solicitar al usuario que introduzca el folder ID, con el folder ID vamos a poder obtener todas las carpetas internas, así como también el drive ID que lo vamos a necesitar para crear el link para dirigirnos a la carpeta.
Vamos a ordenar las carpetas en caso de que hayan mas de una y contengan un nombre de proyecto similar al siguiente (PROJECT_NAME_1, PROJECT_NAME_2, PROJECT_NAME_3, etc) porque no vamos a poder obtener ordenadas por defecto.
Vamos a crear una const foldersId = [] donde vamos a almacenar los nombres y id de las carpetas.
Ahora vamos a usar un for loop para recorrer el array foldersId y obtener los archivos de cada carpeta con

const getFiles = await arDrive.listPublicFolder({
    folderId: folderId
  })

Ordenaremos los archivos porque los podemos obtener desordenados
Luego vamos a crear un array const filesInformation = [] que va a almacenar la información de cada uno de los archivos por cada carpeta
Después vamos a utilizar otro for loop para recorrerlos dentro del mismo loop, con este enfoque vamos a obtener toda la informacion de los archivos de la carpeta actual.
Ahora almacenaremos el folderName, folderLink, and also the filesInformation (fileName, fileId, and fileLink del loop anterior) en el array Files
Finalmente vamos a crear un archivo .json que va a contener toda la informacion contenida en Files

import {readJWKFile, arDriveFactory} from 'ardrive-core-js'
import fs from 'fs'
import dotenv from 'dotenv'
dotenv.config({path: '../.env'})
import ps from "prompt-sync";
const prompt = ps()

//read wallet from file
const myWallet = readJWKFile(process.env.WALLET_PATH)

const arDrive = arDriveFactory({ wallet: myWallet })

const folderID = prompt("insert the folder id ")

const getFolders = await arDrive.listPublicFolder({
  folderId: folderID 
})

const driveId = getFolders[0].driveId

const LINK_TO_FOLDERS = `https://app.ardrive.io/#/drives/${driveId}/folders/`

getFolders.sort((a, b) => {
  return a.name.localeCompare(b.name)
})

const foldersId = []

getFolders.forEach(folder => {
  foldersId.push({
    folderName: folder.name,
    folderId: folder.folderId.entityId
  })
})


const Files = []

for (let i = 0; i < foldersId.length; i++) {
  const folderId = foldersId[i].folderId
  const folderName = foldersId[i].folderName
  const getFiles = await arDrive.listPublicFolder({
    folderId: folderId
  })

  //create an array for eachFoldername
  const filesInformation = []



getFiles.sort((a, b) => {
  return a.name.localeCompare(b.name)
})

  for (let j = 0; j < getFiles.length; j++) {
    const file = getFiles[j]
    filesInformation.push({
      fileName: file.name,
      fileId: file.fileId.entityId,
      fileLink:'https://arweave.net/'+file.dataTxId.transactionId
    })


  }

  Files.push({
    folderName,
    folderLink: LINK_TO_FOLDERS + folderId,
    filesInformation
  })

}


fs.writeFileSync(`filesInfo.json`, JSON.stringify(Files))

El resultado final va a ser similar al siguiente

[
  {
    "folderName": "arweave-images",
    "folderLink": "https://app.ardrive.io/#/drives/5791d389-438c-4af5-820f-a2fe0fb782a8/folders/3d124a11-ebb5-4c2e-9d2c-02d6f1700b4b",
    "filesInformation": [
      {
        "fileName": "1.jpg",
        "fileId": "b2ca111f-54c5-4515-b700-e055c3a4e7c1",
        "fileLink": "https://arweave.net/SrERAlYcB1v8D6ABRkP_QbHfRR6RdKTO3akSghPz3dM"
      },
      {
        "fileName": "2.jpg",
        "fileId": "2e791441-9404-4211-b618-2e580e110a15",
        "fileLink": "https://arweave.net/fsnAIp1VFBMqBhNYsejaI5BqqOuUNat0gnUE2CHevqY"
      },
      {
        "fileName": "3.jpg",
        "fileId": "1c40d120-fe1d-4394-93e3-f9df3bf0f176",
        "fileLink": "https://arweave.net/mSgGn1D_WPudzm0uROiJxegbZ760rhSNI8p5DGiy7hI"
      }
    ]
  }
]

5. Conclusión

En este post aprendimos a subir y compartir archivos manualmente con arDrive, asi como también con su CLI, además a como crear un script personalizado para interactuar con los archivos subidos.

Realmente espero que hayas podido seguirme hasta aquí sin ningún inconveniente, de otra manera me disculpo, por favor puedes dejarme tus dudas y comentarios.

Si deseas enconntrar mas contenido o empleos relacionados a blockchain te recomiendo que entres y te registres en Code&Jobs

Puedes contactarme por telegram en caso de que necesites contratar a un Full Stack Developer.

También te dejo mi usuario de Discord Appu#9136 en caso de que desees agregarme.

Muchas Gracias por tu tiempo.

How to upload files to ardrive manually and with ardrive CLI?

Robert — Wed, 10 Aug 2022 23:04:00 +0000

In the following post I will explaining what is Arweave, how to create a wallet, and also how to upload files manually and with the CLI.

For this example I will be uploading some free images from unsplash.

What is Arweave?.

According to the Arweave website, Arweave is a protocol that allows you to store data permanently, sustainably, with a single upfront fee.

You can think of it as an alternative to IPFS

With Ardrive, we will able to upload and share our files, there is also a fee calculator in case you want to know how much you will pay for the amount of data that you want store.

Prerequisites

Node.js installed
Arweave Wallet
Ardrive CLI installed

Creating Our Project

Open your terminal and type the following commands
mkdir ardrive-tutorial
cd ardrive-tutorial
npm init --y
Open the project with your preferred code editor

Dependencies

To install dependencies go to your project folder open a terminal and type the following.

npm i ardrive-core-js dotenv prompt-sync

We will be using import so open package.json and add the following line "type" : "module".

"type" : "module",
"scripts": {
  "start": "node ./src index.js"
},

Project File Structure

arDrive-tutorial/
├── node_modules/
├── tutorial-images/
├── src/
│   └── index.js
├── .env
└── package.json

Log in to ArDrive
Uploading files to ArDrive
Uploading files with ArDrive CLI
Script to create a .json with files info
Conclusion

1. Log in to ArDrive

This is not difficult to do, assuming that you created your wallet, you just go to Ardrive login page, and log in with your wallet.

The user and password are for private folders.

2. Uploading Files to ArDrive

Remember that all the files will be permanently stored, that means that the files cannot be deleted.

The first thing that we will do is create a new drive by clicking on the New button.

Then set a name and choose between public or private, I am going to choose public.

Then we are going to click the New button again, and this time select "upload folder" because we are going to upload a folder with files in it, like I said before in this example I will be using some free images from unsplash. you can use whatever you want, just make sure that you have the permission to upload the files.

You will also be able to see the price to upload those files, so you can decide if you want to upload them.

Now you will be able to see a new folder in your drive, and if we open it we will be able to see the files in it, also we can download them, get details of each file, a preview link, etc.

3. Uploading files with ArDrive CLI

To get more info about the commands that can be used type ardrive -h or in case you want more usage information about a command ardrive create-drive -h.

Now we are going to repeat the process but using ardrive cli instead, so the first thing that we are going to do is open our terminal and check if the ardrive CLI is installed with this command:

ardrive --version

You should get your ardrive CLI version.

1.19.0

Then we are going to create a new drive, we must specify our wallet location and a name for the new drive, you can also specify if you want it to be a private drive with -p

ardrive create-drive -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> -n cli-tut

You should get an object with information about the drive and the folder like the following one:

{
  "created": [
    {
      "type": "drive",
      "metadataTxId": "0fzTAOPqIK4Imk2xGf3e9CDCXxO_k-xFFlOkAA-IXRg",
      "entityId": "5e219c5e-ed6a-497d-b225-b5d621eed097",
      "bundledIn": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk",
      "entityName": "cli-tut"
    },
    {
      "type": "folder",
      "metadataTxId": "LGeONqTaoiE1m6_OXK2RcmsBZbkN0yxl-AKNUEn4ahs",
      "entityId": "1739f7e2-baa2-491a-a2ab-f406d778041a",
      "bundledIn": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk",
      "entityName": "cli-tut"
    },
    {
      "type": "bundle",
      "bundleTxId": "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk"
    }
  ],
  "tips": [],
  "fees": {
    "GL725mzIbYgisddpaimoxs6lAdN9CjASmhhxqdP3agk": "52221667"
  }
}

Then we are going to upload some files to it, if we want upload them to the root folder we will need to add the entityId of the previous object with "type": "folder", anyways if you open your ardrive and look for the drive that you created you can get the root folder id like this.

We also need the file location, or folder location that we want to upload

ardrive upload-file -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> --local-path <FILE\OR\FOLDER\LOCATION\THAT\WANT\TO\UPLOAD> -F <folder-id>

You will get a message like this:

{
  "created": [
    {
      "type": "folder",
      "entityId": "4de053e3-cf7f-4da6-88bc-e238e7478226",
      "metadataTxId": "rhML7VdZDfm2R1sASWwiCVt-_eeGb38VOFMUOszgvlM",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "entityName": "ardrive-cli-files",
    },
    {
      "type": "file",
      "entityName": "1.jpg",
      "entityId": "6cb92418-bf77-4edd-a271-a4981abb92bc",
      "dataTxId": "8y5PVi1V2WAF4etKv0lgbfx2tO2P_ekDu7PBFjhu4us",
      "metadataTxId": "LD2QI5erLPuvM39ptN0-G9vpLEGh4VXIdglhzS_oHEI",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
    },
    {
      "type": "file",
      "entityName": "2.jpg",
      "entityId": "48c33090-a7e6-47d3-b974-924a09defbb4",
      "dataTxId": "oMEPmy2LIKL0RI2WSfMyT3XEo2aZ86zqDQrEcfteqVo",
      "metadataTxId": "m3cDLllbgTwg4rlKF_FivP5nSHRd7BZ9WIUY31NVlxE",
      "bundledIn": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "sourceUri": "file://C:\\Users\\Rob\\Downloads\\ardrive-cli-files\\2.txt"
    },
    {
      "type": "bundle",
      "bundleTxId": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4"
    }
  ],
  "tips": [
    {
      "recipient": "aVHpFhSorIljeZ9so8unOEnPkW3YqRbqG5cfM4aXxBI",
      "txId": "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4",
      "winston": "10000000"
    }
  ],
  "fees": {
    "CjI3RTkum17KI5GHEiI6dC_gjq1dznylrA4pR5hk0E4": "52221667"
  }
}

So as you can see, a new folder was created, also two files with it.

Now we can download that folder (it will be downloaded in your current console location) with this command:

ardrive download-folder -w <YOUR\WALLET\LOCATION\FOLDER\wallet-file.json> -f <folder-id>

4. Script to create a .json with files info

Now we are going to create a custom script to get files and folder information and finally create a .json file with it that would be helpful for a real life NFT project.

First create a .env file in the root of your project and create a WALLET_PATH variable and add your wallet path like this C:\\YOUR\\WALLET\\PATH.

Then go to src folder and open index.js, copy and paste the following code, don't worry I will explain it step by step.

I am going to use a folder form our previous example, but you can also work for a folder arDrive structure like this.

driveName
├── imagesFolder/ //if we want imagesFolder info then we should provide this folder id
│   ├── folder1/
│   │   ├── 0.jpg
│   │   └── 1.jpg
│   ├── folder2/
│   │   ├── 2.jpg
│   │   └── 3.jpg
│   ├── folder3/
│   │   ├── 4.jpg
│   │   └── 5.jpg
│   ├── folder4/
│   │   ├── 6.jpg
│   │   └── 7.jpg
│   └── folder5/
│       ├── 8.jpg
│       └── 9.jpg
├── metadatasFolder/
└── anotherFolder/

We are going to import {readJWKFile, arDriveFactory} from 'ardrive-core-js'. we'll be able to read our wallet with readJWKFile and use arDrive operations with arDriveFactory.
We are going to create a .json file at the end of our script so we need to use fs.
The script will prompt the user for the folder ID, with the folder ID we can get all folders inside that folder and we can also get the drive ID that will be needed to build the link to the folder.
We need sort the folders in case there are more than one and have a project name e.g. (PROJECT_NAME_1, PROJECT_NAME_2, PROJECT_NAME_3, etc) because probably we won't get them sorted by default.
We will create a const foldersId = [] that will store every folder name and folder id.
Now we will use a for loop to loop through foldersId and will get the files of each folder with .

const getFiles = await arDrive.listPublicFolder({
    folderId: folderId
  })

We will sort those files because we could obtain them unsorted.
Then we are going to create a const filesInformation = [] that will store the information of each one of the files per folder.
After that we are going to use another for loop trough them inside our current loop, So with this approach we will get all the files info from the current folder.
Now we will store the folderName, folderLink, and also the filesInformation (fileName, fileId, and fileLink from the previous loop) and will be stored in a Files array.
Finally we will create a json file and we will write the stored data in Files.

import {readJWKFile, arDriveFactory} from 'ardrive-core-js'
import fs from 'fs'
import dotenv from 'dotenv'
dotenv.config({path: '../.env'})
import ps from "prompt-sync";
const prompt = ps()

//read wallet from file
const myWallet = readJWKFile(process.env.WALLET_PATH)

const arDrive = arDriveFactory({ wallet: myWallet })

const folderID = prompt("insert the folder id ")

const getFolders = await arDrive.listPublicFolder({
  folderId: folderID 
})

const driveId = getFolders[0].driveId

const LINK_TO_FOLDERS = `https://app.ardrive.io/#/drives/${driveId}/folders/`

getFolders.sort((a, b) => {
  return a.name.localeCompare(b.name)
})

const foldersId = []

getFolders.forEach(folder => {
  foldersId.push({
    folderName: folder.name,
    folderId: folder.folderId.entityId
  })
})


const Files = []

for (let i = 0; i < foldersId.length; i++) {
  const folderId = foldersId[i].folderId
  const folderName = foldersId[i].folderName
  const getFiles = await arDrive.listPublicFolder({
    folderId: folderId
  })

  //create an array for eachFoldername
  const filesInformation = []

  // Format here
  getFiles.sort((a, b) => {
    return a.name.localeCompare(b.name)
  })

  for (let j = 0; j < getFiles.length; j++) {
    const file = getFiles[j]
    filesInformation.push({
      fileName: file.name,
      fileId: file.fileId.entityId,
      fileLink:'https://arweave.net/'+file.dataTxId.transactionId
    })


  }

  Files.push({
    folderName,
    folderLink: LINK_TO_FOLDERS + folderId,
    filesInformation
  })

}

fs.writeFileSync(`filesInfo.json`, JSON.stringify(Files))

The final output will be similar to this:

[
  {
    "folderName": "arweave-images",
    "folderLink": "https://app.ardrive.io/#/drives/5791d389-438c-4af5-820f-a2fe0fb782a8/folders/3d124a11-ebb5-4c2e-9d2c-02d6f1700b4b",
    "filesInformation": [
      {
        "fileName": "1.jpg",
        "fileId": "b2ca111f-54c5-4515-b700-e055c3a4e7c1",
        "fileLink": "https://arweave.net/SrERAlYcB1v8D6ABRkP_QbHfRR6RdKTO3akSghPz3dM"
      },
      {
        "fileName": "2.jpg",
        "fileId": "2e791441-9404-4211-b618-2e580e110a15",
        "fileLink": "https://arweave.net/fsnAIp1VFBMqBhNYsejaI5BqqOuUNat0gnUE2CHevqY"
      },
      {
        "fileName": "3.jpg",
        "fileId": "1c40d120-fe1d-4394-93e3-f9df3bf0f176",
        "fileLink": "https://arweave.net/mSgGn1D_WPudzm0uROiJxegbZ760rhSNI8p5DGiy7hI"
      }
    ]
  }
]

5. Conclusion

We have learned how to upload and share files with arDrive manually and with the CLI, also how to create a custom script to interact with the files uploaded.

I really hope you have been able to follow the post without any trouble, otherwise I apologize, please leave me your doubts or comments.

You can contact me by telegram if you need to hire a Full Stack developer.

You can also find me on Discord Appu#9136

Thank you for your time.

Deploy and Verify a Smart Contract to Testnet using Hardhat

Robert — Mon, 08 Aug 2022 21:28:00 +0000

In the following post will be learn how to deploy and verify a smart contract to Rinkeby testnet using hardhat.

NOTE: Rinkeby will be deprecated soon, click here if you want to know more about it, anyways this example can work for any other testnet like Goerli, Kovan, etc.

What is Hardhat?

According to official documentation Hardhat is a development environment for Ethereum software. It consists of different components for editing, compiling, debugging and deploying your smart contracts and dApps, all of which work together to create a complete development environment.

Prerequisites

Node.js installed
Metamask Wallet
Infura API Key
Etherscan Account
Have some Rinkeby funds in your wallet, in case you need some can use this faucet

Creating Our Project

open your terminal and type the following commands
mkdir hardhat-tutorial
cd hardhat-tutorial
npm init --y
Open the project with your preferred code editor

Dependencies

dotenv
hardhat
@nomiclabs/hardhat-etherscan
@nomicfoundation/hardhat-toolbox

To install dependencies go to your project folder and open a terminal and type the following commands:

npm i dotenv

npm i hardhat --save-dev hardhat @nomiclabs/hardhat-etherscan @nomicfoundation/hardhat-toolbox

Now execute the following command

npx hardhat

You can use the JavaScript option for this example.

Project File Structure

hardhat-tutorial/
├── contracts/
├── node_modules/
├── scripts/
├── test/
├── .env
├── hardhat.config.js
└── package.json

Config our .env file
Set Up hardhat.config.js
Creating the contract to deploy
Deploy Script
Deploying and Verifying
Conclusion

1. Config our .env file

Let's create a .env file in case you haven't already and open it.

We will need to set the following variables:

INFURA_API_KEY = your infura API key
METAMASK_ACCOUNT = your metamask account
ETHERSCAN_API_KEY = your etherscan API key

In case you don't know how to get your Metamask account, just follow the following steps:

Open your Metamask browser extension, click on the three dots.

Click on Account details .

Click on Export Private Key.

Finally type your password.

2. Set Up hardhat.config.js

First we need to set up the configuration file, so let's open hardhat.config.js, you will see something similar to this

require("@nomicfoundation/hardhat-toolbox");
require("@nomiclabs/hardhat-etherscan");

module.exports = {
  solidity: "0.8.9",
};

We need to specify the networks we want to use, for this example we are only going to use Rinkeby.

require("@nomicfoundation/hardhat-toolbox");
require("@nomiclabs/hardhat-etherscan");
//dotenv
require("dotenv").config();

module.exports = {
  solidity: "0.8.9",
  networks: {
    rinkeby: {
      url: `https://rinkeby.infura.io/v3/${process.env.INFURA_API_KEY}`,
      accounts: [`${process.env.METAMASK_ACCOUNT}`]
    }
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

3. Creating the contract to deploy

For this example will be using a Dummy contract called Greeter.sol, so let's open it.

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

  import "hardhat/console.sol";

  contract Greeter {
      string public greeting = 'Hello World';

      function setGreeting(string memory _greeting) public {
          console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
          greeting = _greeting;
      }
  }

4. Deploy Script

Go to scripts folder and open deploy.js, delete everything inside.

First let's require ethers from hardhat.
Then we will create a function that will be executed when the script is executed.
we will use ethers.getSigners() to get a object with our ethereum account information .
then we with getContractFactory() we are going to abstract the contract information, in this case of Greeter.sol.
we will deploy that information with deploy().
Finally we wait for the contract to be deployed and get the address of the contract.

const { ethers } = require("hardhat");

async function main(){
  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account: ", deployer.address);

  const DummyContract = await ethers.getContractFactory("Greeter");
  const dummyContract = await DummyContract.deploy();

  await dummyContract.deployed();

  console.log("DummyContract deployed to: ", dummyContract.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  })

5. Deploying and Verifying

Finally we will execute the following commands to deploy and verify our contract.

npx hardhat run scripts/deploy.js --network rinkeby

You will get something similar to this:

DummyContract deployed to:  0x5c2E1BD82EDC0695cbA5AE64dA7aE34f073E167C

Then to verify the contract type the following command:

The address used in the next command will be the value that you previously get from the console.

npx hardhat verify --network rinkeby 0x5c2E1BD82EDC0695cbA5AE64dA7aE34f07

Finally you will get a message similar to this:

Successfully verified contract Greeter on Etherscan
https://rinkeby.etherscan.io/address/0x5c2E1BD82EDC0695cbA5AE64dA7aE34f073E167C#code

Now if you visit that link you will be able to see your contract as well as the code.

6. Conclusion

We learned how to deploy and verify a smart contract using Hardhat.

I really hope you have been able to follow the post without any trouble, otherwise I apologize, please leave me your doubts or comments.

If you're looking for a blockchain dev position, or more content related, you should check codenjobs web

You can also visit the Spanish version of this post

You can contact me by telegram if you need to hire a Full Stack developer.

You can also find me on Discord as Appu#9136

Thank you for your time.

DEV Community: Robert

How to use libvmaf_cuda on Windows: an easy-to-follow guide (WSL2 + Docker + NVIDIA)

Table of contents

The Problem

Prerequisites

Part 1 — Setting up the environment

1.1 Install WSL2

Ubuntu update

1.2 Accessing Windows drives from WSL

1.3 Verify GPU access from WSL

1.4 Install Docker Desktop

Configure WSL2 integration

Verify Docker works in WSL

1.5 Install the NVIDIA Container Toolkit

Install

Configure the Docker runtime

Restart Docker

Verify Docker can see the GPU

Part 2 — Building the easyVmaf image

2.1 Clone the repository

2.2 Critical fix: pin nv-codec-headers

2.3 Build the image

2.4 Verify the libvmaf_cuda filter

Part 3 — Running VMAF with GPU acceleration

3.1 capabilities=video

3.2 Full analysis command

Real-world result

Troubleshooting

var/run/docker.sock: connect: permission denied

Cannot load libnvcuvid.so.1

NV_ENC_CLOCK_TIMESTAMP_SET has no member named 'countingType'

WSL2 hangs after inactivity

Conclusion

References

Let's Connect

How I Fixed My HLS Seeking Lag with One Keyframe Trick (GOP explained)

Introduction

The Problem

What is GOP?

The Fix

What I learned

Conclusion

Construyendo un audio track remover con Node.js, React y FFmpeg

Tabla de Contenido

Introducción

El Problema

Tecnologías

Retos y Soluciones

1. Procesar videos sin subirlos

2. Progreso en tiempo real con SSE

3. Persistencia de selección de pistas por video

4. Procesamiento por lotes con cola

5. Manejo de videos sin pistas de audio

Conclusión

Contacto

I haven't posted in 4 years. Here's what I built: A Local Audio Track Remover with React, Node.js, and FFmpeg

Table of Contents

Introduction

The Problem

Tech Stack

Key Challenges & Solutions

1. Processing Videos Without Uploading

2. Real-time Progress with SSE

3. Each video remembers its own track choices

4. Batch Processing with a Queue

5. Handling Videos with No Audio Tracks

Conclusion

Let's Connect

¿Cómo mintear NFTs en Solana?

Prerrequisitos

Metaplex CLI

Tabla de Contenido

1. Creación de cartera local

2. Agregar saldo a nuestra cartera

1. Crear una cuenta

2. Dirigirnos a la página de wallet

3. Depositar USD o EUR

4. Convertir a SOL

5. Pasaremos la cantidad que convertimos a SOL a nuestra cartera local

3. Subir la imagen que usaremos como NFT

2.4 Verify the `libvmaf_cuda` filter

`var/run/docker.sock: connect: permission denied`

`Cannot load libnvcuvid.so.1`

`NV_ENC_CLOCK_TIMESTAMP_SET has no member named 'countingType'`