DEV Community: Soroswap.Finance

Step-by-Step Guide to Perform a Token Swap on Soroswap.Finance

Jenny T. — Tue, 17 Sep 2024 12:48:25 +0000

Here's a detailed, step-by-step guide on how to perform a token swap on Soroswap.Finance, tailored for new users. This guide will walk you through the process, from setting up your wallet to completing the token swap, with helpful tips and essential precautions to ensure a smooth experience.

Follow the steps below to perform a swap:

Step 1: Access Soroswap:

Go to the official soroswap.finance website.

Click the “Launch App” button on the homepage to start interacting with Soroswap’s decentralized platform. This will take you to the swap interface.

Step 2: Connect your wallet with Soroswap.Finance

Choose a Stellar Wallet: Select a wallet compatible with the Stellar network. For further guidance, you can check out this helpful article: Guide to Choosing a Stellar Wallet.

2.Acquire Stellar (XLM): Purchase XLM from a reputable exchange or transfer it from another wallet if you already own some.

3.Deposit XLM into Your Wallet: Transfer the XLM to your new Stellar wallet address

If this is your first time, you will need to acquire Stellar (XLM) and transfer it to your wallet.

Step 3: Navigate the Soroswap Finance Interface

Once your Stellar wallet is connected, familiarize yourself with the Soroswap dashboard. It displays your account details, token balances, and options for swapping tokens and managing your assets.

Step 4: Executing a Token Swap

1.Select Tokens: Choose the tokens you want to swap from and to.

2.Enter Amount: Specify the amount of tokens you want to exchange.

Step 5: Trustlines

When swapping a new token for the first time on Soroswap.Finance, you’ll need to sign a "trustline" transaction. Trustlines authorize your account to hold and exchange a specific asset.

1.Transaction Request: A transaction request is sent to authorize your wallet to hold and trade the new token.

2.Sign the Trustline Transaction: Once the transaction is signed, the trustline is successfully authorized, enabling your wallet to hold and manage the new asset.

For more information, refer to the official documentation on trustlines.

Step 6: Confirming the Transaction

Sign the Transaction: Approve the transaction to finalize the swap.

Congratulations! You have successfully completed a swap on Soroswap.Finance Now.

Step Step 7: Check That Your Transaction Went Through

After signing the transaction, it's important to confirm that everything went smoothly. To do this, check the details in your wallet or by using one of the blockchain explorers. This step ensures that the token swap has been completed and that the new tokens are now visible in your balance.

Once the transaction is confirmed, you’ll see a success message indicating the swap is complete. At this point, you can review the transaction details by selecting one of these options:

View in Stellar.Expert
View in StellarChain

By following this step, you can be sure the swap has successfully processed and that your wallet reflects the correct balance.

Best Practices

Sufficient XLM for Fees: Ensure you have enough XLM in your wallet to cover transaction fees.
Review Trustlines: Confirm that all necessary trustlines are set up before performing a swap.
Check Transaction History: Verify in your wallet that the swap has been completed and the new tokens are reflected in your balance.

This guide aims to provide clear and simple instructions to help you successfully complete your first token swap on Soroswap.Finance. Remember, handling digital assets responsibly is crucial for maintaining the security of your investments.

Official Website: Soroswap.Finance
Twitter: @SoroswapFinance
GitHub: Soroswap
Documentation: docs.soroswap.finance

Guide to Choosing Wallet for the Stellar Network

Jenny T. — Wed, 11 Sep 2024 16:46:22 +0000

Introduction

Before you can start using Soroswap.Finance 🪐, the decentralized exchange on the Soroban blockchain, you'll need to set up a wallet for Stellar Lumens (XLM). A Stellar Lumens wallet is essential for storing and sending XLM. In this article, you'll learn about the importance of a Stellar Lumens wallet, the types available, our recommended choices, and more.

User Interface

Wallets on the Stellar network come in several forms:

Mobile Wallets:
Offer convenience and accessibility. Ideal for users who need access on the go.
Browser Extensions:
Facilitate quick transactions and are easy to integrate with web services.
Desktop Wallets:
Provide robust security features and are suitable for handling larger amounts or for more frequent trading.
Security

