DEV Community: tqmvt

Get wallet address for multiple chains in cosmos app chains

tqmvt — Sat, 08 Jun 2024 02:29:01 +0000

In the Cosmos ecosystem, each chain has its own specific prefix for Bech32 addresses. When you connect your Keplr wallet to a Cosmos SDK-based chain, you receive a wallet address specific to that chain. However, the underlying public key remains the same across these chains, and you can derive the addresses for other chains by converting the address prefix.

Here's how you can derive the address for multiple chains using JavaScript, assuming you have the wallet address for one chain:

Extract the Public Key: You need the public key associated with the address. This step typically involves interacting with the Keplr wallet to get the public key.
Convert the Address Prefix: Use the Bech32 encoding library to convert the address prefix to the desired chain's prefix.

Show me the code

Below is an example using JavaScript and the bech32 library to convert an address from the Osmosis chain to the Stargaze chain:

Install the necessary libraries:

npm install @cosmjs/encoding @cosmjs/crypto

JavaScript code to convert the address prefix:

const { Bech32 } = require('@cosmjs/encoding');

/**
 * Converts a Bech32 address to another Bech32 address with a different prefix.
 * @param {string} address - The original Bech32 address.
 * @param {string} newPrefix - The new prefix for the Bech32 address.
 * @returns {string} - The new Bech32 address with the specified prefix.
 */
function convertAddressPrefix(address, newPrefix) {
    const { prefix, data } = Bech32.decode(address);
    return Bech32.encode(newPrefix, data);
}

// Example usage
const osmosisAddress = 'osmo1n3v7hdf3lj6gr7hyluq7x4hj4snmajsze3fnlq';
const stargazePrefix = 'stars';

const stargazeAddress = convertAddressPrefix(osmosisAddress, stargazePrefix);
console.log('Stargaze Address:', stargazeAddress);

This code will convert an Osmosis address to a Stargaze address by changing the Bech32 prefix.

Summary

By extracting the public key from Keplr and using a Bech32 conversion, you can derive addresses for multiple chains in the Cosmos ecosystem. This approach leverages the shared public key across these chains and the flexibility of Bech32 encoding.

Thanks for your time. Happy coding!

Delving into Blockchain (1)

tqmvt — Thu, 23 May 2024 01:48:39 +0000

What is staking

Staking cryptocurrencies is a process that involves buying and setting aside a certain amount of tokens to become an active validating node for the network. By simply holding these coins, the buyer becomes an important piece in the network’s security infrastructure and is compensated accordingly.

Staking income is offered in the form of interest paid to the holder, while rates vary from one network to the other depending on several factors including supply and demand dynamics.

As the number of PoS-based networks continues to grow, new alternatives to stake crypto have emerged including the launch of group staking, also known as staking pools, staking providers, and cold staking.

These initiatives aim to democratize access to opportunities in the staking space to retail investors who hold a small number of tokens of a certain blockchain.

AMM

Automated market makers (AMMs) are part of the decentralized finance (DeFi) ecosystem. They allow digital assets to be traded in a permissionless and automatic way by using liquidity pools rather than a traditional market of buyers and sellers. AMM users supply liquidity pools with crypto tokens, whose prices are determined by a constant mathematical formula. Liquidity pools can be optimized for different purposes, and are proving to be an important instrument in the DeFi ecosystem.

Liquidity Pools and Liquidity Providers

Liquidity refers to how easily one asset can be converted into another asset, often a fiat currency, without affecting its market price. Before AMMs came into play, liquidity was a challenge for decentralized exchanges (DEXs) on Ethereum.
As a new technology with a complicated interface, the number of buyers and sellers was small, which meant it was difficult to find enough people willing to trade on a regular basis. AMMs fix this problem of limited liquidity by creating liquidity pools and offering liquidity providers the incentive to supply these pools with assets. The more assets in a pool and the more liquidity the pool has, the easier trading becomes on decentralized exchanges.

On AMM platforms, instead of trading between buyers and sellers, users trade against a pool of tokens — a liquidity pool. At its core, a liquidity pool is a shared pot of tokens. Users supply liquidity pools with tokens and the price of the tokens in the pool is determined by a mathematical formula. By tweaking the formula, liquidity pools can be optimized for different purposes.

