skip-python 0.1.4

A helper library to sign/send bundles and secure transactions to the Skip Relay in Python.

A helper library to sign and send bundles to the Skip Relay in Python.

PyPi: https://pypi.org/project/skip-python/

Github: https://github.com/skip-mev/skip-py

Quick Start

Prerequisite

In the latest release, skip-python requires:

• Python 3.10 or later

Check your python version by entering:

python3 --version

Installation

There are 2 ways to use skip-python: pip, or git clone.

via pip

pip install skip-python

via git clone

git clone https://github.com/skip-mev/skip-py.git

After cloning, you can move the skip folder into your respective development repo and import the helper library.

Example Usage

import skip
from cosmpy.aerial.wallet import LocalWallet
from cosmpy.crypto.keypairs import PrivateKey

tx_bytes = b'<tx bytes>'

wallet = LocalWallet(PrivateKey('<base64 encoded private key>'), prefix="juno")

response = skip.sign_and_send_bundle(bundle=[tx_bytes], 
                                     private_key=wallet.signer().private_key_bytes,
                                     public_key=wallet.signer().public_key,
                                     rpc_url="http://juno-1-api.skip.money/",
                                     desired_height=0,
                                     sync=True)

For a more detailed/runnable example, check out:

https://github.com/skip-mev/skip-py/blob/main/examples/example.py

Detailed Usage

Import the package with:

import skip

Alternatively, you can import specific functions to use like so:

from skip import sign_bundle, send_bundle, sign_and_send_bundle, send_secure_transaction, send_bundle_async, sign_and_send_bundle_async

This helper library exposes six functions: sign_bundle, send_bundle, sign_and_send_bundle, send_secure_transaction, send_bundle_async, sign_and_send_bundle_async

sign_bundle

sign_bundle Signs a bundle of transactions and returns the signed bundle and the signature.

sign_bundle(bundle: list[bytes], private_key: bytes) -> tuple[list[str], bytes]
"""
Args:
    bundle (list[bytes]): A list of transaction bytes to sign. 
        The list of transaction must be in the order as the desired bundle.
        Transaction bytes can be obtained from mempool txs (tx) by applying base64.b64decode(tx)
    private_key (bytes): The private key to sign the bundle with in bytes.

Returns:
    tuple[list[str], bytes]: A tuple of the signed bundle and the signature.
"""

send_bundle

send_bundle Sends a signed bundle to the Skip Relay.

send_bundle(b64_encoded_signed_bundle: list[str], 
            bundle_signature: bytes, 
            public_key: str, 
            rpc_url: str, 
            desired_height: int, 
            sync: bool,
            timeout: float | None = 30) -> httpx.Response
"""
Args:
    b64_encoded_signed_bundle (list[str]): A list of base64 encoded signed transactions.
        The list of transaction must be in the order as the desired bundle.
    bundle_signature (bytes): The signature applied to the bundle.
    public_key (str): The base64 encoded public key of the private key used to sign the bundle.
    rpc_url (str): The URL of the Skip Relay RPC.
    desired_height (int): The desired height for the bundle to be included in. 
        Height of 0 can be used to include the bundle in the next block.
    sync (bool): A flag to indicate if the broadcast should be synchronous or not.
    timeout (float | None): Number of seconds to wait before throwing a read timeout error
        for httpx. Default is 10 seconds.

Returns:
    httpx.Response: The response from the Skip Relay.
"""

sign_and_send_bundle

sign_and_send_bundle Signs and sends a bundle to the Skip Relay (a wrapper function combining sign_bundle and send_bundle).

sign_and_send_bundle(bundle: list[bytes], 
                     private_key: bytes, 
                     public_key: str, 
                     rpc_url: str, 
                     desired_height: int,
                     timeout: float | None = 30) -> httpx.Response
"""
Args:
    bundle (list[bytes]): A list of transaction bytes to sign.
        The list of transaction must be in the order as the desired bundle.
        Transaction bytes can be obtained from mempool txs (tx) by applying base64.b64decode(tx)
    private_key (bytes): The private key to sign the bundle with in bytes.
    public_key (str): The base64 encoded public key of the private key used to sign the bundle.
    rpc_url (str): The URL of the Skip Relay RPC.
    desired_height (int): The desired height for the bundle to be included in.
    sync (bool): A flag to indicate if the broadcast should be synchronous or not.
    timeout (float | None): Number of seconds to wait before throwing a read timeout error
        for httpx. Default is 10 seconds.

Returns:
    httpx.Response: The response from the Skip Relay.
"""

send_secure_transaction

send_secure_transaction Sends a transaction securely through Skip Secure. The transaction's memo must be equal to the transaction sender address.

send_secure_transaction(transaction: bytes,
                        rpc_url: str,
                        timeout: float | None = 30) -> httpx.Response
"""
Sends a transaction through Skip Secure.

Args:
    transaction (str): Base64 encoded signed transaction to send.
    rpc_url (str): The URL of the Skip Secure RPC.
    timeout (float | None): Number of seconds to wait before throwing a read timeout error
    for httpx. Default is 10 seconds.

Returns:
    httpx.Response: The response from Skip Secure.
"""

send_bundle_async

send_bundle_async Sends a signed bundle to the Skip Relay asynchronously

send_bundle(b64_encoded_signed_bundle: list[str], 
            bundle_signature: bytes, 
            public_key: str, 
            rpc_url: str, 
            desired_height: int, 
            sync: bool,
            timeout: float | None = 30) -> httpx.Response
"""
Args:
    b64_encoded_signed_bundle (list[str]): A list of base64 encoded signed transactions.
        The list of transaction must be in the order as the desired bundle.
    bundle_signature (bytes): The signature applied to the bundle.
    public_key (str): The base64 encoded public key of the private key used to sign the bundle.
    rpc_url (str): The URL of the Skip Relay RPC.
    desired_height (int): The desired height for the bundle to be included in. 
        Height of 0 can be used to include the bundle in the next block.
    sync (bool): A flag to indicate if the broadcast should be synchronous or not.
    timeout (float | None): Number of seconds to wait before throwing a read timeout error
        for httpx. Default is 10 seconds.

Returns:
    httpx.Response: The response from the Skip Relay.
"""

sign_and_send_bundle_async

sign_and_send_bundle Signs and sends a bundle to the Skip Relay asynchronously (a wrapper function combining sign_bundle and send_bundle_async).

sign_and_send_bundle(bundle: list[bytes], 
                     private_key: bytes, 
                     public_key: str, 
                     rpc_url: str, 
                     desired_height: int,
                     timeout: float | None = 30) -> httpx.Response
"""
Args:
    bundle (list[bytes]): A list of transaction bytes to sign.
        The list of transaction must be in the order as the desired bundle.
        Transaction bytes can be obtained from mempool txs (tx) by applying base64.b64decode(tx)
    private_key (bytes): The private key to sign the bundle with in bytes.
    public_key (str): The base64 encoded public key of the private key used to sign the bundle.
    rpc_url (str): The URL of the Skip Relay RPC.
    desired_height (int): The desired height for the bundle to be included in.
    sync (bool): A flag to indicate if the broadcast should be synchronous or not.
    timeout (float | None): Number of seconds to wait before throwing a read timeout error
        for httpx. Default is 10 seconds.

Returns:
    httpx.Response: The response from the Skip Relay.
"""