Security

Key security features to consider include:

Private Key Management: Ensuring that the wallet gives you full control over your private keys.
Encryption: Strong encryption standards to protect your data.
Backup & Recovery: Options available for backing up and recovering your wallet.

Popular Wallet Options for Stellar

Freighter Wallet

Description: A browser extension wallet designed specifically for the Stellar network.
Key Features: Integrates seamlessly with web applications, supports multiple Stellar accounts.
Recommended Use Cases: Best for users who frequently interact with Stellar-based web applications. Installation Guide: For a step-by-step tutorial on how to install and set up Freighter Wallet.

XBull Wallet

Description: A comprehensive wallet offering both mobile and desktop versions.
Key Features: Support for multiple assets, built-in exchange features, and high-level security measures.
Recommended Use Cases: Suitable for users looking for a versatile wallet that supports frequent trading and investment.

Lobstr Wallet

Description: Popular among Stellar users for its user-friendly mobile app.
Key Features: Social features for sending and receiving payments, strong security protocols.
Recommended Use Cases: Ideal for everyday users needing a simple and secure way to manage and transact with Stellar Lumens and other tokens.

Hana Wallet

Description: Is a mobile wallet known for its simplicity and effectiveness, designed specifically for managing Stellar assets on the go.
Key Features: Minimalistic design, ease of use, focus on user privacy.
Recommended Use Cases: Great for new users of the Stellar network who prefer a straightforward and secure wallet.

Factors to Consider

Security and Privacy

Assess the wallet’s security track record and read reviews about its reliability and privacy protections.

Ease of Use

The wallet interface should be intuitive, making it easy for you to manage your assets and transactions without confusion.

Compatibility

Consider how well the wallet integrates with other platforms and applications, including exchanges and other blockchain services.

Further Research

Before making a final decision, visit official wallet websites, read user reviews, and check out community feedback on forums like Discord or Stellar community channels. Understanding the experiences of other users can provide valuable insights into the reliability and efficiency of a wallet.

Choosing the right Stellar wallet will enhance your experience and ensure that your assets are secure and easily manageable. Take the time to evaluate each option based on these criteria to find the best fit for your needs.

Bridging Stellar with Allbridge Core on Soroswap: New Possibilities Unveiled

coderipper — Wed, 15 May 2024 14:38:10 +0000

Introduction

Our journey into blockchain interoperability has reached an exciting milestone. We've successfully created a proof-of-concept script that utilizes Allbridge Core to bridge assets between Stellar's Soroban and other blockchains like Binance Smart Chain (BSC). This development not only enhances Soroswap's capabilities but also aligns with future advancements in the blockchain ecosystem, paving the way for seamless asset transfers and improved user experience.

Advancing with Allbridge Core

Previously, we explored Allbridge Classic to bridge Stellar with other blockchains. However, with the advent of Allbridge Core, featuring full support for Soroban, our approach has evolved. Allbridge Core offers advanced bridging capabilities, enabling seamless asset transfers across multiple networks. This upgrade is crucial for maintaining the efficiency and reliability of our platform as we continue to innovate and grow.

Our New Integration

The latest script showcases how to bridge USDT and USDC between Soroban and BSC. This integration demonstrates our capability to leverage Allbridge Core's features effectively. Key components of this integration include:

SDK Initialization: Setting up Allbridge Core SDK with custom RPC URLs for supported blockchains.
Chain and Token Details: Retrieving information about supported chains and tokens, focusing on BSC and Soroban.
Transaction Execution: Bridging assets between BSC and Soroban, with robust error handling and transaction confirmations.

Proof of Concept

This proof-of-concept script successfully demonstrates the bridging of 1 USDC from Soroban to 1 USDT on BSC, and vice versa. Here’s an overview of the process:

Bridging from Soroban to BSC:
- Initializes the transaction parameters.
- Executes the transaction, handles potential errors, and confirms the transaction on the blockchain.
Bridging from BSC to Soroban:
- Sets up the necessary permissions and allowances.
- Executes the bridge, confirms the transaction, and ensures trust lines on Soroban.

