This library will enable developers to seamlessly integrate Soroban functionality into their Rust-based applications and services.

The key features and services I plan to develop include:

1. Transaction Processing: We aim to provide a comprehensive set of functions and utilities for creating, signing, and submitting transactions to the Stellar network using Soroban. This will empower developers to easily build secure and efficient transaction processing capabilities into their applications.
2. Account Management: The library will offer convenient methods for managing Stellar accounts, including generating key pairs, retrieving balances, fetching transaction histories, and monitoring account events. These functionalities will simplify the process of interacting with Stellar accounts while ensuring data integrity and security.
3. Asset Issuance and Management: This will provide tools for creating and managing custom assets on the Stellar network, enabling developers to tokenize real-world assets, issue stablecoins, or implement their own unique digital assets. Our library will streamline the asset issuance process and provide necessary functionalities for asset management.
4. Integration Support: To enhance ease of adoption, the library will offer extensive documentation, code examples, and integration guides. I will actively engage with the developer community to provide support, address queries, and incorporate feedback, ensuring a smooth and efficient integration experience.

‍

The library is open-source and it is composed of 3 components:
1. rs-stellar-xdr: a low-level library for encoding/decoding XDR data. This has already been developed by the Stellar Core team.
2. rs-stellar-base: a library that offers a comprehensive set of functions for reading, writing, hashing, and signing primitive XDR constructs utilized in the Stellar network. it provides a nice abstraction for building and signing transactions.
3. rs-soroban-client: A Horizon client for submission of the transactions.

This library will enable developers to seamlessly integrate Soroban functionality into their Rust-based applications and services. Most of the groundwork has already been laid by the Stellar team by building the xdr library and rust stellar strkey implementation. This particular library has been the missing piece for soroban and the rust community at large in the stellar ecosystem.

A practical scenario where this library can be used,Suppose someone wants to build a trading bot targeting a DEX built on Soroban itself. This bot executes a large number of trades within a short period, often leveraging market inefficiencies and price discrepancies. A Rust client library for Soroban would provide the person with a performant toolset to build trading algorithms, interact with the Stellar network, and execute trades with minimal latency.

The first deliverable, which represents approximately 10% of the total project workload, will be the implementation of the basic functionality of the Rust Soroban Client Library. To complete this successfully, the following steps will be undertaken.:

1. Research and Analysis: I will conduct a thorough analysis of the existing js-soroban-client library to understand its core features, functionality, and design principles. This analysis will guide us in identifying the key components and requirements for the Rust implementation.

2. Project Setup: I will set up the necessary development environment for Rust, including installing the required dependencies, setting up a project structure, and configuring the build system. This step will ensure a smooth development process and allow to leverage existing Rust ecosystem tools and libraries effectively.

3. API Design: I will design the API of the Rust Soroban Client Library, taking into consideration best practices, idiomatic Rust patterns, and the specific requirements of the Stellar and Soroban ecosystems. The API design will focus on providing intuitive and easy-to-use functions for developers, while ensuring the library's flexibility and extensibility.

4. Core Functionality Implementation: Based on the API design, I will begin implementing a part of the core functionality of the library. This will include handling account handling, keypair generation, transaction building and signing and error handling.

How can a reviewer check you completed your first deliverable?

To ensure transparency and enable the reviewer to verify the completion of the first deliverable, the implementation of the basic functionality of the Rust Soroban Client Library, will be providing the following means for validation:

1. Design Documentation:

The documentation which identifies the key methods, structs, enums, design considerations and the required modules for the library is here

https://rust-soroban-client-lib.notion.site/Rust-Soroban-Client-Library-Design-85f89b7adefd4c5c9cb10025de96e951?pvs=4

2. Code Repository: I will maintain a publicly accessible code repository, where the reviewer can examine the codebase. The repository which you can access publicly is Stellar Base Library - https://github.com/rahul-soshte/rs-stellar-base

The above link is for the low-level library which is being heavily worked upon. I have been able to complete code for

1. Account Handling (https://github.com/rahul-soshte/rs-stellar-base/blob/main/src/account.rs)
2. Keypair (https://github.com/rahul-soshte/rs-stellar-base/blob/main/src/keypair.rs)
3. Signing Functionality (https://github.com/rahul-soshte/rs-stellar-base/blob/main/src/signing.rs)
4. Create Account Operations Example (https://github.com/rahul-soshte/rs-stellar-base/blob/main/src/op_list/create_account.rs)
5. Simple Transaction Building and Signing where you can add operations and set fee

(https://github.com/rahul-soshte/rs-stellar-base/blob/add-transaction/src/transaction.rs)

The high-level library, which is the rs-soroban-client re-exports functions from this low level library and communicates with the Soroban RPC. Its development depends on the availability of functions from the low-level library rs-stellar-base which is still WIP. For now it does not contain much other than re-exporting of the base library. Posting the link here though, Soroban Client Library - https://github.com/rahul-soshte/rs-soroban-client

3. API Documentation

The API documentation for the modules developed till now can be found in docs.rs which hosts the documentation for the crate.

https://docs.rs/stellar-baselib/latest/stellar_baselib/

4. Unit Tests: I have written unit tests for any module that I have written in the code. The reviewer can execute these tests locally to verify that the features are implemented correctly. The instruction to execute the tests for the stellar base library can be found here

https://github.com/rahul-soshte/rs-stellar-base#how-to-run-tests

‍