def main():
from stellar_sdk.server import Server
def load_last_paging_token():
# Get the last paging token from a local database or file
return "now"
def save_paging_token(paging_token):
# In most cases, you should save this to a local database or file so that
# you can load it next time you stream new payments.
pass
# server = Server("https://horizon-testnet.stellar.org")
server = Server("https://horizon.stellar.org")
account_id = "GDTIZ3P6L33OZE3B437ZPX5KAS7APTGUMUTS34TXX6Z5BHD7IAABZDJZ"
# Create an API call to query payments involving the account.
payments = server.payments().for_account(account_id)
# If some payments have already been handled, start the results from the
# last seen payment. (See below in `handle_payment` where it gets saved.)
last_token = load_last_paging_token()
# if last_token:
# payments.cursor(last_token)
# `stream` will send each recorded payment, one by one, then keep the
# connection open and continue to send you new payments as they occur.
# 基于 EventSource(http长连接) , 而不是Websocket
for payment in payments.stream():
# Record the paging token so we can start from here next time.
save_paging_token(payment["paging_token"])
from pprint import pprint
pprint(payment)
# We only process `payment`, ignore `create_account` and `account_merge`.
if payment["type"] != "payment":
continue
# The payments stream includes both sent and received payments. We
# only want to process received payments here.
if payment['to'] != account_id:
continue
# In Stellar’s API, Lumens are referred to as the “native” type. Other
# asset types have more detailed information.
if payment["asset_type"] == "native":
asset = "Lumens"
else:
asset = f"{payment['asset_code']}:{payment['asset_issuer']}"
print(f"{payment['amount']} {asset} from {payment['from']}")
#获取更多信息 memo_type 和 memo
ret = server.transactions().transaction(
payment['transaction_hash']).call()
from pprint import pprint
pprint(ret)
pass
def chargeUser(uid, amount):
"""
Charge the user for a transaction.
"""
def load_last_paging_token():
# Get the last paging token from a local database or file
return "now"
def save_paging_token(paging_token):
# In most cases, you should save this to a local database or file so that
# you can load it next time you stream new payments.
pass
server = Server("https://horizon-testnet.stellar.org")
account_id = "GA4QPSGBHK7RAJZBBEDCIKFPSYLG3O2UTBT2I56RN4B5KIQF2GFZKSMF"
# Create an API call to query payments involving the account.
payments = server.payments().for_account(account_id)
# If some payments have already been handled, start the results from the
# last seen payment. (See below in `handle_payment` where it gets saved.)
last_token = load_last_paging_token()
if last_token:
payments.cursor(last_token)
# `stream` will send each recorded payment, one by one, then keep the
# connection open and continue to send you new payments as they occur.
for payment in payments.stream():
# Record the paging token so we can start from here next time.
save_paging_token(payment["paging_token"])
# We only process `payment`, ignore `create_account` and `account_merge`.
if payment["type"] != "payment":
continue
# The payments stream includes both sent and received payments. We
# only want to process received payments here.
if payment['to'] != account_id:
continue
# In Stellar’s API, Lumens are referred to as the “native” type. Other
# asset types have more detailed information.
if payment["asset_type"] == "native":
asset = "Lumens"
else:
asset = f"{payment['asset_code']}:{payment['asset_issuer']}"
print(f"{payment['amount']} {asset} from {payment['from']}")
return None
def main():
from stellar_sdk.server import Server
server = Server("https://horizon-testnet.stellar.org")
public_key = "GDTIZ3P6L33OZE3B437ZPX5KAS7APTGUMUTS34TXX6Z5BHD7IAABZDJZ"
account = server.accounts().account_id(public_key).call()
pprint(account)
for balance in account['balances']:
print(f"Type: {balance['asset_type']}, Balance: {balance['balance']}")
pass
def test_load_acount_sync(self):
account_id = "GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D"
horizon_url = "https://horizon.stellar.org"
with Server(horizon_url) as server:
account = server.load_account(account_id)
assert account.account_id == account_id
assert isinstance(account.sequence, int)
def test_submit_transaction_with_xdr(self):
xdr = "AAAAAHI7fpgo+b7tgpiFyYWimjV7L7IOYLwmQS7k7F8SronXAAAAZAE+QT4AAAAJAAAAAQAAAAAAAAAAAAAAAF1MG8cAAAAAAAAAAQAAAAAAAAAAAAAAAOvi1O/HEn+QgZJw+EMZBtwvTVNmpgvE9p8IRfwp0GY4AAAAAAExLQAAAAAAAAAAARKuidcAAABAJVc1ASGp35hUquGNbzzSqWPoTG0zgc89zc4p+19QkgbPqsdyEfHs7+ng9VJA49YneEXRa6Fv7pfKpEigb3VTCg=="
horizon_url = "https://horizon.stellar.org"
client = RequestsClient()
with Server(horizon_url, client) as server:
resp = server.submit_transaction(xdr, True)
assert resp["envelope_xdr"] == xdr
async def _for_account(self, account: str): # pragma: no cover
"""
Stream transactions for the server Stellar address.
"""
async with Server(settings.HORIZON_URI,
client=AiohttpClient()) as server:
try:
# Ensure the distribution account actually exists
await server.load_account(account)
except NotFoundError:
# This exception will crash the process, but the anchor needs
# to provide valid accounts to watch.
raise RuntimeError(
"Stellar distribution account does not exist in horizon")
last_completed_transaction = (Transaction.objects.filter(
Q(kind=Transaction.KIND.withdrawal)
| Q(kind=Transaction.KIND.send),
receiving_anchor_account=account,
status=Transaction.STATUS.completed,
).order_by("-completed_at").first())
cursor = "now"
if last_completed_transaction:
cursor = last_completed_transaction.paging_token
endpoint = server.transactions().for_account(account).cursor(
cursor)
async for response in endpoint.stream():
self.process_response(response, account)
async def test_submit_transaction_with_te(self):
xdr = "AAAAAHI7fpgo+b7tgpiFyYWimjV7L7IOYLwmQS7k7F8SronXAAAAZAE+QT4AAAAJAAAAAQAAAAAAAAAAAAAAAF1MG8cAAAAAAAAAAQAAAAAAAAAAAAAAAOvi1O/HEn+QgZJw+EMZBtwvTVNmpgvE9p8IRfwp0GY4AAAAAAExLQAAAAAAAAAAARKuidcAAABAJVc1ASGp35hUquGNbzzSqWPoTG0zgc89zc4p+19QkgbPqsdyEfHs7+ng9VJA49YneEXRa6Fv7pfKpEigb3VTCg=="
te = TransactionEnvelope.from_xdr(xdr, Network.PUBLIC_NETWORK_PASSPHRASE)
horizon_url = "https://horizon.stellar.org"
client = AiohttpClient()
async with Server(horizon_url, client) as server:
resp = await server.submit_transaction(te, True)
assert resp["envelope_xdr"] == xdr
async def test_load_acount_async(self):
account_id = "GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D"
horizon_url = "https://horizon.stellar.org"
client = AiohttpClient()
async with Server(horizon_url, client) as server:
account = await server.load_account(account_id)
assert account.account_id == account_id
assert isinstance(account.sequence, int)
assert account.thresholds == Thresholds(1, 2, 3)
def test_load_acount_muxed_account_sync(self):
account_id = MuxedAccount(
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D", 1234
)
horizon_url = "https://horizon.stellar.org"
with Server(horizon_url) as server:
account = server.load_account(account_id)
assert account.account_id == account_id
assert isinstance(account.sequence, int)
assert account.thresholds == Thresholds(1, 2, 3)
def test_bad_type_client_raise(self):
horizon_url = "https://h.fchain.io"
client = "BAD TYPE"
with pytest.raises(
TypeError,
match="This `client` class should be an instance "
"of `stellar_sdk.client.base_async_client.BaseAsyncClient` "
"or `stellar_sdk.client.base_sync_client.BaseSyncClient`.",
):
Server(horizon_url, client)
async def test_load_acount_muxed_account_str_async(self):
account_id = (
"MAAAAAAAAAAAJUXL4LKO7RYSP6IIDETQ7BBRSBW4F5GVGZVGBPCPNHYIIX6CTUDGHDUWO"
)
horizon_url = "https://horizon.stellar.org"
client = AiohttpClient()
async with Server(horizon_url, client) as server:
account = await server.load_account(account_id)
assert account.account_id == MuxedAccount.from_account(account_id)
assert isinstance(account.sequence, int)
assert account.thresholds == Thresholds(1, 2, 3)
def rewardUser(uid, amount):
"""
Reward the user by increasing his karma points via blockchain
"""
server = Server("https://horizon-testnet.stellar.org")
source_key = Keypair.from_secret(
"SA6HHDJ5KZKYFZVOOGHENIPVKV2HGKICN4RYQ2UZNZHZP7ZIYSQIQDCI")
destination_id = "GA4QPSGBHK7RAJZBBEDCIKFPSYLG3O2UTBT2I56RN4B5KIQF2GFZKSMF"
# First, check to make sure that the destination account exists.
# You could skip this, but if the account does not exist, you will be charged
# the transaction fee when the transaction fails.
try:
server.load_account(destination_id)
except NotFoundError:
# If the account is not found, surface an error message for logging.
raise Exception("The destination account does not exist!")
# If there was no error, load up-to-date information on your account.
source_account = server.load_account(source_key.public_key)
# Let's fetch base_fee from network
base_fee = server.fetch_base_fee()
# Start building the transaction.
transaction = (
TransactionBuilder(
source_account=source_account,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
base_fee=base_fee,
)
# Because Stellar allows transaction in many currencies, you must specify the asset type.
# Here we are sending Lumens.
.append_payment_op(destination=destination_id,
amount="10",
asset_code="XLM")
# A memo allows you to add your own metadata to a transaction. It's
# optional and does not affect how Stellar treats the transaction.
.add_text_memo("Test Transaction")
# Wait a maximum of three minutes for the transaction
.set_timeout(10).build())
# Sign the transaction to prove you are actually the person sending it.
transaction.sign(source_key)
try:
# And finally, send it off to Stellar!
response = server.submit_transaction(transaction)
print(f"Response: {response}")
except (BadRequestError, BadResponseError) as err:
print(f"Something went wrong!\n{err}")
return None
async def _for_account(self, account: str): # pragma: no cover
"""
Stream transactions for the server Stellar address.
"""
async with Server(settings.HORIZON_URI,
client=AiohttpClient()) as server:
try:
# Ensure the distribution account actually exists
await server.load_account(account)
except NotFoundError:
# This exception will crash the process, but the anchor needs
# to provide valid accounts to watch.
raise RuntimeError(
"Stellar distribution account does not exist in horizon")
endpoint = server.transactions().for_account(account).cursor("now")
async for response in endpoint.stream():
self.process_response(response)
class StellarConnector(Connector):
""" The StellarConnector class """
settings = {}
params = {
'addresses': {
'key_type': 'list',
'default': None,
'mandatory': True,
},
'url': {
'key_type': 'string',
'default': 'https://horizon.stellar.org/',
'mandatory': False,
},
}
def __init__(self):
self.exchange = 'stellar'
self.params.update(super().params) # merge with the global params
self.settings = utils.gather_environ(self.params)
self.server = Server(horizon_url=self.settings['url'])
super().__init__()
def retrieve_accounts(self):
""" Connects to the Stellar network and retrieves the account information """
log.info('Retrieving accounts')
for account in self.settings['addresses']:
balances = self.server.accounts().account_id(account).call().get('balances')
if isinstance(balances, list):
for balance in balances:
if balance.get('asset_code'):
currency = balance.get('asset_code')
elif balance.get('asset_type') == 'native':
currency = 'XLM'
else:
currency = balance.get('asset_type')
if currency not in self._accounts:
self._accounts.update({currency: {}})
self._accounts[currency].update({
f'{account}': float(balance.get('balance'))
})
log.log(5, f'Found the following accounts: {self._accounts}')
def server():
return Server(horizon_url=horizon_url())
def test_endpoint(self):
horizon_url = "https://horizon.stellar.org"
client = RequestsClient()
with Server(horizon_url, client) as server:
assert server.accounts() == AccountsCallBuilder(
horizon_url, client)
assert server.assets() == AssetsCallBuilder(horizon_url, client)
assert server.effects() == EffectsCallBuilder(horizon_url, client)
assert server.fee_stats() == FeeStatsCallBuilder(
horizon_url, client)
assert server.ledgers() == LedgersCallBuilder(horizon_url, client)
assert server.offers(
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D"
) == OffersCallBuilder(
horizon_url,
client,
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D",
)
assert server.operations() == OperationsCallBuilder(
horizon_url, client)
buying = Asset.native()
selling = Asset(
"MOE",
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D")
assert server.orderbook(buying, selling) == OrderbookCallBuilder(
horizon_url, client, buying, selling)
source_account = "GABUVMDURJFF477AEDAXOG5TL7JBHGDAKJQLH5K6FB5QONMLEV52C6IO"
destination_account = (
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D")
destination_asset = Asset.native()
destination_amount = "100.0"
assert server.paths(
source_account,
destination_account,
destination_asset,
destination_amount,
) == PathsCallBuilder(
horizon_url,
client,
source_account,
destination_account,
destination_asset,
destination_amount,
)
assert server.payments() == PaymentsCallBuilder(
horizon_url, client)
assert server.root() == RootCallBuilder(horizon_url, client)
base = Asset.native()
counter = Asset(
"MOE",
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D")
resolution = 3600000
start_time = 1565272000000
end_time = 1565278000000
offset = 3600000
assert server.trade_aggregations(
base, counter, resolution, start_time, end_time,
offset) == TradeAggregationsCallBuilder(
horizon_url,
client,
base,
counter,
resolution,
start_time,
end_time,
offset,
)
assert server.trades() == TradesCallBuilder(horizon_url, client)
assert server.transactions() == TransactionsCallBuilder(
horizon_url, client)
async def test_fetch_base_fee_async(self):
horizon_url = "https://horizon.stellar.org"
client = AiohttpClient()
async with Server(horizon_url, client) as server:
base_fee = await server.fetch_base_fee()
assert isinstance(base_fee, int)
def test_endpoint(self):
horizon_url = "https://horizon.stellar.org"
client = RequestsClient()
with Server(horizon_url, client) as server:
assert server.accounts() == AccountsCallBuilder(
horizon_url, client)
assert server.assets() == AssetsCallBuilder(horizon_url, client)
assert server.claimable_balances() == ClaimableBalancesCallBuilder(
horizon_url, client)
assert server.data(
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D",
"hello") == DataCallBuilder(
horizon_url,
client,
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D",
"hello",
)
assert server.effects() == EffectsCallBuilder(horizon_url, client)
assert server.fee_stats() == FeeStatsCallBuilder(
horizon_url, client)
assert server.ledgers() == LedgersCallBuilder(horizon_url, client)
assert server.offers() == OffersCallBuilder(horizon_url, client)
assert server.operations() == OperationsCallBuilder(
horizon_url, client)
buying = Asset.native()
selling = Asset(
"MOE",
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D")
assert server.orderbook(buying, selling) == OrderbookCallBuilder(
horizon_url, client, buying, selling)
source = "GAYSHLG75RPSMXWJ5KX7O7STE6RSZTD6NE4CTWAXFZYYVYIFRUVJIBJH"
destination_asset = Asset(
"EUR",
"GDSBCQO34HWPGUGQSP3QBFEXVTSR2PW46UIGTHVWGWJGQKH3AFNHXHXN")
destination_amount = "20.0"
assert server.strict_receive_paths(
source, destination_asset,
destination_amount) == StrictReceivePathsCallBuilder(
horizon_url, client, source, destination_asset,
destination_amount)
source_asset = Asset(
"EUR",
"GDSBCQO34HWPGUGQSP3QBFEXVTSR2PW46UIGTHVWGWJGQKH3AFNHXHXN")
source_amount = "10.25"
destination = "GARSFJNXJIHO6ULUBK3DBYKVSIZE7SC72S5DYBCHU7DKL22UXKVD7MXP"
assert server.strict_send_paths(
source_asset, source_amount,
destination) == StrictSendPathsCallBuilder(
horizon_url, client, source_asset, source_amount,
destination)
assert server.payments() == PaymentsCallBuilder(
horizon_url, client)
assert server.root() == RootCallBuilder(horizon_url, client)
base = Asset.native()
counter = Asset(
"MOE",
"GDV6FVHPY4JH7EEBSJYPQQYZA3OC6TKTM2TAXRHWT4EEL7BJ2BTDQT5D")
resolution = 3600000
start_time = 1565272000000
end_time = 1565278000000
offset = 3600000
assert server.trade_aggregations(
base, counter, resolution, start_time, end_time,
offset) == TradeAggregationsCallBuilder(
horizon_url,
client,
base,
counter,
resolution,
start_time,
end_time,
offset,
)
assert server.trades() == TradesCallBuilder(horizon_url, client)
assert server.transactions() == TransactionsCallBuilder(
horizon_url, client)
from stellar_sdk.server import Server
import json
fileName = 'accounts.json'
with open(fileName) as r:
accounts = json.load(r)
server = Server("https://horizon-testnet.stellar.org")
for user in accounts:
account = server.accounts().account_id(user['publicKey']).call()
for balance in account['balances']:
print(f"User: {user['name']}, ID: {account['id']}")
print(f"Type: {balance['asset_type']}, Balance: {balance['balance']}")
print()
def test_fetch_base_fee_sync(self):
horizon_url = "https://horizon.stellar.org"
with Server(horizon_url) as server:
base_fee = server.fetch_base_fee()
assert base_fee == 100
def main():
# server = Server("https://horizon-testnet.stellar.org")
server = Server("https://horizon.stellar.org")
# source_key = Keypair.from_secret("SARJMVBEUC32ITKBIBYRQZUFEWKYHMR7PET5NDZH6KPREY3CPCUQSBJU") #test1
# destination_id = "GBMHN7DQ7MQTFPUPAYJR6HUGI2WX55LDTJ4AJNBQPIWMHNHSN34A2ENS" #test2
# test2
# Secret: SARJMVBEUC32ITKBIBYRQZUFEWKYHMR7PET5NDZH6KPREY3CPCUQSBJU
# Public Key: GDTIZ3P6L33OZE3B437ZPX5KAS7APTGUMUTS34TXX6Z5BHD7IAABZDJZ
source_key = Keypair.from_secret(
"SARJMVBEUC32ITKBIBYRQZUFEWKYHMR7PET5NDZH6KPREY3CPCUQSBJU")
# destination_id = "GC2QRLQCNCIK3FEIPEO7KP64PBOTFREGNCLMUG64QYOQFVQVARQCNPTV"
destination_id = "GDKSN4MKI3VCX4ZN6P6WVQR64TGKPOHPKVBCO5ERJABMHI7GJHNAF6PX"
#如果目的账户不存在, 则使用 append_create_account_op
#如果目的账号存在, 则使用 append_payment_op
# First, check to make sure that the destination account exists.
# You could skip this, but if the account does not exist, you will be charged
# the transaction fee when the transaction fails.
is_acc_exits = False
try:
server.load_account(destination_id)
is_acc_exits = True
except NotFoundError:
# If the account is not found, surface an error message for logging.
# raise Exception("The destination account does not exist!")
print(f"{destination_id} not found, will create it")
is_acc_exits = False
# If there was no error, load up-to-date information on your account.
source_account = server.load_account(source_key.public_key)
# Let's fetch base_fee from network
base_fee = server.fetch_base_fee()
# Start building the transaction.
txbuilder = TransactionBuilder(
source_account=source_account,
# network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
network_passphrase=Network.PUBLIC_NETWORK_PASSPHRASE,
base_fee=base_fee,
)
if is_acc_exits:
txbuilder.append_payment_op(destination=destination_id,
amount="1.6666",
asset_code="XLM")
else:
txbuilder.append_create_account_op(destination=destination_id,
starting_balance="1.001")
txbuilder.add_text_memo("101108")\
.set_timeout(1000)
transaction = txbuilder.build()
# transaction = (
# TransactionBuilder(
# source_account=source_account,
# # network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
# network_passphrase=Network.PUBLIC_NETWORK_PASSPHRASE,
# base_fee=base_fee,
# )
# # Because Stellar allows transaction in many currencies, you must specify the asset type.
# # Here we are sending Lumens.
# # .append_payment_op(destination=destination_id, amount="1.001", asset_code="XLM")
# .append_create_account_op(destination=destination_id, starting_balance="1.001")
# # A memo allows you to add your own metadata to a transaction. It's
# # optional and does not affect how Stellar treats the transaction.
# .add_text_memo("556850")
# # Wait a maximum of three minutes for the transaction
# .set_timeout(10)
# .build()
# )
# Sign the transaction to prove you are actually the person sending it.
transaction.sign(source_key)
print(f'xdr trx: {transaction.to_xdr()}')
xdr = transaction.to_xdr()
print(f'len : {len(xdr)}')
print(type(server))
# rsp = server.submit_transaction(xdr)
# print(rsp)
try:
# And finally, send it off to Stellar!
response = server.submit_transaction(transaction)
print(f"Response: {response}")
except (BadRequestError, BadResponseError) as err:
print(f"Something went wrong!\n{err}")
pass
import os
import sys
from pprint import pprint
import dotenv
from stellar_sdk.asset import Asset
from stellar_sdk.keypair import Keypair
from stellar_sdk.network import Network
from stellar_sdk.operation.set_options import Flag as AuthFlag
from stellar_sdk.server import Server
from stellar_sdk.transaction_builder import TransactionBuilder
dotenv.load_dotenv(verbose=True)
STELLAR_HORIZON_TESTNET = os.getenv("STELLAR_HORIZON_TESTNET")
server = Server(STELLAR_HORIZON_TESTNET)
def create_assets_for_distributing(amount):
# Keys for accounts to issue and receive the new asset
issuing_keypair = Keypair.from_secret(os.getenv("ISSUING_PRIVATE"))
issuing_public = issuing_keypair.public_key
issuing_account = server.load_account(issuing_public)
distributor_keypair = Keypair.from_secret(os.getenv("DISTRIBUTOR_INRX_PRIVATE_KEY"))
distributor_public = distributor_keypair.public_key
distributor_account = server.load_account(distributor_public)
inr_asset = Asset("INRx", issuing_public)
from stellar_sdk.keypair import Keypair
import requests
from stellar_sdk.server import Server
import json
server = Server("https://horizon-testnet.stellar.org")
accounts = {}
for i in range(3):
# Create a Keypair
pair = Keypair.random()
print(f"Secret: {pair.secret}")
print(f"Public Key: {pair.public_key}")
# Create Account
public_key = pair.public_key
response = requests.get(f"https://friendbot.stellar.org?addr={public_key}")
if response.status_code == 200:
print(f"SUCCESS! You have a new account :)\n{response.text}")
# Get Account details
account = server.accounts().account_id(public_key).call()
for balance in account['balances']:
print(
f"Type: {balance['asset_type']}, Balance: {balance['balance']}"
)
# Save Account Keys
accounts[i] = {"sk": pair.secret, "pk": pair.public_key}
else:
SERVER_JWT_KEY = None
if any(sep in ACTIVE_SEPS for sep in ["sep-10", "sep-24"]):
SERVER_JWT_KEY = env_or_settings("SERVER_JWT_KEY")
STELLAR_NETWORK_PASSPHRASE = (
env_or_settings("STELLAR_NETWORK_PASSPHRASE", required=False)
or "Test SDF Network ; September 2015"
)
HORIZON_URI = (
env_or_settings("HORIZON_URI", required=False)
or "https://horizon-testnet.stellar.org"
)
if not HORIZON_URI.startswith("http"):
raise ImproperlyConfigured("HORIZON_URI must include a protocol (http or https)")
HORIZON_SERVER = Server(horizon_url=HORIZON_URI)
LOCAL_MODE = env_or_settings("LOCAL_MODE", bool=True, required=False) or False
HOST_URL = env_or_settings("HOST_URL")
if not HOST_URL.startswith("http"):
raise ImproperlyConfigured("HOST_URL must include a protocol (http or https)")
elif LOCAL_MODE and HOST_URL.startswith("https"):
raise ImproperlyConfigured("HOST_URL uses HTTPS but LOCAL_MODE only supports HTTP")
elif not LOCAL_MODE and not HOST_URL.startswith("https"):
raise ImproperlyConfigured("HOST_URL uses HTTP but LOCAL_MODE is off")
SEP10_HOME_DOMAINS = env_or_settings(
"SEP10_HOME_DOMAINS", list=True, required=False
) or [urlparse(HOST_URL).netloc]
if any(d.startswith("http") for d in SEP10_HOME_DOMAINS):
def __init__(self):
self.exchange = 'stellar'
self.params.update(super().params) # merge with the global params
self.settings = utils.gather_environ(self.params)
self.server = Server(horizon_url=self.settings['url'])
super().__init__()
# See: https://www.stellar.org/developers/guides/issuing-assets.html
from stellar_sdk.keypair import Keypair
from stellar_sdk.asset import Asset
from stellar_sdk.transaction_builder import TransactionBuilder
from stellar_sdk.server import Server
from stellar_sdk.network import Network
# Configure StellarSdk to talk to the horizon instance hosted by Stellar.org
# To use the live network, set the hostname to 'horizon.stellar.org'
server = Server(horizon_url="https://horizon-testnet.stellar.org")
# Keys for accounts to issue and receive the new asset
issuing_keypair = Keypair.from_secret(
"SCBHQEGSNBTT4S7Y73YAF3M3JSVSTSNBGAVU5M4XVFGUF7664EUXQHFU")
issuing_public = issuing_keypair.public_key
distributor_keypair = Keypair.from_secret(
"SB6MJ6M3BPJZUGFP2QCODUIKWQWF6AIN4Z6L3J6PWL3QGDW4L6YR3QIU")
distributor_public = distributor_keypair.public_key
# Transactions require a valid sequence number that is specific to this account.
# We can fetch the current sequence number for the source account from Horizon.
distributor_account = server.load_account(distributor_public)
# Create an object to represent the new asset
hello_asset = Asset("Hello", issuing_public)
# First, the receiving account must trust the asset
trust_transaction = (TransactionBuilder(
source_account=distributor_account,
from stellar_sdk.keypair import Keypair
from stellar_sdk.network import Network
from stellar_sdk.server import Server
from stellar_sdk.transaction_builder import TransactionBuilder
from stellar_sdk.exceptions import NotFoundError, BadResponseError, BadRequestError
import json
from stellar_base.builder import Builder
server = Server("https://horizon-testnet.stellar.org")
fileName = 'accounts.json'
with open(fileName) as r:
accounts = json.load(r)
source_acc_key = accounts[0]['secret']
source_acc_id = accounts[0]['publicKey']
destination_acc_id = accounts[1]['publicKey']
try:
server.load_account(destination_acc_id)
except NotFoundError:
# If the account is not found, surface an error message for logging.
raise Exception("The destination account does not exist!")
'''builder = Builder(secret=source_acc_key)
bob_address = destination_acc_id
builder.append_payment_op(bob_address, '10', 'XLM')
builder.add_text_memo('For beers') # string length <= 28 bytes
builder.sign()
builder.submit()'''
base_fee = server.fetch_base_fee()