The script also includes error handling and transaction confirmations to ensure reliability and consistency, which are critical for maintaining user trust and platform stability.

Detailed Script Overview

For those interested in the technical specifics, here is a brief overview of the script components:

SDK Initialization: The Allbridge Core SDK is initialized with custom RPC URLs for supported blockchains, including BSC and Soroban.
Token Details Retrieval: Detailed information about the supported chains and tokens is retrieved, with a focus on BSC and Soroban.
Bridging Operations: The script handles the bridging of tokens, including setting up trust lines on Soroban when needed. It manages errors and confirms transactions across chains to ensure reliability.
Monitoring and Testing: The script includes functionality for monitoring transaction statuses and testing the bridging process, ensuring that each step is executed correctly.

The full implementation is available in our GitHub repository, inviting the community to explore, collaborate, and contribute to our ongoing efforts.

Future Prospects

While immediate implementation of Allbridge Core in Soroswap is not planned, this proof-of-concept lays the groundwork for future integration. As the blockchain landscape continues to evolve, we are committed to exploring and adopting cutting-edge technologies to enhance our platform's capabilities. This strategic patience allows us to align with the most advanced and supported technologies, ensuring our initiatives are future-proof.

Our exploration of Allbridge Core with Soroban marks a significant step forward in our interoperability efforts. As we continue to refine and expand our capabilities, we remain excited about the future possibilities this technology brings to Soroswap and the broader blockchain ecosystem.

Conclusion

The integration of Allbridge Core with Soroban represents a significant advancement in our quest for blockchain interoperability. By leveraging the latest features of Allbridge Core, we can now bridge assets between Soroban and other blockchains like BSC more efficiently and reliably. This development not only enhances Soroswap's capabilities but also sets the stage for future innovations in the blockchain space. We invite the community to join us in this exciting journey, exploring the vast potential of blockchain technology together.

For more details, check out our GitHub repository, and stay tuned for future updates as we continue to push the boundaries of what's possible in blockchain interoperability.

Costs, DoS Risks, and Instance vs Persistent Data Types in Soroban

esteblock — Fri, 19 Jan 2024 19:45:30 +0000

In the development journey of the Soroswap.Finance protocol, critical decisions regarding data types for Smart Contracts were made. The choice of storage impacts the risk of Denial of Service (DoS), increases contract interaction costs, or introduces both risks simultaneously.

This article explores the advantages and drawbacks of four design patterns for storing an increasing amount of information on the Soroban blockchain. Additionally, it delves into the associated costs for each scenario.

Context: Soroswap.Finance is an Automated Market Maker in the Soroban Smart Contract Platform within the Stellar Blockchain, developed by the PaltaLabs 🥑 team.

Follow the code here: Instance-Persistent-Dos-Soroban

TLDR;

This article demonstrates that:

Instance data types share a common Ledger Entry, leading to contract failure if the total stored information reaches 64kb.
Instance storage Ledger Entry is independent of contract size, with a fixed 64kb reserved regardless of contract dimensions.
Instance data types are read on every interaction, making any contract interaction more costly.
Unbounded data storage in Vectors or Mappings risks reaching 64kb and becoming vulnerable to DoS attacks.
The variable DataKey technique is the recommended approach for storing unbounded data.

Instance and Persistent Data Types.

From Soroban documentation, we know that:

Instance storage has its data limit determined by the ledger entry size (Source).
All instance storage is kept in a single contract instance LedgerEntry with a 64kb size (Source).
The Ledger Entry Size is capped at 64kb (Source).

The Challenge: Store Unbounded Information

The example challenge involves creating a Smart Contract that stores two collections of an increasing amount of 32-byte addresses, representing buyers and sellers. Two separate collections are used, as the choice of data type can impact one collection when the other grows.

Externally, interactions with this contract are intended to follow this pattern for each collection:

Call a function to store a new address (number n).
Retrieve the address for a given number n.

Indeed, tests for each design are the same, and they all pass! So be aware dev, passing your test does not means that your code is safe!

