DEV Community: Volnov Peter

Tutorial: pay for users' gas on NEAR Protocol

Volnov Peter — Tue, 04 Jul 2023 02:38:59 +0000

NEAR Protocol has introduced an exceptional feature since its version 0.17.0: Delegate Transactions. With this feature, you can create and sign a transaction from one account and send it on behalf of another account. Essentially, you pay for the gas for a third-party account.

This tutorial will guide you through creating and executing Delegate Transactions on NEAR Protocol using Python.

Prerequisites:

Familiarity with Python
A NEAR Protocol account
Python NEAR library (py_near)

Step-by-Step Guide

Delegate Transactions are performed in three steps:

Alice creates a delegate_action specifying all the actions, public key, and recipient.
Alice signs delegate_action with her private key and passes it to Bob.
Bob forms a normal transaction from one action - delegate_action, signs it, and sends it to the blockchain. Essentially, Alice's transaction is executed, but Bob pays for the gas.

Creating and Signing a Delegate Transaction

The following Python function creates and signs a delegate transaction. Follow the steps below:

Install the py_near Python library. You can install it via pip:

pip install py_near

Run the following Python code:

from py_near.account import Account
from py_near_primitives import TransferAction
import ed25519

async def create_and_sign_delegate():
    account = Account(
        "alice.near",
        "ed25519::...",
        "https://nrpc.herewallet.app",
    )

    action = await account.create_delegate_action(actions=[TransferAction(1)], receiver_id="bob.near")
    sign = account.sign_delegate_transaction(action)

    account_to_execute = Account(
        "bob.near",
        "ed25519:...",
        "https://nrpc.herewallet.app",
    )
    result = account_to_execute.call_delegate_transaction(
        delegate_action=action,
        signature=sign,
    )
    return result

create_and_sign_delegate()

In this example, we transfer 1 yNEAR from alice.near to bob.near and pay for gas from bob.near balance.

Note: Replace ed25519 public and private keys in the Account objects with your actual account keys. You also need to replace the receiver_id value in the create_delegate_action method with the actual NEAR Protocol account ID where you want to send the transaction.

Warning: Not all RPC support delegate transactions. You can use https://nrpc.herewallet.app for testing.

Executing the Delegate Transaction

To execute the delegate transaction, use the call_delegate_transaction method as in the Python code above. This method requires two parameters:

delegate_action: The DelegateActionModel object you created in the previous step.
signature: The signature of the delegate transaction that you created in the previous step.

You can execute this transaction from any NEAR Protocol account. In the example above, the transaction is executed from the bob.near account.

And that's it! You have successfully created and executed a Delegate Transaction on NEAR Protocol, covering the gas costs on behalf of another user.

Setup IPFS images cache server in 5 min

Volnov Peter — Fri, 19 May 2023 08:34:36 +0000

Introduction

In this tutorial, we will explore the importance of caching images from IPFS (InterPlanetary File System) and demonstrate how to set up a basic IPFS image caching service using the repository called ipfs-cache-server (https://github.com/pvolnov/ipfs-cache-server). Caching images from IPFS can greatly improve performance and reduce bandwidth usage, especially in scenarios where the same images are frequently accessed

Why we need to cache IPFS images?

IPFS is a distributed file system that allows storing and sharing content using cryptographic hashes. While IPFS provides a decentralized and resilient way to store and retrieve files, accessing files directly from IPFS can sometimes introduce performance challenges, especially when dealing with large files or high-demand scenarios. By caching IPFS images, we can alleviate some of these challenges by storing the frequently accessed images closer to the users, reducing the need for repeated network requests.

Lets go

1. Create a folder for image caching:

mkdir /var/www/cache

2. Configure image share via nginx:

Install and configure Nginx to serve the cached images. Add the following Nginx configuration to the appropriate server block in your Nginx configuration file (e.g., /etc/nginx/sites-available/default or /etc/nginx/conf.d/default.conf):

location /ipfs/ {
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header Host $http_host;
    proxy_pass http://127.0.0.1:7001;
}

location /cache/ {
    alias /var/www/cache/;
    expires 30d;
}

In this configuration, requests to /ipfs/ will be proxied to the ipfs-cache-server running on 127.0.0.1:9090, while requests to /cache/ will serve the cached images directly from the /var/www/cache/ directory.

3. Setup cache server

git clone https://github.com/pvolnov/ipfs-cache-server
cd ipfs-cache-server

Open the config.yml file and update the following configuration parameters:

folder_size: The maximum cache size in MB.
cache_folder: The path to the cache folder (default is ./cache).
image_server_prefix: web link to ngnix server to share images from cache folder
max_size: The maximum number of images in the cache folder. Set cache folder path in docker-compose.yml:

5. Add cache folder path

Open the docker-compose.yml file and update the volume mapping to your desired cache folder path:

volumes:
  - /var/www/here-storage/cache:/workdir/cache

6. Run

docker-compose up

How to use

Make all requests via cache server, create url https://<image server>/url?sz=XXX

Example

server-url: https://image.herewallet.app
ipfs url: https://nftstorage.link/ipfs/bafybeieboqph4qqf2n7lasq4ehn6snke2nhdqzde4i4hlywwd3dd7mcjma/U1307.png
ipfs id: nftstorage.link/ipfs/bafybeieboqph4qqf2n7lasq4ehn6snke2nhdqzde4i4hlywwd3dd7mcjma/U1307.png
size: 512*512

Result:
https://image.herewallet.app/nftstorage.link/ipfs/bafybeieboqph4qqf2n7lasq4ehn6snke2nhdqzde4i4hlywwd3dd7mcjma/U1307.png?sz=512

Conclusion:

Caching IPFS images can significantly enhance performance and reduce network overhead when serving frequently accessed images. In this tutorial, we explored the importance of image caching from IPFS and demonstrated how to set.

P.S. Add ⭐️ for https://github.com/pvolnov/ipfs-cache-server