DEV Community: DevMonster

7 common transactions on Stellar and Soroban to explore using Mercury and how to retrieve them

DevMonster — Thu, 28 Dec 2023 22:23:25 +0000

In the following article we will be describing the transactions that we will be exploring using Mercury. We will be using the following transactions:
- Send Payments
- Receive Payments
- Liquidity Pool Deposit
- Liquidity Pool Withdrawal
- Soroswap Add Liquidity
- Soroswap Remove Liquidity
- Soroswap Swap tokens
Some of them are using Stellar Classic, and some of them are in Soroban Network.

We have developed mercury-sdk to facilitate the exploration of the transactions.

In order to work with mercury-sdk you need to create an instance of the Mercury class. You can do it as follows:

import { Mercury } from "mercury-sdk";

const mercuryInstance = new Mercury({
  backendEndpoint: process.env.MERCURY_BACKEND_ENDPOINT,
  graphqlEndpoint: process.env.MERCURY_GRAPHQL_ENDPOINT,
  email: process.env.MERCURY_TESTER_EMAIL,
  password: process.env.MERCURY_TESTER_PASSWORD,
});

Payments

Sent and received payments are the most common transactions in Stellar. They are used to send and receive assets between accounts.
You can retrieve the information as:

import { 
    getSentPaymentsParser, 
    getReceivedPaymentsParser,
     } from "mercury-sdk";
async function someFunction() {
  //Sent payments
  const sentPaymentsResponse = await mercuryInstance.getSentPayments({
    publicKey: "someStellarAddress",
  });

  if (sentPaymentsResponse.ok) {
    const sentPaymentsParsedData = getSentPaymentsParser(
      sentPaymentsResponse.data!
    );
    console.log(sentPaymentsParsedData);
  }

  //Received payments
  const receivedPaymentsResponse = await mercuryInstance.getReceivedPayments({
    publicKey: "someStellarAddress",
  });

  if (receivedPaymentsResponse.ok) {
    const receivedPaymentsParsedData = getReceivedPaymentsParser(
      receivedPaymentsResponse.data!
    );
    console.log(receivedPaymentsParsedData);
  }
}

example response:

[
  {
    "from": "GCQF7MWR7QO2QKD7F72WG2H5L3TBE53DN67OYBXQEDEWIYOSYVP5D7CJ",
    "to": "GD3PVP6AYFOVWXYFYTX7JM7WMYPKINCTUXZNXOYKAO5U2AUARARDDM45",
    "amount": "10000000000",
    "assetNative": false,
    "asset": "PALTA:GDA7K7I3XGH5HKUH5NYFYY3JBKUAJ3DSGLVGJHBDLUTKCUYVMUOVR2ZM",
    "ledger": 162443,
    "timestamp": 1703774254
  },
  {
    "from": "GCQF7MWR7QO2QKD7F72WG2H5L3TBE53DN67OYBXQEDEWIYOSYVP5D7CJ",
    "to": "GD3PVP6AYFOVWXYFYTX7JM7WMYPKINCTUXZNXOYKAO5U2AUARARDDM45",
    "amount": "10000000000",
    "assetNative": true,
    "ledger": 162444,
    "timestamp": 1703774259
  }
]

receivedPaymentsParsedData
[
  {
    "from": "GDA7K7I3XGH5HKUH5NYFYY3JBKUAJ3DSGLVGJHBDLUTKCUYVMUOVR2ZM",
    "to": "GCQF7MWR7QO2QKD7F72WG2H5L3TBE53DN67OYBXQEDEWIYOSYVP5D7CJ",
    "amount": "1000000000000",
    "assetNative": false,
    "asset": "PALTA:GDA7K7I3XGH5HKUH5NYFYY3JBKUAJ3DSGLVGJHBDLUTKCUYVMUOVR2ZM",
    "ledger": 162440,
    "timestamp": 1703774238
  }
]

Liquidity Pool Operations