In the following sections, four design patterns will be explained, with only one proving to be DoS-free and not increasing the cost of interacting with the contract.

Design 1: Store a Vector in an Instance Data Type. The Case of a Light Smart Contract.

With this technique, a vector is stored in an instance storage slot. Each time a new element is pushed, the current vector value is read, the new element is added, and the updated vector is written back to the same instance storage slot. The code looks like this:

let mut vector: Vec<Address> = env.storage().instance()
            .get(&VECTOR_A).unwrap_or(Vec::new(&env)); // If no value set, assume an empty vector.

// Push the current contract address in the vector
vector.push_back(env.current_contract_address().clone());

// Save the updated vector to instance storage
env.storage().instance().set(&VECTOR_A, &vector);

A DoS attack simulation reveals that this design causes the contract to fail with a ResourceLimitExceeded error after the sum of the collections reaches 64kb, equivalent to 818 pushes of addresses on each collection. Further details, including code, simulation, and results, can be found in the repository. Additionally, this design increases the cost of every call to the smart contract, even for unrelated functions.

Design 2: Store a Vector in an Instance Data Type.. The Case of a Heavy Smart Contract.

Similar to Design 1, this approach demonstrates that instance storage is stored in an independent LedgerEntry from the Smart Contract itself. With this design, the cost of reading the contract increases with every push operation, even for unrelated functions. This design also results in a ResourceLimitExceeded error.

Design 3: Store a Vector in a Persistent Data Type..

This design involves storing a vector in a persistent data type.

let mut vector: Vec<Address> = env.storage().persistent()
            .get(&VECTOR_A).unwrap_or(Vec::new(&env)); // If no value set, assume an empty vector.
vector.push_back(env.current_contract_address().clone());
env.storage().persistent().set(&VECTOR_A, &vector);

While it avoids sharing storage size with other variables, it is still limited to 64kb of information. Details of an attack simulation show that it allows reaching twice the number of entries compared to the previous examples. However, the cost of reading the contract does not increase for unrelated functions, as persistent data type is not retrieved every time the contract is called.

Design 4: Use Variable DataKeys with Persistent Data Type..

This design introduces the Variable DataKey technique, where the name of the storage slot depends on a parameter. The DataKey is defined as follows:

#[contracttype]
pub enum DataKey {
    StoredAddressesA(u32),
}

This technique is commonly used to store an increasing amount of data, as seen in the token contract for storing user balances. The information is stored as follows:

let mut count: u32 = env.storage().instance().get(&COUNTER_A).unwrap_or(0); 
env.storage().persistent().set(&DataKey::StoredAddressesA(count), &env.current_contract_address().clone());
count += 1;
env.storage().persistent().set(&COUNTER_A, &count);

This design, including the storage of a COUNTER to track the number of stored addresses, is considered the best option. It successfully avoids DoS attacks and minimizes the cost of reading the contract.

Using u32 provides 2^32 different storage slots for StoredAddressA, which is more than sufficient. Even if an attacker were to call the push function 2^32 times, the associated cost is calculated to be around 439,289 stroops (0.044 XLM). This cost limitation makes it practically infeasible for an attacker, even with the entire Total Supply of XLM (50,001,787,051), to add more than 2,196,523,503 entries (2^21).

Design 5: Use Variable DataKeys with Instance Data Type.

Lastly, using Variable DataKeys as a solution with instance data type is a mistake. This design is as inefficient as using a vector because storing in different slots shared in a single Ledger Entry is almost equivalent to storing everything in one slot, similar to a vector. This situation can lead to a DoS attack and result in a ResourceLimitExceeded error.

Contact us:

Did you like the article? Contact us in our Discord https://discord.gg/HFkBquZNNg or reach us in https://paltalabs.io

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!

Installing Freighter

esteblock — Wed, 15 Nov 2023 22:16:32 +0000

1. Installing Freighter

In this section, we will guide you through the installation process of Freighter, a non-custodial Stellar wallet extension that will empower you to engage with Soroswap.Finance

Step 1: Installing Freighter on your Browser