Anyone with an internet connection and in possession of any type of ERC-20 tokens can become a liquidity provider by supplying tokens to an AMM’s liquidity pool. Liquidity providers normally earn a fee for providing tokens to the pool. This fee is paid by traders who interact with the liquidity pool. Recently, liquidity providers have also been able to earn yield in the form of project tokens through what is known as “yield farming.”

Vaults

Sometimes your money belongs in different places. This is why we keep some cash on hand, in a checking account, and in a savings account. Similarly, users have the ability to organize funds into different wallets or store their crypto in a vault.

What is a vault?

A vault can receive cryptocurrency like a normal wallet, but can also prevent stored crypto from being immediately withdrawn by adding optional security steps.

Users can also choose to split ownership between multiple users and email accounts, requiring these users to approve of a transaction before it can be completed.
Vaults also go through a secure approval withdrawal process after creation. Unapproved vault withdrawals will be canceled in 24 hours

DAO

A decentralized autonomous organization (DAO) is an entity with no central leadership. Decisions get made from the bottom-up, governed by a community organized around a specific set of rules enforced on a blockchain.

DAOs are internet-native organizations collectively owned and managed by their members. They have built-in treasuries that are only accessible with the approval of their members. Decisions are made via proposals the group votes on during a specified period.

A DAO works without hierarchical management and can have a large number of purposes. Freelancer networks where contracts pool their funds to pay for software subscriptions, charitable organizations where members approve donations and venture capital firms owned by a group are all possible with these organizations.

Reference

How to use Redis with Vercel Edge

tqmvt — Sun, 23 Apr 2023 13:05:12 +0000

Introduction

Vercel’s Edge Network provides developers with powerful compute capabilities with zero configuration and added latency.

Edge Functions are JavaScript, TypeScript, or WebAssembly functions that are designed to be more efficient and faster than traditional Serverless compute and they are generally available since December 2022.

Redis client for the Edge
Under the hood Vercel Edge uses Cloudflare Workers and the Workers cannot create TCP connections.

Due to this runtime restrictions of Vercel Edge, custom clients are needed to use certain services like Redis.

To overcome this issue we will need to use a Redis http client and a provider that support this funcionality.
Luckily for us Upstash provides both things for us!

If you haven’t already create your Next.js app with: “npx create-next-app@latest — typescript”

npm install @upstash/redis

Create Redis instance
Once installed, you can create a Redis instance with Upstash and obtain the connection URL. This connection URL can then be used in your Vercel Edge Functions to access the Redis instance.

Remember to copy the secrets from Upstash dashboard:

UPSTASH_REDIS_REST_URL
UPSTASH_REDIS_REST_TOKEN

Copy these to your .env and upload them on Vercel as secrets.

Create the Edge Function
https://gist.github.com/gofixgo/67f17cbac15634ea44b950d8a73a820e

import { NextRequest, NextResponse } from "next/server";
import { Redis } from "@upstash/redis";
export const config = {
  runtime: "edge",
};

if (
  !process.env.UPSTASH_REDIS_REST_URL ||
  !process.env.UPSTASH_REDIS_REST_TOKEN
) {
  throw new Error("Missing UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN");
}

// Create a Redis client outside of the function
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
});

export async function middleware(req: NextRequest) {
  const country = req.geo?.country || "fallback";

  // Increment the country counter
  const sameCountryVisits = await redis.incr(country);
  // Increment the total counter
  const totalVisits = await redis.incr("total");


  return NextResponse.json({
    sameCountryVisits,
    totalVisits,
  });
}

Alternatives to Upstash for Edge Functions?
As we mentioned before Edge Functions runs on a runtime where common Redis clients won’t work due to V8 engine restrictions on TCP connections.

This means that you can’t use self hosted Redis or Redislabs unless you use and implement a REST Proxy. Upstash Redis has this REST API built-in by default.

Best Practices for Using Redis with Vercel Edge:
To ensure that Redis performs optimally with Vercel Edge, it is important to follow some best practices.

These include keeping Redis keys and values small to reduce memory usage, setting expiration times on cached data to prevent stale data, and monitoring Redis performance to ensure it can handle the workload.

Additionally, Redis can be used in combination with Vercel Edge cache using: https://github.com/vercel/examples/tree/main/edge-api-routes/cache-control

Conclusion
Using Upstash Redis with Vercel Edge can provide a significant performance boost for your applications. So why not give Redis a try with Vercel Edge and see how it can benefit your application?

Upstash Rest API docs: https://docs.upstash.com/redis/features/restapi

Happy coding!