Deposit and Withdrawal operations are used to add and remove liquidity from a liquidity pool. These operations are used in the built-in Stellar AMM.

Example code:

  //Liquidity Pool Withdraw
  const liquidityPoolWithdrawResponse =
    await mercuryInstance.getLiquidityPoolWithdraw({
      publicKey: "someStellarAddress",
    });

  if (liquidityPoolWithdrawResponse.ok) {
    const liquidityPoolWithdrawParsedData = getLiquidityPoolWithdrawParser(
      liquidityPoolWithdrawResponse.data!
    );
  }

  //Liquidity Pool Deposit
  const liquidityPoolDepositResponse =
    await mercuryInstance.getLiquidityPoolDeposit({
      publicKey: "someStellarAddress",
    });

  if (liquidityPoolDepositResponse.ok) {
    const liquidityPoolDepositParsedData = getLiquidityPoolDepositParser(
      liquidityPoolDepositResponse.data!
    );
  }

example response:

liquidityPoolWithdrawParsedData
[
  {
    "source": 402241,
    "poolId": "\\xc7403b2778be92e967f714a6cbff8181a4ec993ff2a3538a4114744150c4a72a",
    "amount": "1000000000",
    "ledger": 162449,
    "timestamp": 1703774286
  }
]

liquidityPoolDepositParsedData
[
  {
    "source": 402238,
    "poolId": "\\xc7403b2778be92e967f714a6cbff8181a4ec993ff2a3538a4114744150c4a72a",
    "maxAmountA": "20000000000",
    "maxAmountB": "10000000000",
    "minPriceN": 9,
    "minPriceD": 5,
    "maxPriceN": 11,
    "maxPriceD": 5,
    "ledger": 162446,
    "timestamp": 1703774270
  }
]

Soroswap Operations

Soroswap operations are used to add and remove liquidity from a liquidity pool, and to swap tokens. These operations are used in the Soroswap AMM. Which is different from the built-in Stellar AMM. Because in Soroswap there will be tokens that are not Stellar Assets.

When doing swaps, instead of the pair of asset we have the path of the swap. The path is the sequence of assets that the swap will go through.

Example code:

  const getContractEventsRes = await mercuryInstance.getContractEvents({
    contractId: routerContractAddress,
  });
  const parsedContractEvents = getContractEventsParser(getContractEventsRes.data!);
  const eventByPublicKey = parsedContractEvents.filter((event) => event.to === publicKey);

example response:

[
  {
    "amount_a": "2000000",
    "amount_b": "2000000",
    "liquidity": "1999000",
    "pair": "CAMCPA2QDCC2K3DJOSRKRGQXETHQND7KK46VOEW3YLL5OP7BDXNB37YF",
    "to": "GBDJYBFPYUY7XXI5XCT473VJRT7PRGMRA2AJ2TKUKGPLJ5ZGVPJYKEAR",
    "token_a": "CBKZMWGE7E3VDJRCHRNLAHKYL2JMCC4METUJA262WXKN2SANJXVQYE3N",
    "token_b": "CCFB3TPPJHDLDYRTPJEFYJ37FOVASDCIZEJ3DYKOFUQO4WJHHZ7SML2D",
    "topic1": "SoroswapRouter",
    "topic2": "add"
  },
  {
    "amounts": [
      "100000",
      "94965"
    ],
    "path": [
      "CBKZMWGE7E3VDJRCHRNLAHKYL2JMCC4METUJA262WXKN2SANJXVQYE3N",
      "CCFB3TPPJHDLDYRTPJEFYJ37FOVASDCIZEJ3DYKOFUQO4WJHHZ7SML2D"
    ],
    "to": "GBDJYBFPYUY7XXI5XCT473VJRT7PRGMRA2AJ2TKUKGPLJ5ZGVPJYKEAR",
    "topic1": "SoroswapRouter",
    "topic2": "swap"
  },
  {
    "amount_a": "105",
    "amount_b": "95",
    "liquidity": "100",
    "pair": "CAMCPA2QDCC2K3DJOSRKRGQXETHQND7KK46VOEW3YLL5OP7BDXNB37YF",
    "to": "GBDJYBFPYUY7XXI5XCT473VJRT7PRGMRA2AJ2TKUKGPLJ5ZGVPJYKEAR",
    "token_a": "CBKZMWGE7E3VDJRCHRNLAHKYL2JMCC4METUJA262WXKN2SANJXVQYE3N",
    "token_b": "CCFB3TPPJHDLDYRTPJEFYJ37FOVASDCIZEJ3DYKOFUQO4WJHHZ7SML2D",
    "topic1": "SoroswapRouter",
    "topic2": "remove"
  }
]