Freighter works as a Extension in Chrome (Google Chrome, Brave) and Firefox:

Visit the Freighter Official Website, to install Freighter into your browser.
Click on "Create Account" and choose a secure password.

Step 2: Safeguarding Your Wallet

Upon creating your account, you will be presented with a secret recovery phrase. This phrase acts as a backup for your wallet's private key, allowing you to restore your wallet in case of loss, theft, or device damage.

Follow these important guidelines to protect your funds:

Save the Seed Phrase: Keep your seed phrase in a safe place. Treat it as a valuable key to your funds and store it confidentially.
Secure Storage: Store the seed phrase in a secure location, such as a locked drawer or a password-protected digital storage solution. Ensure it is shielded from unauthorized access and potential loss.
Exercise Caution: Remember, anyone with access to your seed phrase can gain control over your wallet and its contents. Take the necessary precautions to safeguard it diligently.

Step 3: Confirming Your Seed Phrase

To ensure accuracy, you will be asked to confirm your seed phrase in the same order. This step guarantees that you have correctly noted down your recovery phrase.

Step 4: Accessing Your Wallet

Congratulations! You are now ready to use your Freighter wallet. Follow these final steps:

Open the Freighter extension in your browser.

Your account will be displayed, labeled as "Account 1," along with your unique account address. This address serves as an identifier for receiving funds or transactions from other users or entities on the blockchain network.
Click on the "Main Net" button located at the top right corner to explore the networks:

Mainnet: The live and fully operational blockchain network where real transactions occur.
Testnet: A simulated environment for testing and experimentation

Since Soroswap is currently in the Soroban Testnet environment, we will proceed with the tutorial using the Testnet setting. By utilizing the testnet, we can safely explore and demonstrate the functionalities of Soroswap without any concerns about real-world financial implications.

Step 5: Let's Dive into the Tutorial

Congratulations! You are now fully equipped to embark on an exciting journey with Soroswap on the testnet. Get ready to explore and make the most of Soroswap's comprehensive range of features within this secure testing environment. Let's dive right into the tutorial and unlock the full potential of your Soroswap experience!

Soroswap 🪐 on Testnet Overview

esteblock — Wed, 15 Nov 2023 20:53:15 +0000

Soroswap Testnet Overview

Soroswap is an Automated Market Maker (AMM) built on Soroban, designed to facilitate token trading and liquidity provision. With its user-friendly interface, Soroswap offers a seamless and intuitive experience for users to engage with decentralized finance (DeFi) on the Soroban and Stellar

Check it in https://soroswap.finance/

User-Friendly Interface

Soroswap boasts a user-friendly interface that ensures a smooth and enjoyable trading experience. The intuitive design caters to both beginners and experienced traders, making it easy to navigate the platform and interact with its features.

Key Features and Benefits

** Currently Soroswap works only on Soroban Testnet**, and provides several key features and benefits for users:

Balance Section: Conveniently view your test token balances in the Balance section. This feature allows you to keep track of your assets and monitor their availability for transactions within the app.
Swap Section: Easily exchange one token for another within the liquidity pool using Soroswap's Swap section. This feature provides a straightforward and efficient solution for diversifying your portfolio or making specific token swaps.
Liquidity Section: Empowers users to add or remove liquidity from the pools. By participating in liquidity provision, you contribute to the stability and efficiency of the Soroswap ecosystem. Effectively manage your liquidity positions in the Liquidity section for a smooth and rewarding experience.

Soroswap on the Sorosban Testnet allows users to fully explore and test the platform using test tokens. This enables you to experience the complete functionality of the app without risking real funds. It provides an opportunity to familiarize yourself with the features, understand the process of adding liquidity, performing swaps, and removing liquidity.

By utilizing Soroswap on the testnet, you can gain hands-on experience with decentralized exchanges and DeFi concepts. It serves as a valuable learning tool and a safe environment to experiment with different trading strategies and liquidity provision.

In the following sections, we will provide step-by-step instructions on how to use Soroswap on the testnet, including installing the Freighter wallet, adding liquidity, performing swaps, and removing liquidity. These instructions will help you navigate the platform and make the most of the features and benefits offered by Soroswap. Let's dive in!

