Python SDK for Secret Network
An intricate reference to the APIs on the Secret SDK can be found here.
A walk-through of the steps to get started with the Secret SDK alongside with a few use case examples are provided below.
Secret SDK requires Python v3.7+.
NOTE: All code starting with a $ is meant to run on your terminal (a bash prompt). All code starting with a >>> is meant to run in a python interpreter, like ipython.
Secret SDK can be installed (preferably in a virtual environment from PyPI using pip) as follows:
$ pip install -U secret-sdk
You might have pip3 installed instead of pip; proceed according to your own setup.
Secret SDK uses Poetry to manage dependencies. To get set up with all the required dependencies, run:
$ pip install poetry
$ poetry install
Secret SDK provides extensive tests for data classes and functions. To run them, after the steps in Dependencies:
$ make test
Secret SDK can help you read block data, query secret contracts, sign and send transactions, and many more. Following examples are provided to help get building started.
In order to interact with the Secret blockchain, you'll need a connection to a Secret node or an api. This can be done through setting up an LCDClient (The LCDClient is an object representing an HTTP connection to a Secret LCD node.):
>>> from secret_sdk.client.lcd import LCDClient
>>> secret = LCDClient(chain_id="secret-4", url=node_rest_endpoint)
Once properly configured, the LCDClient instance will allow you to interact with the Secret blockchain. Try getting the latest block height:
>>> secret.tendermint.block_info()['block']['header']['height']
'1687543'
If you want to make asynchronous, non-blocking LCD requests, you can use AsyncLCDClient. The interface is similar to LCDClient, except the module and wallet API functions must be awaited.
>>> import asyncio
>>> from secret_sdk.client.lcd import AsyncLCDClient
>>> async def main():
async with AsyncLCDClient(url=node_rest_endpoint, chain_id="secret-4") as secret:
community_pool = await secret.distribution.community_pool()
print(community_pool)
await secret.session.close() # you must close the session
>>> asyncio.get_event_loop().run_until_complete(main())
You can improve the efficiency of consecutive queries by making them asynchronous.
>>> import asyncio
>>> import uvloop
>>> from secret_sdk.client.lcd import AsyncLCDClient
>>> from secret_sdk.exceptions import LCDResponseError
>>> def owner_of(token_id):
return {
"owner_of": {
"token_id": token_id,
}
}
>>> async def query_owner(secret, contract_address, token_id, query):
try:
msg = await secret.wasm.contract_query(contract_address, query)
return (token_id, msg["owner_of"]["owner"])
except LCDResponseError:
return (token_id, "")
>>> async def query_collection(contract_address, token_ids):
async with AsyncLCDClient(chain_id="secret-4", url=node_rest_endpoint) as secret:
requests = [query_owner(secret, contract_address, token, owner_of(token)) for token in token_ids]
owners = await asyncio.gather(*requests, return_exceptions=True)
print(owners)
await secret.session.close() # you must close the session
>>> uvloop.install()
>>> if __name__ == '__main__':
asyncio.run(query_collection(contract_address, token_ids))
If you wish to perform a state-changing operation on the Secret blockchain such as sending tokens, swapping assets, withdrawing rewards, or even invoking functions on smart contracts, you must create a transaction and broadcast it to the network. Secret SDK provides functions that help create StdTx objects.
A Wallet allows you to create and sign a transaction in a single step by automatically fetching the latest information from the blockchain (chain ID, account number, sequence).
Use LCDClient.wallet() to create a Wallet from any Key instance. The Key provided should correspond to the account you intend to sign the transaction with.
>>> from secret_sdk.client.lcd import LCDClient
>>> from secret_sdk.key.mnemonic import MnemonicKey
>>> mk = MnemonicKey(mnemonic=MNEMONIC)
>>> secret = LCDClient(node_rest_endpoint, "secret-4")
>>> wallet = secret.wallet(mk)
Once you have your Wallet, you can create a StdTx using Wallet.create_and_sign_tx then broadcast it to the network with secret.tx.broadcast with your broadcast mode of choice (block, sync, async - see cosmos docs).
>>> from secret_sdk.core.auth import StdFee
>>> from secret_sdk.core.bank import MsgSend
>>> send_msg = MsgSend(
wallet.key.acc_address,
RECIPIENT,
"1000000uscrt" # send 1 scrt
)
>>> tx = wallet.create_and_sign_tx(
msgs=[send_msg],
memo="My first transaction!",
fee=StdFee(200000, "120000uscrt")
)
>>> result = secret.tx.broadcast(tx)
>>> print(result)
Or use the abstraction wallet.send_tokens (see wallet.execute_tx to execute a smart contract with handle_msg).
>>> tx = wallet.send_tokens(recipient_addr=RECIPIENT, transfer_amount="1000000uscrt")
You can combine muliple state-changing transactions for the same contract into a single transaction. The contract used here is from the Counter contract example
msg = {
'increment': {}
}
msg_list = [msg for _ in range(10)]
tx = wallet.execute_tx(
CONTRACT_ADDR,
msg_list,
memo="My first batch transaction!",
)
Community contribution, whether it's a new feature, correction, bug report, additional documentation, or any other feedback is always welcome. Please read through this section to ensure that your contribution is in the most suitable format for us to effectively process.
First things first: Do NOT report security vulnerabilities in public issues! Please disclose responsibly by letting the Secret SDK team know upfront (discord , telegram). We will assess the issue as soon as possible on a best-effort basis and will give you an estimate for when we have a fix and release available for an eventual public disclosure.
If you encounter a different issue with the Python SDK, check first to see if there is an existing issue on the Issues page or a pull request on the Pull request page (both Open and Closed tabs) addressing the topic.
If there isn't a discussion on the topic there, you can file an issue. The ideal report includes:
If you wish to request the addition of a feature, please first checkout the Issues page and the Pull requests page (both Open and Closed tabs). If you decide to continue with the request, think of the merits of the feature to convince the project's developers, and provide as much detail and context as possible in the form of filing an issue on the Issues page.
If you wish to contribute to the repository in the form of patches, improvements, new features, etc., first scale the contribution. If it is a major development, like implementing a feature, it is recommended that you consult with the developers of the project before starting the development in order not to risk spending a lot of time working on a change that might not get merged into the project. Once confirmed, you are welcome to submit your pull request.
main branch to propose your code.A good pull request:
Flake8).Documentation improvements are always welcome. The documentation files live in the docs directory of the repository and are written in reStructuredText and use Sphinx to create the full suite of documentation.
When contributing documentation, please do your best to follow the style of the documentation files. This means a soft-limit of 88 characters wide in your text files and a semi-formal, yet friendly and approachable, prose style. You can propose your imporvements by submiting a pull request as explained above.
You can give this guide read for more insight.
This software is licensed under the MIT license. See LICENSE for full disclosure.
FAQs
The Python SDK for Secret
We found that secret-sdk demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.