The complete code can be checked on https://github.com/paltalabs/mercury-client/blob/main/scripts/mercurySdkTester/retrieve7txs.ts

Deploying a Soroban Contract from a .wasm File using js-stellar-sdk

DevMonster — Thu, 14 Dec 2023 20:06:00 +0000

Soroban is a blockchain platform that allows developers to build and deploy smart contracts. In this article, we will explore how to deploy a Soroban contract from a .wasm file using typescript.

In this example we will deploy a token contract

Prerequisites

Before we begin, make sure you have the following:

Node.js installed on your machine
You have installed stellar-sdk
You have a .wasm file containing the contract code

Understanding the Code

The code provided consists of two functions: uploadTokenContractWasm and createTokenContract. Because we need to upload the wasm code before we can create the contract, we will first look at the uploadTokenContractWasm function.

The createTokenContract function work as follow: It reads the .wasm file, calculates the hash of the wasm code, and creates a custom contract operation. It then builds and submits a transaction to create the contract.

Deploying the Soroban Contract

To deploy a Soroban contract from a .wasm file, follow these steps:

Import the necessary modules and dependencies:

import fs from 'fs';
import sdk from 'stellar-sdk';
import axios from 'axios';

Define the uploadTokenContractWasm function:

export async function uploadTokenContractWasm(signer) {
  const wasmBuffer = fs.readFileSync("/path/to/soroban_token_contract.optimized.wasm");
  const hf = sdk.xdr.HostFunction.hostFunctionTypeUploadContractWasm(wasmBuffer);
  const op = sdk.Operation.uploadContractWasm({ wasm: wasmBuffer });
  // ... continue with the transaction building and submission
}

Define the createTokenContract function:

export async function createTokenContract(signer) {
  const wasmBuffer = fs.readFileSync("/path/to/soroban_token_contract.optimized.wasm");
  const hash = sdk.hash(wasmBuffer);
  const op = sdk.Operation.createCustomContract({
    address: new sdk.Address(signer.publicKey),
    wasmHash: hash,
  });
  // ... continue with the transaction building and submission
}

Replace /path/to/soroban_token_contract.optimized.wasm with the actual path to your .wasm file.
Build and submit the transaction:

const source = await sorobanServer.getAccount(signer.publicKey);
const sourceKeypair = sdk.Keypair.fromSecret(signer.privateKey);

let tx = new sdk.TransactionBuilder(source, { fee: sdk.BASE_FEE })
  .setNetworkPassphrase(sdk.Networks.TESTNET)
  .setTimeout(30)
  .addOperation(op)
  .build();

try {
  const preparedTransaction = await sorobanServer.prepareTransaction(tx);
  preparedTransaction.sign(sourceKeypair);
  const submitTransactionResponse = await sorobanServer.sendTransaction(preparedTransaction);
  return submitTransactionResponse;
} catch (error) {
  // Handle error cases
}

Replace sorobanServer with the appropriate Soroban server instance.
Run the desired function to deploy the contract:

const signer = {
  publicKey: 'YOUR_PUBLIC_KEY',
  privateKey: 'YOUR_PRIVATE_KEY',
};

await uploadTokenContractWasm(signer);
// or
await createTokenContract(signer);