Did you like it?
Please give us feedback. Join our Discord channel: https://discord.gg/wyesAQhP

Soroswap.Finance 🪐 is live on Soroban Testnet ✨!

esteblock — Wed, 15 Nov 2023 20:50:39 +0000

Soroswap.Finance 🪐 is now live on Soroban Testnet, and we couldn't be more thrilled to share this exciting news with the Stellar and Soroban communities!

Ten months have passed since Soroswap proudly clinched the 3rd prize in the inaugural Hacka-Soroban-athon 🖥, Soroban's first-ever hackathon. Our journey has been filled with dedication, a evoluting team of over 10 talented collaborators, collaboration with an external design agency, and participation in key events like the sub0 Polkadot 🧬 Conference and the Meridian 2023 conference in Madrid 🇪🇸.

Soroswap is an open-source AMM protocol designed to enhance liquidity provision and asset trading for Stellar assets within the Soroban ecosystem. It comes equipped with an SDK and a user-friendly frontend to make your experience seamless.
Soroban is the new Smart Contract platform of the Blockchain Stellar, and we are creating DeFi primitives on it!

Experience Soroswap on Testnet now!: https://soroswap.finance/

To get started, simply access it with a Freighter Wallet version 5.6.4 or higher. On our Testnet dapp, you can experiment with our test tokens and get a feel for the platform. Mint test tokens, provide liquidity and do swaps"

Your Feedback Matters 💭: We welcome your valuable feedback! Your input is crucial to us and the entire ecosystem. If you have questions, find bugs, or just want to share your thoughts, please don't hesitate to reach out. We're eager to incorporate your insights into this incredible project. You can do this by:

What is next? 🥑✨
For the final months and 2024 Q1 Soroswap.Finance Rodamap looks like this:

Implement Mercury 🌐 Indexer to become a multi AMM Aggregator
Implement Mercury 🌐 Indexer for a Enhanced Dashboard
Implement Mercury 🌐 Indexer for a Optimal Routing
Implement a Bridge (AllBridge in/to Ethereum or Pendulum in/to Polkadot!)
Community Building

We still have a lot of things to build!
We hope you give us your support to let this happen!

A Big Thank You 🤗: We owe a massive thanks to the Stellar Community Fund (SCF) for making this journey possible. You can review all our SCF deliverables in our SCF tracker repo.

Meet the Team 🧑‍🤝‍🧑:
Soroswap.Finance 🪐 is brought to you by PaltaLabs🥑, a dynamic Blockchain Development Laboratory with contributors from Santiago, Valdivia and Rancagua (Chile), Rio de Janeiro (Brazil), Berlin (Germany), and Arras (France). Our team is a blend of dedicated full-timers, part-timers, and past collaborators who may rejoin us in the future. We extend our heartfelt gratitude to everyone who's played a role in Soroswap's journey.

Esteban Iglesias (esteblock), CEO & Founder, Fullstack Blockchain Developer
Francisco Catrileo (devmonsterblock), Fullstack Blockchain Developer
Joaquín Soza (yripper), Fullstack Blockchain Developer
Maximiliano Carrasco (abstract#1547), Frontend Developer
Viviana Manríquez (vivitapatita), Brand Coordinator
Diego Correa Tristain (diegotristain), Rust Developer
Benjamin Salon(benjaminsalon) Computer Science & @soroban-react Supporter
Jose Tomas Schuwirth (ealric), Frontend Web3 Developer
Mauricio Patiño (.maur0), Full-Stack Developer
Ricardo Rodriguez (ricardor4), Computer Science & Mathematics Models
José Fredes (draken1700), Frontend Developer

Join us in exploring Soroswap on Testnet and help us make it even better! Your involvement is key to the success of this innovative project. 🚀🌟

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.

Welcome to Soroswap.Finance

esteblock — Tue, 31 Oct 2023 12:29:51 +0000

This will be our space to share what we are building in the Soroban / Stellar Blockchain!

https://soroswap.finance/