Replace 'YOUR_PUBLIC_KEY' and 'YOUR_PRIVATE_KEY' with your Soroban account's public and private keys.
You will need to initialize it afterwards

Conclusion

Deploying a Soroban contract from a .wasm file is a straightforward process. By utilizing the provided code and following the steps outlined in this article, you can easily deploy your own Soroban contracts and leverage the power of blockchain technology.

Remember to handle any potential errors and customize the code according to your specific requirements. Happy coding!

Collaboration with Mercury and SubQuery

DevMonster — Tue, 31 Oct 2023 18:41:22 +0000

This article outlines the outcomes and walkthroughs of our collaborative projects with Mercury and SubQuery indexers. We aim to achieve two primary objectives:

Introduce developers from the Stellar and Soroban ecosystems to the capabilities of indexer services.
Assist indexers in refining their offerings by reporting bugs and providing documentation feedback we've uncovered through our usage.

The Importance of Indexers in Blockchain Ecosystems

Utilizing indexers is crucial for efficient data retrieval, thereby enabling developers to offer a seamless user experience. Although blockchains inherently ensure transactional integrity, extracting an entire history directly from a node is computationally intensive. Therefore, indexers serve as invaluable tools. This article serves two main goals:

Demonstrate practical uses of the indexer as an example or initial repository.
Test various indexer solutions, offering constructive feedback on bugs and documentation.

Mercury: Subscription-Based Indexing Solutions

Mercury offers a subscription-based indexing service equipped with numerous features such as alert systems and code execution environments. As a fully managed service, Mercury obviates the need for developers to manage any GraphQL service themselves.

In our repository, you'll find a Node.js client pre-configured with queries to inspect a specific contract, specified through the repository's environment variables.

Getting Started with Mercury

Prerequisites: Docker installation on your machine

Clone the repository: https://github.com/paltalabs/mercury-client.git
Duplicate .env.example as .env
Request Mercury access here
Populate the MERCURY_ACCESS_TOKEN in .env. For usage exceeding 7 days, also complete MERCURY_TESTER_EMAIL and MERCURY_TESTER_PASSWORD.
Update CONTRACT_ADDRESS if you are interested in a contract other than the Soroswap's Factory contract.
Run the container (Node 18.8.2): bash run.sh
Install dependencies: yarn

Use predefined scripts to interact with the contract:

node scripts/subscribeToEntries.js
node scripts/getAllEntriesForContract.js
node scripts/getEntrySubscriptions.js
node scripts/getEventSubscriptions.js

SubQuery: Versatile Indexing for Multiple Platforms

SubQuery is a comprehensive indexer that interfaces seamlessly with multiple blockchain platforms, including Stellar and Soroban. We've developed a customized SubQuery project capable of IPFS deployment and management through SubQuery's Managed Service.

However, storing blockchain history requires access to an archive node, which can be a limitation. While several projects are developing Soroban-compatible archive nodes, none are publicly available yet.

Getting Started with SubQuery

Requirements: Docker

Our setup incorporates Docker inside a Node.js image to manage the required Node.js version and to prevent the need for a global subql package installation. If you prefer to install node, docker and subql locally you can start from step 4.

Clone repository: https://github.com/paltalabs/subquery-sandbox.git
Run the container: bash run.sh

Install Docker and SubQuery:

bash install_docker.sh
bash setup_subquery.sh

Navigate to subql-starter directory and execute:
```
yarn
dockerd &
```
In another terminal
```
bash connect.sh
```
and (if you prefer to install node, docker and subql locally you can start from here)
```
cd subql-starter
yarn codegen
yarn build
yarn start:docker
```
Begin querying by navigating to http://localhost:3000/graphql
To publish your project to IPFS, run:
```
cd subql-starter
subql publish
```

Conclusion

We've demonstrated how to leverage both Mercury and SubQuery indexers, reporting bugs and providing documentation feedback along the way. Each service offers unique approaches to solving data availability issues. While SubQuery provides a more mature and UI-rich solution, its requirement for an archive node adds complexity. Mercury, however, simplifies the process by only requiring subscriptions and queries, thereby eliminating the need to manage additional infrastructure.

New Partnerships Unveiled: SubQuery and Mercury

DevMonster — Tue, 31 Oct 2023 18:40:12 +0000

In a previous update, we explored the prospect of forming partnerships with ten different entities within the Stellar ecosystem. Today, we're thrilled to announce our collaborations with two standout partners: SubQuery and Mercury. We'll also provide an in-depth look at the specialized code we're crafting for each partnership.

Among the ten potential partners we considered, the list included indexers, wallets, decentralized protocols, interoperability protocols, and educational content providers. Although each of these options presented a valuable opportunity to enrich the Stellar ecosystem, we have identified SubQuery and Mercury as the partners that most align with Soroswap's immediate objectives.

While SubQuery and Mercury both serve as indexers, they operate differently, which makes each uniquely valuable to us.

First Partnership: SubQuery

Our inaugural partnership is with SubQuery, a multifaceted indexer that works closely with various blockchain platforms, including Stellar and Soroban. SubQuery's user-friendly interface simplifies production deployments.

SubQuery provides a comprehensive solution for project configuration and its IPFS publishing feature promotes a more decentralized pipeline. However, to access the information we need, we are required to either rent or set up a private RPC, since public RPCs have usage restrictions and a SubQuery project tends to exceed those.

In specific terms, we're developing software that customizes the SubQuery project to efficiently pull information related to Smart Contracts. This software will be deployable to IPFS, enabling its use on SubQuery's Managed Service.

Second Partnership: Mercury

Our second alliance is with Mercury, a subscription-based indexer offering cost-effective and efficient solutions. Mercury comes equipped with various tools, including an alert system and a code execution environment that benefit from direct access to our database.

Mercury's API is readily available; you simply request an API key and begin querying their endpoints for information. Given its subscription-based model, it's crucial to know upfront what data you need to extract from Soroswap's Smart Contracts since Mercury only stores data once you've subscribed to a specific data type.

In the coming days, we'll be sharing code for a client built on Node.js, using Axios to both subscribe to contracts and query Mercury's endpoints for state changes in contracts.

Soroswap: Bridging Wallets, Indexing, and Decentralized Protocols

DevMonster — Tue, 17 Oct 2023 13:47:05 +0000

In the article that follows, we'll explore 10 potential collaborations that could emerge from this SCF initiative, either presently or down the line.

We work with indexing solutions like SubQuery and Mercury, which offer quick access to blockchain data without having to trawl through the entire transaction history. Our focus is on speedy, easy-to-digest information to identify optimal trading routes for users. We're actively contributing to their development by offering constructive feedback.

Additionally, we may partner with wallet services like Meru, Beans App, CashAbroad, and Decaf. These platforms might be interested in allowing their users to hold various assets in the Soroban ecosystem or to open savings accounts via liquidity provision in the Soroswap protocol. Our role is to develop software that these wallets can easily integrate into their existing operations.

Slender and SStream, both decentralized protocols, aim to innovate financial transactions in unique ways. Slender, built on the Soroban framework, focuses on peer-to-peer lending with fluctuating interest rates dictated by market conditions. It could also expand its utility by allowing users to use LP tokens from Soroswap as collateral or enable token conversions post-borrowing. Similarly, SStream, designed for continuous payment streams, could allow immediate token conversion using Soroswap. Both platforms could benefit from a SDK for seamless front-end integration and/or immediate utilization of Soroswap post-contract interactions.

Axelar is focused on enabling interoperability between different blockchains. They have expressed interest in integrating with our platform as a way to introduce new users from other networks to Soroswap.

For Haciendo Stellar, our best collaborative approach involves crafting educational content about Soroswap and Soroban, specifically tailored for the Spanish-speaking audience, as we have several native Spanish-speaking developers at Paltalabs.