ARCHIVE/xrpl-dev-portal
1
0
Fork 0
mirror of https://github.com/XRPLF/xrpl-dev-portal.git synced 2025-11-21 20:25:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1933 from XRPLF/xrpl-py-2.0

Browse Source 
feat: Update xrpl-dev-portal to use xrpl-py 2.0
This commit is contained in:
Rome Reginelli
2023-07-05 15:00:32 -07:00
committed by GitHub
parent ca70a6080b 6350dfe50a
commit 5116247da7
52 changed files with 342 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -6,3 +6,4 @@ out/
package-lock.json
yarn-error.log
/.idea
.venv/

13
content/_code-samples/airgapped-wallet/py/airgapped-wallet-TEST.py
View File

@@ -7,11 +7,11 @@ from pathlib import Path, PureWindowsPath, PurePath
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from xrpl import wallet
from xrpl.core import keypairs
from xrpl.utils import xrp_to_drops
from xrpl.models.transactions import Payment
from xrpl.transaction import safe_sign_transaction
from xrpl.transaction import sign
from xrpl.wallet.main import Wallet
def create_wallet(silent: False):
@@ -63,24 +63,23 @@ def sign_transaction(xrp_amount, destination, ledger_seq, wallet_seq, password):
seed = crypt.decrypt(seed)
print("4. Initializing wallet using decrypted private key")
_wallet = wallet.Wallet(seed=seed.decode(), sequence=0)
_wallet = Wallet.from_seed(seed=seed.decode())
validated_seq = ledger_seq
_wallet.sequence = wallet_seq
print("5. Constructing payment transaction...")
my_tx_payment = Payment(
account=_wallet.classic_address,
account=_wallet.address,
amount=xrp_to_drops(xrp=xrp_amount),
destination=destination,
last_ledger_sequence=validated_seq + 100,
# +100 to catch up with the ledger when we transmit the signed tx blob to Machine 2
sequence=_wallet.sequence,
sequence=wallet_seq,
fee="10"
)
print("6. Signing transaction...")
my_tx_payment_signed = safe_sign_transaction(transaction=my_tx_payment, wallet=_wallet)
my_tx_payment_signed = sign(transaction=my_tx_payment, wallet=_wallet)
img = qrcode.make(my_tx_payment_signed.to_dict())

13
content/_code-samples/airgapped-wallet/py/airgapped-wallet.py
View File

@@ -8,11 +8,11 @@ from pathlib import Path, PureWindowsPath, PurePath
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from xrpl import wallet
from xrpl.wallet import Wallet
from xrpl.core import keypairs
from xrpl.utils import xrp_to_drops
from xrpl.models.transactions import Payment
from xrpl.transaction import safe_sign_transaction
from xrpl.transaction import sign
def create_wallet():
@@ -58,25 +58,24 @@ def sign_transaction(_xrp_amount, _destination, _ledger_seq, _wallet_seq, passwo
# Decrypts the wallet's private key
_seed = crypt.decrypt(_seed)
_wallet = wallet.Wallet(seed=_seed.decode(), sequence=0)
_wallet = Wallet.from_seed(seed=_seed.decode())
validated_seq = _ledger_seq
_wallet.sequence = _wallet_seq
# Construct Payment transaction
my_tx_payment = Payment(
account=_wallet.classic_address,
account=_wallet.address,
amount=xrp_to_drops(xrp=_xrp_amount),
destination=_destination,
last_ledger_sequence=validated_seq + 100,
# +100 to catch up with the ledger when we transmit the signed tx blob to Machine 2
sequence=_wallet.sequence,
sequence=_wallet_seq,
fee="10"
)
# Signs transaction and displays the signed_tx blob in QR code
# Scan the QR code and transmit the signed_tx blob to an online machine (Machine 2) to relay it to the XRPL
my_tx_payment_signed = safe_sign_transaction(transaction=my_tx_payment, wallet=_wallet)
my_tx_payment_signed = sign(transaction=my_tx_payment, wallet=_wallet)
img = qrcode.make(my_tx_payment_signed.to_dict())
img.save(get_path("/Wallet/transactionID.png"))

4
content/_code-samples/airgapped-wallet/py/relay-transaction.py
View File

@@ -1,6 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import Payment
from xrpl.transaction import send_reliable_submission
from xrpl.transaction import submit_and_wait
def connect_node(_node):
@@ -27,7 +27,7 @@ def send_transaction(transaction_dict):
# Since we manually inserted the tx blob, we need to initialize it into a Payment so xrpl-py could process it
my_tx_signed = Payment.from_dict(transaction_dict)
tx = send_reliable_submission(transaction=my_tx_signed, client=client)
tx = submit_and_wait(transaction=my_tx_signed, client=client)
tx_hash = tx.result['hash']
tx_destination = tx.result['Destination']

7
content/_code-samples/airgapped-wallet/py/requirements.txt
View File

@@ -9,7 +9,6 @@ Django==3.2.19
ECPy==1.2.5
h11==0.12.0
httpcore==0.13.6
httpx==0.23.0
idna==3.2
image==1.5.33
pifacedigitalio==3.0.5
@@ -21,6 +20,6 @@ rfc3986==1.5.0
six==1.16.0
sniffio==1.2.0
sqlparse==0.4.4
typing-extensions==3.10.0.0
websockets==9.1
xrpl-py==1.1.1
typing-extensions==4.2.0
websockets==10.0
xrpl-py==2.0.0

4
content/_code-samples/build-a-wallet/py/3_account.py
View File

@@ -233,9 +233,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

4
content/_code-samples/build-a-wallet/py/4_tx_history.py
View File

@@ -264,9 +264,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

10
content/_code-samples/build-a-wallet/py/5_send_xrp.py
View File

@@ -130,9 +130,9 @@ class XRPLMonitorThread(Thread):
# Autofill provides a sequence number, but this may fail if you try to
# send too many transactions too fast. You can send transactions more
# rapidly if you track the sequence number more carefully.
tx_signed = await xrpl.asyncio.transaction.safe_sign_and_autofill_transaction(
tx, self.wallet, self.client)
await xrpl.asyncio.transaction.submit_transaction(tx_signed, self.client)
tx_signed = await xrpl.asyncio.transaction.autofill_and_sign(
tx, self.client, self.wallet)
await xrpl.asyncio.transaction.submit(tx_signed, self.client)
wx.CallAfter(self.gui.add_pending_tx, tx_signed)
@@ -380,9 +380,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

10
content/_code-samples/build-a-wallet/py/6_verification_and_polish.py
View File

@@ -184,9 +184,9 @@ class XRPLMonitorThread(Thread):
# Autofill provides a sequence number, but this may fail if you try to
# send too many transactions too fast. You can send transactions more
# rapidly if you track the sequence number more carefully.
tx_signed = await xrpl.asyncio.transaction.safe_sign_and_autofill_transaction(
tx, self.wallet, self.client)
await xrpl.asyncio.transaction.submit_transaction(tx_signed, self.client)
tx_signed = await xrpl.asyncio.transaction.autofill_and_sign(
tx, self.client, self.wallet)
await xrpl.asyncio.transaction.submit(tx_signed, self.client)
wx.CallAfter(self.gui.add_pending_tx, tx_signed)
@@ -541,9 +541,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

10
content/_code-samples/build-a-wallet/py/7_owned_objects.py
View File

@@ -202,9 +202,9 @@ class XRPLMonitorThread(Thread):
# Autofill provides a sequence number, but this may fail if you try to
# send too many transactions too fast. You can send transactions more
# rapidly if you track the sequence number more carefully.
tx_signed = await xrpl.asyncio.transaction.safe_sign_and_autofill_transaction(
tx, self.wallet, self.client)
await xrpl.asyncio.transaction.submit_transaction(tx_signed, self.client)
tx_signed = await xrpl.asyncio.transaction.autofill_and_sign(
tx, self.client, self.wallet)
await xrpl.asyncio.transaction.submit(tx_signed, self.client)
wx.CallAfter(self.gui.add_pending_tx, tx_signed)
@@ -588,9 +588,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

12
content/_code-samples/build-a-wallet/py/8_regular_key.py
View File

@@ -132,7 +132,7 @@ class XRPLMonitorThread(Thread):
))
if response.is_successful():
print("set regular key: got account")
if response.result["account_data"].get("RegularKey") == wallet.classic_address:
if response.result["account_data"].get("RegularKey") == wallet.address:
print("set regular key: regular key matches")
self.wallet = wallet
wx.CallAfter(self.gui.enable_readwrite)
@@ -220,9 +220,9 @@ class XRPLMonitorThread(Thread):
# Autofill provides a sequence number, but this may fail if you try to
# send too many transactions too fast. You can send transactions more
# rapidly if you track the sequence number more carefully.
tx_signed = await xrpl.asyncio.transaction.safe_sign_and_autofill_transaction(
tx, self.wallet, self.client)
await xrpl.asyncio.transaction.submit_transaction(tx_signed, self.client)
tx_signed = await xrpl.asyncio.transaction.autofill_and_sign(
tx, self.client, self.wallet)
await xrpl.asyncio.transaction.submit(tx_signed, self.client)
wx.CallAfter(self.gui.add_pending_tx, tx_signed)
@@ -638,9 +638,9 @@ class TWaXLFrame(wx.Frame):
try:
# Check if it's a valid seed
seed_bytes, alg = xrpl.core.addresscodec.decode_seed(value)
wallet = xrpl.wallet.Wallet(seed=value, sequence=0)
wallet = xrpl.wallet.Wallet.from_seed(seed=value)
x_address = wallet.get_xaddress(is_test=self.test_network)
classic_address = wallet.classic_address
classic_address = wallet.address
except Exception as e:
print(e)
exit(1)

4
content/_code-samples/build-a-wallet/py/requirements.txt
View File

@@ -1,4 +1,4 @@
xrpl-py==1.3.0
wxPython==4.1.1
xrpl-py==2.0.0
wxPython==4.2.1
toml==0.10.2
requests==2.31.0

10
content/_code-samples/checks/py/cancel_check.py
View File

@@ -1,8 +1,7 @@
from xrpl.wallet import Wallet, generate_faucet_wallet
from xrpl.wallet import generate_faucet_wallet
from xrpl.clients import JsonRpcClient
from xrpl.models import CheckCancel
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.transaction import submit_and_wait
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to the testnetwork
@@ -17,11 +16,10 @@ check_id = "F944CB379DEE18EFDA7A58A4F81AF1A98C46E54A8B9F2D268F1E26610BC0EB03"
sender_wallet = generate_faucet_wallet(client=client)
# Build check cancel transaction
check_txn = CheckCancel(account=sender_wallet.classic_address, check_id=check_id)
check_txn = CheckCancel(account=sender_wallet.address, check_id=check_id)
# Sign and submit transaction
stxn = safe_sign_and_autofill_transaction(check_txn, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
stxn_response = submit_and_wait(check_txn, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result

26
content/_code-samples/checks/py/cash_check.py
View File

@@ -1,8 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import CheckCash, IssuedCurrencyAmount
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.utils import str_to_hex, xrp_to_drops
from xrpl.transaction import submit_and_wait
from xrpl.utils import xrp_to_drops
from xrpl.wallet import generate_faucet_wallet
# Connect to a network
@@ -21,13 +20,11 @@ amount = 10.00
sender_wallet = generate_faucet_wallet(client=client)
# Build check cash transaction
check_txn = CheckCash(account=sender_wallet.classic_address, check_id=check_id, amount=xrp_to_drops(amount))
check_txn = CheckCash(account=sender_wallet.address, check_id=check_id, amount=xrp_to_drops(amount))
# Sign transaction
stxn = safe_sign_and_autofill_transaction(check_txn, sender_wallet, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(check_txn, client, sender_wallet)
# Submit transaction and wait for result
stxn_response = send_reliable_submission(stxn, client)
# Parse response for result
stxn_result = stxn_response.result
@@ -49,22 +46,19 @@ token = "USD"
amount = 10.00
# Token issuer address
issuer = generate_faucet_wallet(client=client).classic_address
issuer = generate_faucet_wallet(client=client).address
# Create sender wallet object
sender_wallet = generate_faucet_wallet(client=client)
# Build check cash transaction
check_txn = CheckCash(account=sender_wallet.classic_address, check_id=check_id, amount=IssuedCurrencyAmount(
currency=str_to_hex(token),
check_txn = CheckCash(account=sender_wallet.address, check_id=check_id, amount=IssuedCurrencyAmount(
currency=token,
issuer=issuer,
value=amount))
# Sign transaction
stxn = safe_sign_and_autofill_transaction(check_txn, sender_wallet, client)
# Submit transaction and wait for result
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(check_txn, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result

31
content/_code-samples/checks/py/create_check.py
View File

@@ -2,9 +2,8 @@ from datetime import datetime, timedelta
from xrpl.clients import JsonRpcClient
from xrpl.models import CheckCreate, IssuedCurrencyAmount
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.utils import datetime_to_ripple_time, str_to_hex, xrp_to_drops
from xrpl.transaction import submit_and_wait
from xrpl.utils import datetime_to_ripple_time, xrp_to_drops
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to the testnetwork
@@ -26,16 +25,15 @@ expiry_date = datetime_to_ripple_time(datetime.now() + timedelta(days=5))
sender_wallet = generate_faucet_wallet(client=client)
# Build check create transaction
check_txn = CheckCreate(account=sender_wallet.classic_address, destination=receiver_addr,
send_max=IssuedCurrencyAmount(
currency=str_to_hex(token),
issuer=issuer,
value=amount),
check_txn = CheckCreate(account=sender_wallet.address, destination=check_receiver_addr,
send_max=IssuedCurrencyAmount(
currency=token_name,
issuer=token_issuer,
value=amount_to_deliver),
expiration=expiry_date)
# Sign, submit transaction and wait for result
stxn = safe_sign_and_autofill_transaction(check_txn, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(check_txn, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result
@@ -61,14 +59,13 @@ expiry_date = datetime_to_ripple_time(datetime.now() + timedelta(days=5))
sender_wallet = generate_faucet_wallet(client=client)
# Build check create transaction
check_txn = CheckCreate(account=sender_wallet.classic_address,
destination=receiver_addr,
send_max=xrp_to_drops(amount),
check_txn = CheckCreate(account=sender_wallet.address,
destination=check_receiver_addr,
send_max=xrp_to_drops(amount_to_deliver),
expiration=expiry_date)
# Sign, submit transaction and wait for result
stxn = safe_sign_and_autofill_transaction(check_txn, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(check_txn, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result

20
content/_code-samples/delete-account/py/blackhole-account.py
View File

@@ -1,6 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import AccountSet, SetRegularKey, AccountSetFlag, Payment
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.models.transactions import AccountSet, SetRegularKey, AccountSetAsfFlag
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountInfo
@@ -17,9 +17,9 @@ client = JsonRpcClient(JSON_RPC_URL)
# Get credentials from the Testnet Faucet
print("Requesting an account from the Testnet faucet...")
test_wallet = generate_faucet_wallet(client=client)
myAddr = test_wallet.classic_address
myAddr = test_wallet.address
print(f"\n Account: {test_wallet.classic_address}")
print(f"\n Account: {test_wallet.address}")
print(f" Seed: {test_wallet.seed}")
# This is a well known blackhole address
@@ -31,9 +31,8 @@ tx_regulary_key = SetRegularKey(
regular_key=blackhole_address
)
# Sign the transaction
tx_regulary_key_signed = safe_sign_and_autofill_transaction(tx_regulary_key, wallet=test_wallet, client=client)
submit_tx_regular = send_reliable_submission(client=client, transaction=tx_regulary_key_signed)
# Sign and submit the transaction
submit_tx_regular = submit_and_wait(transaction=tx_regulary_key, client=client, wallet=test_wallet)
submit_tx_regular = submit_tx_regular.result
print(f"\n Submitted a SetRegularKey tx. Result: {submit_tx_regular['meta']['TransactionResult']}")
print(f" Tx content: {submit_tx_regular}")
@@ -42,12 +41,11 @@ print(f" Tx content: {submit_tx_regular}")
# This permanently blackholes an account!
tx_disable_master_key = AccountSet(
account=myAddr,
set_flag=AccountSetFlag.ASF_DISABLE_MASTER
set_flag=AccountSetAsfFlag.ASF_DISABLE_MASTER
)
# Sign the transaction
tx_disable_master_key_signed = safe_sign_and_autofill_transaction(tx_disable_master_key, wallet=test_wallet, client=client)
submit_tx_disable = send_reliable_submission(client=client, transaction=tx_disable_master_key_signed)
# Sign and submit the transaction
submit_tx_disable = submit_and_wait(transaction=tx_disable_master_key, client=client, wallet=test_wallet)
submit_tx_disable = submit_tx_disable.result
print(f"\n Submitted a DisableMasterKey tx. Result: {submit_tx_disable['meta']['TransactionResult']}")
print(f" Tx content: {submit_tx_disable}")

10
content/_code-samples/escrow/py/cancel_escrow.py
View File

@@ -1,7 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import EscrowCancel
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to the testnetwork
@@ -15,11 +14,10 @@ escrow_sequence = 30215126
sender_wallet = generate_faucet_wallet(client=client)
# Build escrow cancel transaction
cancel_txn = EscrowCancel(account=sender_wallet.classic_address, owner=sender_wallet.classic_address, offer_sequence=escrow_sequence)
cancel_txn = EscrowCancel(account=sender_wallet.address, owner=sender_wallet.address, offer_sequence=escrow_sequence)
# Sign and submit transaction
stxn = safe_sign_and_autofill_transaction(cancel_txn, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(cancel_txn, client, sender_wallet)
# Parse response and return result
stxn_result = stxn_response.result

11
content/_code-samples/escrow/py/create_escrow.py
View File

@@ -1,10 +1,8 @@
import json
from datetime import datetime, timedelta
from xrpl.clients import JsonRpcClient
from xrpl.models import EscrowCreate
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.transaction import submit_and_wait
from xrpl.utils import datetime_to_ripple_time, xrp_to_drops
from xrpl.wallet import generate_faucet_wallet
@@ -31,16 +29,15 @@ sender_wallet = generate_faucet_wallet(client=client)
# Build escrow create transaction
create_txn = EscrowCreate(
account=sender_wallet.classic_address,
account=sender_wallet.address,
amount=xrp_to_drops(amount_to_escrow),
destination=receiver_addr,
finish_after=claim_date,
cancel_after=expiry_date,
condition=condition)
# Sign and send transaction
stxn = safe_sign_and_autofill_transaction(create_txn, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(create_txn, client, sender_wallet)
# Return result of transaction
stxn_result = stxn_response.result

16
content/_code-samples/escrow/py/finish_escrow.py
View File

@@ -1,8 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import EscrowFinish
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.wallet import Wallet, generate_faucet_wallet
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to the testnetwork
@@ -10,7 +9,7 @@ client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to the
# Cannot be called until the finish time is reached
# Required fields (modify to match an escrow you create)
escrow_creator = generate_faucet_wallet(client=client).classic_address
escrow_creator = generate_faucet_wallet(client=client).address
escrow_sequence = 27641268
@@ -26,13 +25,10 @@ fulfillment = "A0228020AED2C5FE4D147D310D3CFEBD9BFA81AD0F63CE1ADD92E00379DDDAF8E
sender_wallet = generate_faucet_wallet(client=client)
# Build escrow finish transaction
finish_txn = EscrowFinish(account=sender_wallet.classic_address, owner=escrow_creator, offer_sequence=escrow_sequence, condition=condition, fulfillment=fulfillment)
finish_txn = EscrowFinish(account=sender_wallet.address, owner=escrow_creator, offer_sequence=escrow_sequence, condition=condition, fulfillment=fulfillment)
# Sign transaction with wallet
stxn = safe_sign_and_autofill_transaction(finish_txn, sender_wallet, client)
# Send transaction and wait for response
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(finish_txn, client, sender_wallet)
# Parse response and return result
stxn_result = stxn_response.result

18
content/_code-samples/freeze/py/enable_no_freeze.py
View File

@@ -1,8 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import AccountSet, AccountSetFlag
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.wallet import Wallet, generate_faucet_wallet
from xrpl.models import AccountSet, AccountSetAsfFlag
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # connect to testnet
@@ -13,15 +12,12 @@ sender_wallet = generate_faucet_wallet(client=client)
print("Successfully generated test wallet")
# build accountset transaction to disable freezing
accountset = AccountSet(account=sender_wallet.classic_address, set_flag=AccountSetFlag.ASF_NO_FREEZE)
# sign transaction
stxn = safe_sign_and_autofill_transaction(accountset, sender_wallet, client)
accountset = AccountSet(account=sender_wallet.address, set_flag=AccountSetAsfFlag.ASF_NO_FREEZE)
print("Now sending an AccountSet transaction to set the ASF_NO_FREEZE flag...")
# submit transaction and wait for result
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(accountset, client, sender_wallet)
# parse response for result
@@ -29,6 +25,6 @@ stxn_result = stxn_response.result
# print result and transaction hash
if stxn_result["meta"]["TransactionResult"] == "tesSUCCESS":
print(f'Successfully enabled no freeze for {sender_wallet.classic_address}')
print(f'Successfully enabled no freeze for {sender_wallet.address}')
print(stxn_result["hash"])

18
content/_code-samples/freeze/py/freeze_token.py
View File

@@ -1,8 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import IssuedCurrencyAmount, TrustSet
from xrpl.models.transactions import TrustSetFlag
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to testnet
@@ -12,31 +11,28 @@ token_name = "FOO"
# Amount a trustline can handle, for this transaction it is set to 0
value = "100"
target_addr = generate_faucet_wallet(client=client).classic_address
target_addr = generate_faucet_wallet(client=client).address
sender_wallet = generate_faucet_wallet(client=client)
print("Successfully generated test wallets")
# Build trustline freeze transaction
trustset = TrustSet(account=sender_wallet.classic_address, limit_amount=IssuedCurrencyAmount(
trustset = TrustSet(account=sender_wallet.address, limit_amount=IssuedCurrencyAmount(
currency= token_name,
issuer=target_addr,
value = value),
flags=TrustSetFlag.TF_SET_FREEZE)
# Sign transaction
stxn = safe_sign_and_autofill_transaction(trustset, sender_wallet, client)
print("Now setting a trustline with the TF_SET_FREEZE flag enabled...")
# Submit transaction and wait for result
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(trustset, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result
if(stxn_result["meta"]["TransactionResult"] == 'tesSUCCESS'):
print(f"Froze {token_name} issued by {target_addr} for address {sender_wallet.classic_address}")
print(f"Froze {token_name} issued by {target_addr} for address {sender_wallet.address}")
if(stxn_result["meta"]["TransactionResult"] == 'tesSUCCESS'):
print(f"Froze {token_name} issued by {target_addr} for address {sender_wallet.classic_address}")
print(f"Froze {token_name} issued by {target_addr} for address {sender_wallet.address}")

16
content/_code-samples/freeze/py/set_global_freeze.py
View File

@@ -1,7 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import AccountSet, AccountSetFlag
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.models import AccountSet, AccountSetAsfFlag
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # Connect to testnet
@@ -12,19 +11,18 @@ sender_wallet = generate_faucet_wallet(client)
print("Successfully generated test wallet")
# Build accountset transaction to enable global freeze
accountset = AccountSet(account=sender_wallet.classic_address,
set_flag=AccountSetFlag.ASF_GLOBAL_FREEZE)
accountset = AccountSet(account=sender_wallet.address,
set_flag=AccountSetAsfFlag.ASF_GLOBAL_FREEZE)
print("Preparing and submitting Account set transaction with ASF_GLOBAL_FREEZE ...")
# Sign and submit transaction
stxn = safe_sign_and_autofill_transaction(accountset, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(accountset, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result
# Print result and transaction hash
if stxn_result["meta"]["TransactionResult"] == "tesSUCCESS":
print(f'Successfully enabled global freeze for {sender_wallet.classic_address}')
print(f'Successfully enabled global freeze for {sender_wallet.address}')
print(stxn_result["hash"])

14
content/_code-samples/freeze/py/unfreeze_token.py
View File

@@ -1,7 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models import IssuedCurrencyAmount, TrustSet, TrustSetFlag
from xrpl.transaction import (safe_sign_and_autofill_transaction,
send_reliable_submission)
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
client = JsonRpcClient("https://s.altnet.rippletest.net:51234") # connect to testnet
@@ -13,7 +12,7 @@ value = "0"
print("Generating two test wallets...")
# Address to unfreeze trustline
target_addr = generate_faucet_wallet(client=client).classic_address
target_addr = generate_faucet_wallet(client=client).address
print("Successfully generated the target account")
# Sender wallet
@@ -23,7 +22,7 @@ print("Successfully generated the sender account")
print("Successfully generated test wallets")
# Build trustline freeze transaction
trustset = TrustSet(account=sender_wallet.classic_address, limit_amount=IssuedCurrencyAmount(
trustset = TrustSet(account=sender_wallet.address, limit_amount=IssuedCurrencyAmount(
currency=token_name,
issuer=target_addr,
value = value
@@ -32,16 +31,15 @@ flags=TrustSetFlag.TF_CLEAR_FREEZE)
print("prepared and submitting TF_CLEAR_FREEZE transaction")
# Sign and Submit transaction
stxn = safe_sign_and_autofill_transaction(trustset, sender_wallet, client)
stxn_response = send_reliable_submission(stxn, client)
# Autofill, sign, then submit transaction and wait for result
stxn_response = submit_and_wait(trustset, client, sender_wallet)
# Parse response for result
stxn_result = stxn_response.result
# Print result and transaction hash
if stxn_result["meta"]["TransactionResult"] == "tesSUCCESS":
print(f'Successfully enabled no freeze for {sender_wallet.classic_address}')
print(f'Successfully enabled no freeze for {sender_wallet.address}')
if stxn_result["meta"]["TransactionResult"] == "tecNO_LINE_REDUNDANT":
print("This was used on an account which didn't have a trustline yet. To try this out, modify `target_addr` to point to an account with a frozen trustline, and make sure the currency code matches.")
else:

2
content/_code-samples/get-started/py/get-acct-info.py
View File

@@ -10,7 +10,7 @@ from xrpl.wallet import generate_faucet_wallet
test_wallet = generate_faucet_wallet(client, debug=True)
# Create an account str from the wallet
test_account = test_wallet.classic_address
test_account = test_wallet.address
# Derive an x-address from the classic address:
# https://xrpaddress.info/

16
content/_code-samples/get-started/py/prepare-payment.py
View File

@@ -11,7 +11,7 @@ from xrpl.wallet import generate_faucet_wallet
test_wallet = generate_faucet_wallet(client, debug=True)
# Create an account str from the wallet
test_account = test_wallet.classic_address
test_account = test_wallet.address
# Derive an x-address from the classic address:
# https://xrpaddress.info/
@@ -32,18 +32,10 @@ my_tx_payment = Payment(
# print prepared payment
print(my_tx_payment)
# Sign the transaction
from xrpl.transaction import safe_sign_and_autofill_transaction
# Sign and submit the transaction
from xrpl.transaction import submit_and_wait
my_tx_payment_signed = safe_sign_and_autofill_transaction(my_tx_payment, test_wallet, client)
# Print signed tx
print("Signed tx:", my_tx_payment_signed)
# Submit and send the transaction
from xrpl.transaction import send_reliable_submission
tx_response = send_reliable_submission(my_tx_payment_signed, client)
tx_response = submit_and_wait(my_tx_payment, client, test_wallet)
# Print tx response
print("Tx response:", tx_response)

58
content/_code-samples/issue-a-token/py/issue-a-token.py
View File

@@ -19,90 +19,74 @@ hot_wallet = generate_faucet_wallet(client, debug=True)
# Configure issuer (cold address) settings -------------------------------------
cold_settings_tx = xrpl.models.transactions.AccountSet(
account=cold_wallet.classic_address,
account=cold_wallet.address,
transfer_rate=0,
tick_size=5,
domain=bytes.hex("example.com".encode("ASCII")),
set_flag=xrpl.models.transactions.AccountSetFlag.ASF_DEFAULT_RIPPLE,
)
cst_prepared = xrpl.transaction.safe_sign_and_autofill_transaction(
transaction=cold_settings_tx,
wallet=cold_wallet,
client=client,
set_flag=xrpl.models.transactions.AccountSetAsfFlag.ASF_DEFAULT_RIPPLE,
)
print("Sending cold address AccountSet transaction...")
response = xrpl.transaction.send_reliable_submission(cst_prepared, client)
response = xrpl.transaction.submit_and_wait(cold_settings_tx, client, cold_wallet)
print(response)
# Configure hot address settings -----------------------------------------------
hot_settings_tx = xrpl.models.transactions.AccountSet(
account=hot_wallet.classic_address,
set_flag=xrpl.models.transactions.AccountSetFlag.ASF_REQUIRE_AUTH,
)
hst_prepared = xrpl.transaction.safe_sign_and_autofill_transaction(
transaction=hot_settings_tx,
wallet=hot_wallet,
client=client,
account=hot_wallet.address,
set_flag=xrpl.models.transactions.AccountSetAsfFlag.ASF_REQUIRE_AUTH,
)
print("Sending hot address AccountSet transaction...")
response = xrpl.transaction.send_reliable_submission(hst_prepared, client)
response = xrpl.transaction.submit_and_wait(hot_settings_tx, client, hot_wallet)
print(response)
# Create trust line from hot to cold address -----------------------------------
currency_code = "FOO"
trust_set_tx = xrpl.models.transactions.TrustSet(
account=hot_wallet.classic_address,
account=hot_wallet.address,
limit_amount=xrpl.models.amounts.issued_currency_amount.IssuedCurrencyAmount(
currency=currency_code,
issuer=cold_wallet.classic_address,
issuer=cold_wallet.address,
value="10000000000", # Large limit, arbitrarily chosen
)
)
ts_prepared = xrpl.transaction.safe_sign_and_autofill_transaction(
transaction=trust_set_tx,
wallet=hot_wallet,
client=client,
)
print("Creating trust line from hot address to issuer...")
response = xrpl.transaction.send_reliable_submission(ts_prepared, client)
response = xrpl.transaction.submit_and_wait(trust_set_tx, client, hot_wallet)
print(response)
# Send token -------------------------------------------------------------------
issue_quantity = "3840"
send_token_tx = xrpl.models.transactions.Payment(
account=cold_wallet.classic_address,
destination=hot_wallet.classic_address,
account=cold_wallet.address,
destination=hot_wallet.address,
amount=xrpl.models.amounts.issued_currency_amount.IssuedCurrencyAmount(
currency=currency_code,
issuer=cold_wallet.classic_address,
issuer=cold_wallet.address,
value=issue_quantity
)
)
pay_prepared = xrpl.transaction.safe_sign_and_autofill_transaction(
transaction=send_token_tx,
wallet=cold_wallet,
client=client,
)
print(f"Sending {issue_quantity} {currency_code} to {hot_wallet.classic_address}...")
response = xrpl.transaction.send_reliable_submission(pay_prepared, client)
print(f"Sending {issue_quantity} {currency_code} to {hot_wallet.address}...")
response = xrpl.transaction.submit_and_wait(send_token_tx, client, cold_wallet)
print(response)
# Check balances ---------------------------------------------------------------
print("Getting hot address balances...")
response = client.request(xrpl.models.requests.AccountLines(
account=hot_wallet.classic_address,
account=hot_wallet.address,
ledger_index="validated",
))
print(response)
print("Getting cold address balances...")
response = client.request(xrpl.models.requests.GatewayBalances(
account=cold_wallet.classic_address,
account=cold_wallet.address,
ledger_index="validated",
hotwallet=[hot_wallet.classic_address]
hotwallet=[hot_wallet.address]
))
print(response)

14
content/_code-samples/multisigning/py/multisigning.py
View File

@@ -10,7 +10,7 @@ from xrpl.transaction import (
autofill,
autofill_and_sign,
multisign,
send_reliable_submission,
submit_and_wait,
sign,
)
from xrpl.utils import str_to_hex
@@ -25,18 +25,18 @@ signer_wallet_1 = generate_faucet_wallet(client, debug=True)
signer_wallet_2 = generate_faucet_wallet(client, debug=True)
signer_entries = [
SignerEntry(account=signer_wallet_1.classic_address, signer_weight=1),
SignerEntry(account=signer_wallet_2.classic_address, signer_weight=1),
SignerEntry(account=signer_wallet_1.address, signer_weight=1),
SignerEntry(account=signer_wallet_2.address, signer_weight=1),
]
signer_list_set_tx = SignerListSet(
account=master_wallet.classic_address,
account=master_wallet.address,
signer_quorum=2,
signer_entries=signer_entries,
)
signed_signer_list_set_tx = autofill_and_sign(signer_list_set_tx, master_wallet, client)
signed_signer_list_set_tx = autofill_and_sign(signer_list_set_tx, client, master_wallet)
print("Constructed SignerListSet and submitting it to the ledger...")
signed_list_set_tx_response = send_reliable_submission(
signed_list_set_tx_response = submit_and_wait(
signed_signer_list_set_tx, client
)
print("SignerListSet submitted, here's the response:")
@@ -45,7 +45,7 @@ print(signed_list_set_tx_response)
# Now that we've set up multisigning, let's try using it to submit an AccountSet
# transaction.
account_set_tx = AccountSet(
account=master_wallet.classic_address, domain=str_to_hex("example.com")
account=master_wallet.address, domain=str_to_hex("example.com")
)
autofilled_account_set_tx = autofill(account_set_tx, client, len(signer_entries))
print("AccountSet transaction is ready to be multisigned")

20
content/_code-samples/non-fungible-token/py/authorize-minter.py
View File

@@ -1,6 +1,6 @@
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_mint import NFTokenMint, NFTokenMintFlag
from xrpl.models.transactions.account_set import AccountSet, AccountSetFlag
from xrpl.models.transactions.account_set import AccountSet, AccountSetAsfFlag
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountNFTs
from xrpl.clients import JsonRpcClient
@@ -14,7 +14,7 @@ seed = ""
custom_wallet = None
if seed:
custom_wallet = Wallet(seed=seed, sequence=0)
custom_wallet = Wallet.from_seed(seed=seed)
# Connect to a testnet node
print("Connecting to Testnet...")
@@ -23,12 +23,12 @@ client = JsonRpcClient(JSON_RPC_URL)
# Initialize wallet from seed
issuer_wallet = generate_faucet_wallet(client=client, wallet=custom_wallet)
issuerAddr = issuer_wallet.classic_address
issuerAddr = issuer_wallet.address
# Get minter account credentials from the testnet faucet
print("Requesting address from the Testnet faucet...")
nftoken_minter_wallet = generate_faucet_wallet(client=client)
minterAddr = nftoken_minter_wallet.classic_address
minterAddr = nftoken_minter_wallet.address
print(f"\nMinter Account: {issuerAddr}")
print(f" Seed: {issuer_wallet.seed}")
@@ -40,13 +40,12 @@ print(f" Seed: {nftoken_minter_wallet.seed}")
print(f"\nAuthorizing account {minterAddr} as a NFT minter on account {issuerAddr}...")
authorize_minter_tx = AccountSet(
account=issuerAddr,
set_flag=AccountSetFlag.ASF_AUTHORIZED_NFTOKEN_MINTER,
set_flag=AccountSetAsfFlag.ASF_AUTHORIZED_NFTOKEN_MINTER,
nftoken_minter=minterAddr
)
# Sign authorize_minter_tx using issuer account
authorize_minter_tx_signed = safe_sign_and_autofill_transaction(transaction=authorize_minter_tx, wallet=issuer_wallet, client=client)
authorize_minter_tx_signed = send_reliable_submission(transaction=authorize_minter_tx_signed, client=client)
# Sign and submit authorize_minter_tx using issuer account
authorize_minter_tx_signed = submit_and_wait(transaction=authorize_minter_tx, client=client, wallet=issuer_wallet)
authorize_minter_tx_result = authorize_minter_tx_signed.result
print(f"\nAuthorize minter tx result: {authorize_minter_tx_result}")
@@ -67,8 +66,7 @@ mint_tx_1 = NFTokenMint(
# Sign using previously authorized minter's account, this will result in the NFT's issuer field to be the Issuer Account
# while the NFT's owner would be the Minter Account
mint_tx_1_signed = safe_sign_and_autofill_transaction(transaction=mint_tx_1, wallet=nftoken_minter_wallet, client=client)
mint_tx_1_signed = send_reliable_submission(transaction=mint_tx_1_signed, client=client)
mint_tx_1_signed = submit_and_wait(transaction=mint_tx_1, client=client, wallet=nftoken_minter_wallet)
mint_tx_1_result = mint_tx_1_signed.result
print(f"\n Mint tx result: {mint_tx_1_result['meta']['TransactionResult']}")
print(f" Tx response: {mint_tx_1_result}")

13
content/_code-samples/non-fungible-token/py/burn-nft.py
View File

@@ -1,4 +1,4 @@
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_burn import NFTokenBurn
from xrpl.models.requests import AccountNFTs
from xrpl.clients import JsonRpcClient
@@ -22,8 +22,8 @@ else:
client = JsonRpcClient(JSON_RPC_URL)
# Initialize wallet from seed
issuer_wallet = Wallet(seed=seed, sequence=0)
issuerAddr = issuer_wallet.classic_address
issuer_wallet = Wallet.from_seed(seed=seed)
issuerAddr = issuer_wallet.address
print(f"\nIssuer Account: {issuerAddr}")
print(f" Seed: {issuer_wallet.seed}")
@@ -52,10 +52,9 @@ else:
nftoken_id=get_account_nfts.result['account_nfts'][0]['NFTokenID']
)
# Sign burn_tx using the issuer account
burn_tx_signed = safe_sign_and_autofill_transaction(transaction=burn_tx, wallet=issuer_wallet, client=client)
burn_tx_signed = send_reliable_submission(transaction=burn_tx_signed, client=client)
burn_tx_result = burn_tx_signed.result
# Sign and submit burn_tx using the issuer account
burn_tx_response = submit_and_wait(transaction=burn_tx, client=client, wallet=issuer_wallet)
burn_tx_result = burn_tx_response.result
print(f"\nBurn tx result: {burn_tx_result['meta']['TransactionResult']}")
print(f" Tx response:{burn_tx_result}")

14
content/_code-samples/non-fungible-token/py/cancel-offer-nft.py
View File

@@ -1,4 +1,4 @@
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_cancel_offer import NFTokenCancelOffer
from xrpl.models.requests import AccountObjects, AccountObjectType
from xrpl.clients import JsonRpcClient
@@ -22,8 +22,8 @@ else:
client = JsonRpcClient(JSON_RPC_URL)
# Initialize wallet from seed
wallet = Wallet(seed=seed, sequence=0)
Addr = wallet.classic_address
wallet = Wallet.from_seed(seed=seed)
Addr = wallet.address
print(f"\n Account: {Addr}")
print(f" Seed: {seed}")
@@ -60,11 +60,9 @@ else:
]
)
# Sign cancel_sell_offer_tx using minter account
cancel_sell_offer_tx_signed = safe_sign_and_autofill_transaction(transaction=cancel_sell_offer_tx, wallet=wallet,
client=client)
cancel_sell_offer_tx_signed = send_reliable_submission(transaction=cancel_sell_offer_tx_signed, client=client)
cancel_sell_offer_tx_result = cancel_sell_offer_tx_signed.result
# Sign and submit cancel_sell_offer_tx using minter account
cancel_sell_offer_tx_response = submit_and_wait(transaction=cancel_sell_offer_tx, client=client, wallet=wallet)
cancel_sell_offer_tx_result = cancel_sell_offer_tx_response.result
print(f"\n Cancel Sell Offer tx result: {cancel_sell_offer_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {cancel_sell_offer_tx_result}")

13
content/_code-samples/non-fungible-token/py/create-buy-offer-nft.py
View File

@@ -1,4 +1,4 @@
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_create_offer import NFTokenCreateOffer
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountNFTs
@@ -24,13 +24,13 @@ else:
client = JsonRpcClient(JSON_RPC_URL)
# Initialize wallet from seed
issuer_wallet = Wallet(seed=seed, sequence=0)
issuerAddr = issuer_wallet.classic_address
issuer_wallet = Wallet.from_seed(seed=seed)
issuerAddr = issuer_wallet.address
# Get buyer account credentials from the testnet faucet
print("Requesting address from the Testnet faucet...")
buyer_wallet = generate_faucet_wallet(client=client)
buyerAddr = buyer_wallet.classic_address
buyerAddr = buyer_wallet.address
print(f"\n Minter Account: {issuerAddr}")
print(f" Seed: {issuer_wallet.seed}")
@@ -56,9 +56,8 @@ else:
amount=buy_offer_amount, # 10 XRP in drops, 1 XRP = 1,000,000 drops
)
# Sign buy_tx using the issuer account
buy_tx_signed = safe_sign_and_autofill_transaction(transaction=buy_tx, wallet=buyer_wallet, client=client)
buy_tx_signed = send_reliable_submission(transaction=buy_tx_signed, client=client)
# Sign and submit buy_tx using the issuer account
buy_tx_signed = submit_and_wait(transaction=buy_tx, client=client, wallet=buyer_wallet)
buy_tx_result = buy_tx_signed.result
print(f"\n NFTokenCreateOffer tx result: {buy_tx_result['meta']['TransactionResult']}")

11
content/_code-samples/non-fungible-token/py/create-sell-offer-nft.py
View File

@@ -1,5 +1,5 @@
from xrpl.models.transactions.nftoken_create_offer import NFTokenCreateOffer, NFTokenCreateOfferFlag
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.requests import AccountNFTs
from xrpl.clients import JsonRpcClient
from xrpl.models import NFTSellOffers
@@ -23,8 +23,8 @@ else:
client = JsonRpcClient(JSON_RPC_URL)
# Initialize wallet from seed
issuer_wallet = Wallet(seed=seed, sequence=0)
issuerAddr = issuer_wallet.classic_address
issuer_wallet = Wallet.from_seed(seed=seed)
issuerAddr = issuer_wallet.address
print(f"\nIssuer Account: {issuerAddr}")
print(f" Seed: {issuer_wallet.seed}")
@@ -55,9 +55,8 @@ else:
)
# Sign sell_tx using the issuer account
sell_tx_signed = safe_sign_and_autofill_transaction(transaction=sell_tx, wallet=issuer_wallet, client=client)
sell_tx_signed = send_reliable_submission(transaction=sell_tx_signed, client=client)
sell_tx_result = sell_tx_signed.result
sell_tx_response = submit_and_wait(transaction=sell_tx, client=client, wallet=issuer_wallet)
sell_tx_result = sell_tx_response.result
print(f"\n Sell Offer tx result: {sell_tx_result['meta']['TransactionResult']}")
print(f" Tx response: {sell_tx_result}")

13
content/_code-samples/non-fungible-token/py/mint-nft.py
View File

@@ -1,4 +1,4 @@
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_mint import NFTokenMint, NFTokenMintFlag
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountNFTs
@@ -22,10 +22,10 @@ client = JsonRpcClient(JSON_RPC_URL)
if seed == "":
print("Requesting address from the Testnet faucet...")
issuer_wallet = generate_faucet_wallet(client=client)
issuerAddr = issuer_wallet.classic_address
issuerAddr = issuer_wallet.address
else:
issuer_wallet = Wallet(seed=seed, sequence=0)
issuerAddr = issuer_wallet.classic_address
issuer_wallet = Wallet.from_seed(seed=seed)
issuerAddr = issuer_wallet.address
print(f"\nIssuer Account: {issuerAddr}")
print(f" Seed: {issuer_wallet.seed}")
@@ -39,9 +39,8 @@ mint_tx = NFTokenMint(
)
# Sign mint_tx using the issuer account
mint_tx_signed = safe_sign_and_autofill_transaction(transaction=mint_tx, wallet=issuer_wallet, client=client)
mint_tx_signed = send_reliable_submission(transaction=mint_tx_signed, client=client)
mint_tx_result = mint_tx_signed.result
mint_tx_response = submit_and_wait(transaction=mint_tx, client=client, wallet=issuer_wallet)
mint_tx_result = mint_tx_response.result
print(f"\n Mint tx result: {mint_tx_result['meta']['TransactionResult']}")
print(f" Tx response: {mint_tx_result}")

58
content/_code-samples/non-fungible-token/py/nft-general.py
View File

@@ -1,9 +1,9 @@
from xrpl.models.transactions.nftoken_create_offer import NFTokenCreateOffer, NFTokenCreateOfferFlag
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.models.transactions.nftoken_mint import NFTokenMint, NFTokenMintFlag
from xrpl.models.transactions.nftoken_accept_offer import NFTokenAcceptOffer
from xrpl.models.transactions.nftoken_cancel_offer import NFTokenCancelOffer
from xrpl.models.transactions.account_set import AccountSet, AccountSetFlag
from xrpl.models.transactions.account_set import AccountSet, AccountSetAsfFlag
from xrpl.models.transactions.nftoken_burn import NFTokenBurn
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountNFTs
@@ -38,13 +38,13 @@ client = JsonRpcClient(JSON_RPC_URL)
# Get issuer, minter, buyer account credentials from the Testnet Faucet
print("Requesting address from the Testnet faucet...")
issuer_wallet = generate_faucet_wallet(client=client)
issuerAddr = issuer_wallet.classic_address
issuerAddr = issuer_wallet.address
nftoken_minter_wallet = generate_faucet_wallet(client=client)
minterAddr = nftoken_minter_wallet.classic_address
minterAddr = nftoken_minter_wallet.address
buyer_wallet = generate_faucet_wallet(client=client)
buyerAddr = buyer_wallet.classic_address
buyerAddr = buyer_wallet.address
print(f" Minter Account: {issuerAddr}"
f"\n Authorized Minter Account: {minterAddr}"
@@ -57,10 +57,9 @@ mint_tx = NFTokenMint(
nftoken_taxon=0
)
# Sign mint_tx using issuer account
mint_tx_signed = safe_sign_and_autofill_transaction(transaction=mint_tx, wallet=issuer_wallet, client=client)
mint_tx_signed = send_reliable_submission(transaction=mint_tx_signed, client=client)
mint_tx_result = mint_tx_signed.result
# Sign and submit mint_tx using issuer account
mint_tx_response = submit_and_wait(transaction=mint_tx, client=client, wallet=issuer_wallet)
mint_tx_result = mint_tx_response.result
print(f"\n Mint tx result: {mint_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {mint_tx_result}")
@@ -81,9 +80,8 @@ burn_tx = NFTokenBurn(
)
# Sign burn_tx using issuer account
burn_tx_signed = safe_sign_and_autofill_transaction(transaction=burn_tx, wallet=issuer_wallet, client=client)
burn_tx_signed = send_reliable_submission(transaction=burn_tx_signed, client=client)
burn_tx_result = burn_tx_signed.result
burn_tx_response = submit_and_wait(transaction=burn_tx, client=client, wallet=issuer_wallet)
burn_tx_result = burn_tx_response.result
print(f"\n Burn tx result: {burn_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {burn_tx_result}")
@@ -96,14 +94,13 @@ else:
print(f"\n - Authorizing account {minterAddr} as a NFT minter on account {issuerAddr}...")
authorize_minter_tx = AccountSet(
account=issuerAddr,
set_flag=AccountSetFlag.ASF_AUTHORIZED_NFTOKEN_MINTER,
set_flag=AccountSetAsfFlag.ASF_AUTHORIZED_NFTOKEN_MINTER,
nftoken_minter=minterAddr
)
# Sign authorize_minter_tx using issuer account
authorize_minter_tx_signed = safe_sign_and_autofill_transaction(transaction=authorize_minter_tx, wallet=issuer_wallet, client=client)
authorize_minter_tx_signed = send_reliable_submission(transaction=authorize_minter_tx_signed, client=client)
authorize_minter_tx_result = authorize_minter_tx_signed.result
authorize_minter_tx_response = submit_and_wait(transaction=authorize_minter_tx, client=client, wallet=issuer_wallet)
authorize_minter_tx_result = authorize_minter_tx_response.result
print(f"\n Authorize minter tx result: {authorize_minter_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {authorize_minter_tx_result}")
@@ -125,9 +122,8 @@ mint_tx_1 = NFTokenMint(
# Sign using previously authorized minter's account, this will result in the NFT's issuer field to be the Issuer Account
# while the NFT's owner would be the Minter Account
mint_tx_1_signed = safe_sign_and_autofill_transaction(transaction=mint_tx_1, wallet=nftoken_minter_wallet, client=client)
mint_tx_1_signed = send_reliable_submission(transaction=mint_tx_1_signed, client=client)
mint_tx_1_result = mint_tx_1_signed.result
mint_tx_1_response = submit_and_wait(transaction=mint_tx_1, client=client, wallet=nftoken_minter_wallet)
mint_tx_1_result = mint_tx_1_response.result
print(f"\n Mint tx result: {mint_tx_1_result['meta']['TransactionResult']}"
f"\n Tx response: {mint_tx_1_result}")
@@ -154,10 +150,9 @@ sell_tx = NFTokenCreateOffer(
flags=NFTokenCreateOfferFlag.TF_SELL_NFTOKEN,
)
# Sign sell_tx using minter account
sell_tx_signed = safe_sign_and_autofill_transaction(transaction=sell_tx, wallet=nftoken_minter_wallet, client=client)
sell_tx_signed = send_reliable_submission(transaction=sell_tx_signed, client=client)
sell_tx_result = sell_tx_signed.result
# Sign and submit sell_tx using minter account
sell_tx_response = submit_and_wait(transaction=sell_tx, client=client, wallet=nftoken_minter_wallet)
sell_tx_result = sell_tx_response.result
print(f"\n Sell Offer tx result: {sell_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {sell_tx_result}")
@@ -178,9 +173,8 @@ cancel_sell_offer_tx = NFTokenCancelOffer(
)
# Sign cancel_sell_offer_tx using minter account
cancel_sell_offer_tx_signed = safe_sign_and_autofill_transaction(transaction=cancel_sell_offer_tx, wallet=nftoken_minter_wallet, client=client)
cancel_sell_offer_tx_signed = send_reliable_submission(transaction=cancel_sell_offer_tx_signed, client=client)
cancel_sell_offer_tx_result = cancel_sell_offer_tx_signed.result
cancel_sell_offer_tx_response = submit_and_wait(transaction=cancel_sell_offer_tx, client=client, wallet=nftoken_minter_wallet)
cancel_sell_offer_tx_result = cancel_sell_offer_tx_response.result
print(f"\n Cancel Sell Offer tx result: {cancel_sell_offer_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {cancel_sell_offer_tx_result}")
@@ -193,10 +187,9 @@ sell_1_tx = NFTokenCreateOffer(
flags=NFTokenCreateOfferFlag.TF_SELL_NFTOKEN,
)
# Sign sell_1_tx using minter account
sell_1_tx_signed = safe_sign_and_autofill_transaction(transaction=sell_1_tx, wallet=nftoken_minter_wallet, client=client)
sell_1_tx_signed = send_reliable_submission(transaction=sell_1_tx_signed, client=client)
sell_1_tx_result = sell_1_tx_signed.result
# Sign and submit sell_1_tx using minter account
sell_1_tx_response = submit_and_wait(transaction=sell_1_tx, client=client, wallet=nftoken_minter_wallet)
sell_1_tx_result = sell_1_tx_response.result
print(f"\n Sell Offer tx result: {sell_1_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {sell_1_tx_result}")
@@ -217,8 +210,7 @@ buy_tx = NFTokenAcceptOffer(
)
# Sign buy_tx using buyer account
buy_tx_signed = safe_sign_and_autofill_transaction(transaction=buy_tx, wallet=buyer_wallet, client=client)
buy_tx_signed = send_reliable_submission(transaction=buy_tx_signed, client=client)
buy_tx_result = buy_tx_signed.result
buy_tx_response = submit_and_wait(transaction=buy_tx, client=client, wallet=buyer_wallet)
buy_tx_result = buy_tx_response.result
print(f"\n Buy Offer result: {buy_tx_result['meta']['TransactionResult']}"
f"\n Tx response: {buy_tx_result}")

53
content/_code-samples/partial-payment/py/partial-payment.py
View File

@@ -3,7 +3,7 @@ from xrpl.clients import JsonRpcClient
from xrpl.models.amounts import IssuedCurrencyAmount
from xrpl.models.requests import AccountLines
from xrpl.models.transactions import Payment, PaymentFlag, TrustSet
from xrpl.transaction import autofill_and_sign, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
# References
@@ -21,48 +21,46 @@ wallet2 = generate_faucet_wallet(client, debug=True)
# Create a TrustSet to issue an IOU `FOO` and set limit on it
trust_set_tx = TrustSet(
account=wallet2.classic_address,
account=wallet2.address,
limit_amount=IssuedCurrencyAmount(
currency="FOO",
value="10000000000",
issuer=wallet1.classic_address,
issuer=wallet1.address,
),
)
# Sign and autofill, then send transaction to the ledger
signed_trust_set_tx = autofill_and_sign(trust_set_tx, wallet2, client)
send_reliable_submission(signed_trust_set_tx, client)
signed_trust_set_tx = submit_and_wait(trust_set_tx, client, wallet2)
# Both balances should be zero since nothing has been sent yet
print("Balances after trustline is claimed:")
print("Balance of ${wallet1.classic_address} is:")
print((client.request(AccountLines(account=wallet1.classic_address))).result["lines"])
print("Balance of ${wallet2.classic_address} is:")
print((client.request(AccountLines(account=wallet2.classic_address))).result["lines"])
print("Balance of ${wallet1.address} is:")
print((client.request(AccountLines(account=wallet1.address))).result["lines"])
print("Balance of ${wallet2.address} is:")
print((client.request(AccountLines(account=wallet2.address))).result["lines"])
# Create a Payment to send 3840 FOO from wallet1 (issuer) to destination (wallet2)
issue_quantity = "3840"
payment_tx = Payment(
account=wallet1.classic_address,
account=wallet1.address,
amount=IssuedCurrencyAmount(
currency="FOO",
value=issue_quantity,
issuer=wallet1.classic_address,
issuer=wallet1.address,
),
destination=wallet2.classic_address,
destination=wallet2.address,
)
# Sign and autofill, then send transaction to the ledger
signed_payment_tx = autofill_and_sign(payment_tx, wallet1, client)
payment_response = send_reliable_submission(signed_payment_tx, client)
payment_response = submit_and_wait(payment_tx, client, wallet1)
print("Initial Payment response: ", payment_response)
# Issuer (wallet1) should have -3840 FOO and destination (wallet2) should have 3840 FOO
print("Balances after wallet1 sends 3840 FOO to wallet2:")
print("Balance of ${wallet1.classic_address} is:")
print((client.request(AccountLines(account=wallet1.classic_address))).result["lines"])
print("Balance of ${wallet2.classic_address} is:")
print((client.request(AccountLines(account=wallet2.classic_address))).result["lines"])
print("Balance of ${wallet1.address} is:")
print((client.request(AccountLines(account=wallet1.address))).result["lines"])
print("Balance of ${wallet2.address} is:")
print((client.request(AccountLines(account=wallet2.address))).result["lines"])
# Send money less than the amount specified on 2 conditions:
# 1. Sender has less money than the amount specified in the payment Tx.
@@ -74,29 +72,28 @@ print((client.request(AccountLines(account=wallet2.classic_address))).result["li
# Create Payment to send 4000 (of 3840) FOO from wallet2 to wallet1
partial_payment_tx = Payment(
account=wallet2.classic_address,
account=wallet2.address,
amount=IssuedCurrencyAmount(
currency="FOO",
value="4000",
issuer=wallet1.classic_address,
issuer=wallet1.address,
),
destination=wallet1.classic_address,
destination=wallet1.address,
flags=[PaymentFlag.TF_PARTIAL_PAYMENT],
send_max=IssuedCurrencyAmount(
currency="FOO",
value="1000000",
issuer=wallet1.classic_address,
issuer=wallet1.address,
),
)
# Sign and autofill, then send transaction to the ledger
signed_partial_payment_tx = autofill_and_sign(partial_payment_tx, wallet2, client)
partial_payment_response = send_reliable_submission(signed_partial_payment_tx, client)
partial_payment_response = submit_and_wait(partial_payment_tx, client, wallet2)
print("Partial Payment response: ", partial_payment_response)
# Tried sending 4000 of 3840 FOO -> wallet1 and wallet2 should have 0 FOO
print("Balances after Partial Payment, when wallet2 tried to send 4000 FOOs")
print("Balance of ${wallet1.classic_address} is:")
print((client.request(AccountLines(account=wallet1.classic_address))).result["lines"])
print("Balance of ${wallet2.classic_address} is:")
print((client.request(AccountLines(account=wallet2.classic_address))).result["lines"])
print("Balance of ${wallet1.address} is:")
print((client.request(AccountLines(account=wallet1.address))).result["lines"])
print("Balance of ${wallet2.address} is:")
print((client.request(AccountLines(account=wallet2.address))).result["lines"])

6
content/_code-samples/paths/py/paths.py
View File

@@ -27,7 +27,7 @@ destination_amount = IssuedCurrencyAmount(
# Create a RipplePathFind request and have the client call it
path_request = RipplePathFind(
source_account=wallet.classic_address,
source_account=wallet.address,
source_currencies=[XRP()],
destination_account=destination_account,
destination_amount=destination_amount,
@@ -41,10 +41,10 @@ print(paths)
# # Create a Payment to send money from wallet to destination_account using path
payment_tx = Payment(
account=wallet.classic_address,
account=wallet.address,
amount=destination_amount,
destination=destination_account,
paths=paths,
)
print("signed: ", autofill_and_sign(payment_tx, wallet, client))
print("signed: ", autofill_and_sign(payment_tx, client, wallet))

21
content/_code-samples/reliable-tx-submission/py/reliable_transaction-submission.py
View File

@@ -3,7 +3,7 @@ from xrpl.account import get_balance
from xrpl.clients import JsonRpcClient
from xrpl.models.requests import Tx
from xrpl.models.transactions import Payment
from xrpl.transaction import autofill_and_sign, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
# References:
@@ -20,21 +20,18 @@ wallet2 = generate_faucet_wallet(client, debug=True)
# Both balances should be zero since nothing has been sent yet
print("Balances of wallets before Payment tx")
print(get_balance(wallet1.classic_address, client))
print(get_balance(wallet2.classic_address, client))
print(get_balance(wallet1.address, client))
print(get_balance(wallet2.address, client))
# Create a Payment transaction
payment_tx = Payment(
account=wallet1.classic_address,
account=wallet1.address,
amount="1000",
destination=wallet2.classic_address,
destination=wallet2.address,
)
# Sign and autofill the transaction (prepares it to be ready to submit)
signed_payment_tx = autofill_and_sign(payment_tx, wallet1, client)
# Submits transaction and waits for response (validated or rejected)
payment_response = send_reliable_submission(signed_payment_tx, client)
# Autofill, sign, and submit the transaction
payment_response = submit_and_wait(payment_tx, client, wallet1)
print("Transaction was submitted")
# Create a Transaction request to see transaction
@@ -45,5 +42,5 @@ print("Validated:", tx_response.result["validated"])
# Check balances after 1000 was sent from wallet1 to wallet2
print("Balances of wallets after Payment tx:")
print(get_balance(wallet1.classic_address, client))
print(get_balance(wallet2.classic_address, client))
print(get_balance(wallet1.address, client))
print(get_balance(wallet2.address, client))

20
content/_code-samples/require-destination-tags/py/require-destination-tags.py
View File

@@ -2,14 +2,14 @@ import asyncio
from xrpl.asyncio.clients import AsyncWebsocketClient
from xrpl.asyncio.transaction import (
safe_sign_and_autofill_transaction,
send_reliable_submission,
autofill_and_sign,
submit_and_wait,
)
from xrpl.asyncio.wallet import generate_faucet_wallet
from xrpl.models.requests import AccountInfo
from xrpl.models.transactions import (
AccountSet,
AccountSetFlag,
AccountSetAsfFlag,
)
@@ -22,24 +22,24 @@ async def main() -> int:
# Send AccountSet transaction -----------------------------------------------
tx = AccountSet(
account=wallet.classic_address,
set_flag=AccountSetFlag.ASF_REQUIRE_DEST,
account=wallet.address,
set_flag=AccountSetAsfFlag.ASF_REQUIRE_DEST,
)
# Sign and autofill the transaction (ready to submit)
signed_tx = await safe_sign_and_autofill_transaction(tx, wallet, client)
signed_tx = await autofill_and_sign(tx, client, wallet)
print("Transaction hash:", signed_tx.get_hash())
# Submit the transaction and wait for response (validated or rejected)
print("Submitting transaction...")
submit_result = await send_reliable_submission(signed_tx, client)
submit_result = await submit_and_wait(signed_tx, client)
print("Submit result:", submit_result)
# Confirm Account Settings --------------------------------------------------
print("Requesting account information...")
account_info = await client.request(
AccountInfo(
account=wallet.classic_address,
account=wallet.address,
ledger_index="validated",
)
)
@@ -47,9 +47,9 @@ async def main() -> int:
# Verify that the AccountRoot lsfRequireDestTag flag is set
flags = account_info.result["account_data"]["Flags"]
if flags & 0x00020000 != 0:
print(f"Require Destination Tag for account {wallet.classic_address} is enabled.")
print(f"Require Destination Tag for account {wallet.address} is enabled.")
else:
print(f"Require Destination Tag for account {wallet.classic_address} is DISABLED.")
print(f"Require Destination Tag for account {wallet.address} is DISABLED.")
# End main()
return 0

16
content/_code-samples/secure-signing/py/sign-payment.py
View File

@@ -2,21 +2,27 @@
import os
my_secret = os.getenv("MYSECRET")
from xrpl.wallet import Wallet
wallet = Wallet(seed=my_secret, sequence=16237283)
print(wallet.classic_address) # "raaFKKmgf6CRZttTVABeTcsqzRQ51bNR6Q"
wallet = Wallet.from_seed(seed=my_secret)
print(wallet.address) # "raaFKKmgf6CRZttTVABeTcsqzRQ51bNR6Q"
# For offline signing, you need to know your address's next Sequence number.
# Alternatively, you could use a Ticket in place of the Sequence number.
# This is useful when you need multiple signatures and may want to process transactions out-of-order.
# For details, see: https://xrpl.org/tickets.html
sequence = 0
from xrpl.models.transactions import Payment
from xrpl.utils import xrp_to_drops
my_payment = Payment(
account=wallet.classic_address,
account=wallet.address,
amount=xrp_to_drops(22),
fee="10",
destination="rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
sequence=wallet.sequence, # this needs to be incremented upon every successful transaction
sequence=sequence,
)
print("Payment object:", my_payment)
# Sign transaction -------------------------------------------------------------
import xrpl.transaction
signed = xrpl.transaction.safe_sign_transaction(my_payment, wallet)
signed = xrpl.transaction.sign(my_payment, wallet)
print("Signed transaction blob:", signed)

8
content/_code-samples/send-a-memo/py/send-a-memo.py
View File

@@ -1,6 +1,6 @@
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import Payment, Memo
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.transaction import autofill_and_sign, submit_and_wait
from xrpl.wallet import generate_faucet_wallet
# This code sample validates and sends a transaction with a Memo attached
@@ -14,7 +14,7 @@ client = JsonRpcClient(JSON_RPC_URL)
# Get account credentials from the Testnet Faucet
print("Requesting an account from the Testnet faucet...")
test_wallet = generate_faucet_wallet(client=client)
myAddr = test_wallet.classic_address
myAddr = test_wallet.address
memo_data = "Example Memo - 123 -=+"
memo_type = "Text"
@@ -42,11 +42,11 @@ payment_tx = Payment(
# Sign the transaction
print("Submitting a payment transaction with our memo...")
payment_tx_signed = safe_sign_and_autofill_transaction(payment_tx, wallet=test_wallet, client=client)
payment_tx_signed = autofill_and_sign(payment_tx, client=client, wallet=test_wallet)
print(f"\n Encoded Transaction MEMO: {payment_tx_signed.memos}")
# Send the transaction to the node
submit_tx_regular = send_reliable_submission(client=client, transaction=payment_tx_signed)
submit_tx_regular = submit_and_wait(transaction=payment_tx_signed, client=client)
submit_tx_regular = submit_tx_regular.result
tx_MemoData = bytes.fromhex(submit_tx_regular['Memos'][0]['Memo']['MemoData']).decode('utf-8')

15
content/_code-samples/send-xrp/py/send-xrp.py
View File

@@ -1,7 +1,8 @@
# Example Credentials ----------------------------------------------------------
from xrpl.wallet import Wallet
test_wallet = Wallet(seed="sn3nxiW7v8KXzPzAqzyHXbSSKNuN9", sequence=16237283)
print(test_wallet.classic_address) # "rMCcNuTcajgw7YTgBy1sys3b89QqjUrMpH"
from xrpl.constants import CryptoAlgorithm
test_wallet = Wallet.from_seed(seed="sn3nxiW7v8KXzPzAqzyHXbSSKNuN9", algorithm=CryptoAlgorithm.SECP256K1)
print(test_wallet.address) # "rMCcNuTcajgw7YTgBy1sys3b89QqjUrMpH"
# Connect ----------------------------------------------------------------------
import xrpl
@@ -17,15 +18,15 @@ test_wallet = generate_faucet_wallet(client, debug=True)
# Prepare transaction ----------------------------------------------------------
my_payment = xrpl.models.transactions.Payment(
account=test_wallet.classic_address,
account=test_wallet.address,
amount=xrpl.utils.xrp_to_drops(22),
destination="rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
)
print("Payment object:", my_payment)
# Sign transaction -------------------------------------------------------------
signed_tx = xrpl.transaction.safe_sign_and_autofill_transaction(
my_payment, test_wallet, client)
signed_tx = xrpl.transaction.autofill_and_sign(
my_payment, client, test_wallet)
max_ledger = signed_tx.last_ledger_sequence
tx_id = signed_tx.get_hash()
print("Signed transaction:", signed_tx)
@@ -35,12 +36,12 @@ print("Identifying hash:", tx_id)
# Submit transaction -----------------------------------------------------------
try:
tx_response = xrpl.transaction.send_reliable_submission(signed_tx, client)
tx_response = xrpl.transaction.submit_and_wait(signed_tx, client)
except xrpl.transaction.XRPLReliableSubmissionException as e:
exit(f"Submit failed: {e}")
# Wait for validation ----------------------------------------------------------
# send_reliable_submission() handles this automatically, but it can take 4-7s.
# submit_and_wait() handles this automatically, but it can take 4-7s.
# Check transaction results ----------------------------------------------------
import json

22
content/_code-samples/set-regular-key/py/setRegularKey.py
View File

@@ -2,7 +2,7 @@
from xrpl.account import get_balance
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import Payment, SetRegularKey
from xrpl.transaction import autofill_and_sign, send_reliable_submission
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
# References
@@ -20,16 +20,15 @@ regular_key_wallet = generate_faucet_wallet(client, debug=True)
# Both balances should be zero since nothing has been sent yet
print("Balances before payment:")
print(get_balance(wallet1.classic_address, client))
print(get_balance(wallet2.classic_address, client))
print(get_balance(wallet1.address, client))
print(get_balance(wallet2.address, client))
# Assign key pair (regular_key_wallet) to wallet1 using SetRegularKey transaction
tx = SetRegularKey(
account=wallet1.classic_address, regular_key=regular_key_wallet.classic_address
account=wallet1.address, regular_key=regular_key_wallet.address
)
signed_tx = autofill_and_sign(tx, wallet1, client)
set_regular_key_response = send_reliable_submission(signed_tx, client)
set_regular_key_response = submit_and_wait(tx, client, wallet1)
print("Response for successful SetRegularKey tx:")
print(set_regular_key_response)
@@ -37,18 +36,17 @@ print(set_regular_key_response)
# Since regular_key_wallet is linked to wallet1,
# walet1 can send payment to wallet2 and have regular_key_wallet sign it
payment = Payment(
account=wallet1.classic_address,
destination=wallet2.classic_address,
account=wallet1.address,
destination=wallet2.address,
amount="1000",
)
signed_payment = autofill_and_sign(payment, regular_key_wallet, client)
payment_response = send_reliable_submission(signed_payment, client)
payment_response = submit_and_wait(payment, client, regular_key_wallet)
print("Response for tx signed using Regular Key:")
print(payment_response)
# Balance after sending 1000 from wallet1 to wallet2
print("Balances after payment:")
print(get_balance(wallet1.classic_address, client))
print(get_balance(wallet2.classic_address, client))
print(get_balance(wallet1.address, client))
print(get_balance(wallet2.address, client))

10
content/_code-samples/submit-and-verify/py/submit-and-verify.py
View File

@@ -1,7 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import AccountSet
from xrpl.transaction import safe_sign_and_autofill_transaction, send_reliable_submission
from xrpl.wallet import Wallet, generate_faucet_wallet
from xrpl.transaction import submit_and_wait
from xrpl.wallet import generate_faucet_wallet
# Connect to a testnet node
JSON_RPC_URL = "https://s.altnet.rippletest.net:51234/"
@@ -9,17 +9,15 @@ client = JsonRpcClient(JSON_RPC_URL)
# Generate a wallet and request faucet
test_wallet = generate_faucet_wallet(client=client)
myAddr = test_wallet.classic_address
myAddr = test_wallet.address
# Construct AccountSet transaction
tx = AccountSet(
account=myAddr
)
# Sign the transaction locally
my_tx_payment_signed = safe_sign_and_autofill_transaction(transaction=tx, wallet=test_wallet, client=client)
# Submit transaction and verify its validity on the ledger
response = send_reliable_submission(transaction=my_tx_payment_signed, client=client)
response = submit_and_wait(transaction=tx, client=client, wallet=test_wallet)
result = response.result["meta"]["TransactionResult"]
print(f"Account: {myAddr}")

20
content/_code-samples/trade-in-the-decentralized-exchange/py/trade-in-the-dex.py
View File

@@ -4,8 +4,8 @@ from decimal import Decimal
from xrpl.asyncio.clients import AsyncWebsocketClient
from xrpl.asyncio.transaction import (
safe_sign_and_autofill_transaction,
send_reliable_submission,
autofill_and_sign,
submit_and_wait,
)
from xrpl.asyncio.wallet import generate_faucet_wallet
from xrpl.models.currencies import (
@@ -64,7 +64,7 @@ async def main() -> int:
print("Requesting orderbook information...")
orderbook_info = await client.request(
BookOffers(
taker=wallet.classic_address,
taker=wallet.address,
ledger_index="current",
taker_gets=we_want["currency"],
taker_pays=we_spend["currency"],
@@ -120,7 +120,7 @@ async def main() -> int:
print("Requesting second orderbook information...")
orderbook2_info = await client.request(
BookOffers(
taker=wallet.classic_address,
taker=wallet.address,
ledger_index="current",
taker_gets=we_spend["currency"],
taker_pays=we_want["currency"],
@@ -164,18 +164,18 @@ async def main() -> int:
# hard-coded TakerGets and TakerPays amounts.
tx = OfferCreate(
account=wallet.classic_address,
account=wallet.address,
taker_gets=we_spend["value"],
taker_pays=we_want["currency"].to_amount(we_want["value"]),
)
# Sign and autofill the transaction (ready to submit)
signed_tx = await safe_sign_and_autofill_transaction(tx, wallet, client)
signed_tx = await autofill_and_sign(tx, client, wallet)
print("Transaction:", signed_tx)
# Submit the transaction and wait for response (validated or rejected)
print("Sending OfferCreate transaction...")
result = await send_reliable_submission(signed_tx, client)
result = await submit_and_wait(signed_tx, client)
if result.is_successful():
print(f"Transaction succeeded: "
f"https://testnet.xrpl.org/transactions/{signed_tx.get_hash()}")
@@ -225,18 +225,18 @@ async def main() -> int:
print("Getting address balances as of validated ledger...")
balances = await client.request(
AccountLines(
account=wallet.classic_address,
account=wallet.address,
ledger_index="validated",
)
)
pprint.pp(balances.result)
# Check Offers --------------------------------------------------------------
print(f"Getting outstanding Offers from {wallet.classic_address} "
print(f"Getting outstanding Offers from {wallet.address} "
f"as of validated ledger...")
acct_offers = await client.request(
AccountOffers(
account=wallet.classic_address,
account=wallet.address,
ledger_index="validated",
)
)

14
content/_code-samples/use-tickets/py/use-tickets-to-multisign.py
View File

@@ -1,5 +1,5 @@
from xrpl.models.transactions import TicketCreate, AccountSet, SignerListSet, SignerEntry
from xrpl.transaction import safe_sign_and_submit_transaction, autofill, multisign, sign
from xrpl.transaction import sign_and_submit, autofill, multisign, sign
from xrpl.models.requests.account_objects import AccountObjects, AccountObjectType
from xrpl.models.requests.submit_multisigned import SubmitMultisigned
from xrpl.wallet import generate_faucet_wallet
@@ -21,7 +21,7 @@ client = JsonRpcClient(JSON_RPC_URL)
# Generate a wallet and request faucet
test_wallet = generate_faucet_wallet(client=client)
myAddr = test_wallet.classic_address
myAddr = test_wallet.address
print("Setting up all the signers' accounts via the testnet faucet, this may take a while...")
signer_1_wallet = generate_faucet_wallet(client=client)
@@ -30,9 +30,9 @@ signer_3_wallet = generate_faucet_wallet(client=client)
# Set the list of accounts that are able to authorize transactions on behalf of our Account via a multi-sig transaction
signers = [
SignerEntry(account=signer_1_wallet.classic_address, signer_weight=1),
SignerEntry(account=signer_2_wallet.classic_address, signer_weight=1),
SignerEntry(account=signer_3_wallet.classic_address, signer_weight=1)
SignerEntry(account=signer_1_wallet.address, signer_weight=1),
SignerEntry(account=signer_2_wallet.address, signer_weight=1),
SignerEntry(account=signer_3_wallet.address, signer_weight=1)
]
# Display all the signers' account address
@@ -55,7 +55,7 @@ tx_set_signer_list = SignerListSet(
# Sign transaction locally and submit
print("Submitting a SignerListSet transaction to update our account to use our new Signers...")
tx_set_signer_list_signed = safe_sign_and_submit_transaction(transaction=tx_set_signer_list, wallet=test_wallet, client=client)
tx_set_signer_list_signed = sign_and_submit(transaction=tx_set_signer_list, client=client, wallet=test_wallet)
# Construct a TicketCreate transaction, 3 tickets will be created
tx_create_ticket = TicketCreate(
@@ -65,7 +65,7 @@ tx_create_ticket = TicketCreate(
# Sign transaction locally and submit
print("Submitting a TicketCreate transaction to get Ticket Sequences for future transactions...")
tx_create_ticket_signed = safe_sign_and_submit_transaction(transaction=tx_create_ticket, wallet=test_wallet, client=client)
tx_create_ticket_signed = sign_and_submit(transaction=tx_create_ticket, client=client, wallet=test_wallet)
# Get a Ticket Sequence
get_ticket_sequence = client.request(AccountObjects(

10
content/_code-samples/use-tickets/py/use-tickets.py
View File

@@ -1,7 +1,7 @@
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import TicketCreate, AccountSet
from xrpl.transaction import safe_sign_and_submit_transaction
from xrpl.wallet import Wallet, generate_faucet_wallet
from xrpl.transaction import sign_and_submit
from xrpl.wallet import generate_faucet_wallet
from xrpl.models.requests.account_objects import AccountObjects, AccountObjectType
# Connect to a testnet node
@@ -10,7 +10,7 @@ client = JsonRpcClient(JSON_RPC_URL)
# Generate a wallet and request faucet
test_wallet = generate_faucet_wallet(client=client)
myAddr = test_wallet.classic_address
myAddr = test_wallet.address
# Construct a TicketCreate transaction, 2 ticket created for future use
tx = TicketCreate(
@@ -19,7 +19,7 @@ tx = TicketCreate(
)
# Sign transaction locally and submit
my_tx_payment_signed = safe_sign_and_submit_transaction(transaction=tx, wallet=test_wallet, client=client)
my_tx_payment_signed = sign_and_submit(transaction=tx, client=client, wallet=test_wallet)
# Get a Ticket Sequence
get_ticket_sequence = AccountObjects(
@@ -48,7 +48,7 @@ tx_1 = AccountSet(
)
# Send transaction (w/ Ticket)
tx_result = safe_sign_and_submit_transaction(transaction=tx_1, client=client, wallet=test_wallet)
tx_result = sign_and_submit(transaction=tx_1, client=client, wallet=test_wallet)
result = tx_result.result["engine_result"]
print(f"Account: {myAddr}")

2
content/tutorials/build-apps/build-a-desktop-wallet-in-python.md
View File

@@ -418,7 +418,7 @@ You can now use your wallet to send XRP! You can even fund an entirely new accou
import xrpl
w = xrpl.wallet.Wallet.create()
print(w.classic_address)
print(w.address)
print(w.seed)
exit()

16
content/tutorials/get-started/get-started-using-python.md
View File

@@ -112,24 +112,16 @@ To prepare the transaction:
##### Sign
##### Sign and submit
To sign the transaction:
To sign and submit the transaction:
{{ include_code("_code-samples/get-started/py/prepare-payment.py", start_with="# Sign the transaction", end_before="# Print signed tx", language="py") }}
##### Send
To send the transaction:
{{ include_code("_code-samples/get-started/py/prepare-payment.py", start_with="# Submit and send the transaction", end_before="# Print tx response", language="py") }}
{{ include_code("_code-samples/get-started/py/prepare-payment.py", start_with="# Sign and submit the transaction", end_before="# Print tx response", language="py") }}
##### Derive an X-address
You can use `xrpl-py`'s [`xrpl.core.addresscodec`](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.core.addresscodec.html) module to derive an [X-address](https://xrpaddress.info/) from the `Wallet.classic_address` field:
You can use `xrpl-py`'s [`xrpl.core.addresscodec`](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.core.addresscodec.html) module to derive an [X-address](https://xrpaddress.info/) from the `Wallet.address` field:
{{ include_code("_code-samples/get-started/py/get-acct-info.py", start_with="# Derive an x-address from the classic address:", end_before="# Look up info about your account", language="py") }}

2
content/tutorials/get-started/send-xrp.ja.md
View File

@@ -262,7 +262,7 @@ _Python_
```py
from xrpl.wallet import Wallet
my_wallet = Wallet.create()
print(my_wallet.classic_address) # Example: rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f
print(my_wallet.address) # Example: rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f
print(my_wallet.seed) # Example: sp6JS7f14BuwFY8Mw6bTtLKWauoUs
```

8
content/tutorials/get-started/send-xrp.md
View File

@@ -196,7 +196,7 @@ The result of the signing operation is a transaction object containing a signatu
Now that you have a signed transaction, you can submit it to an XRP Ledger server, which relays it through the network. It's also a good idea to take note of the latest validated ledger index before you submit. The earliest ledger version that your transaction could get into as a result of this submission is one higher than the latest validated ledger when you submit it. Of course, if the same transaction was previously submitted, it could already be in a previous ledger. (It can't succeed a second time, but you may not realize it succeeded if you aren't looking in the right ledger versions.)
- **JavaScript:** Use the [`submitAndWait()` method of the Client](https://js.xrpl.org/classes/Client.html#submitAndWait) to submit a signed transaction to the network and wait for the response, or use [`submitSigned()`](https://js.xrpl.org/classes/Client.html#submitSigned) to submit a transaction and get only the preliminary response.
- **Python:** Use the [`xrpl.transaction.send_reliable_submission()` method](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.transaction.html#xrpl.transaction.send_reliable_submission) to submit a transaction to the network and wait for a response.
- **Python:** Use the [`xrpl.transaction.submit_and_wait()` method](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.submit_and_wait) to submit a transaction to the network and wait for a response.
- **Java:** Use the [`XrplClient.submit(SignedTransaction)` method](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#submit(org.xrpl.xrpl4j.crypto.signing.SignedTransaction)) to submit a transaction to the network. Use the [`XrplClient.ledger()`](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#ledger(org.xrpl.xrpl4j.model.client.ledger.LedgerRequestParams)) method to get the latest validated ledger index.
<!-- MULTICODE_BLOCK_START -->
@@ -239,7 +239,7 @@ Most transactions are accepted into the next ledger version after they're submit
- **JavaScript:** If you used the [`.submitAndWait()` method](https://js.xrpl.org/classes/Client.html#submitAndWait), you can wait until the returned Promise resolves. Other, more asynchronous approaches are also possible.
- **Python:** If you used the [`xrpl.transaction.send_reliable_submission()` method](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.transaction.html#xrpl.transaction.send_reliable_submission), you can wait for the function to return. Other approaches, including asynchronous ones using the WebSocket client, are also possible.
- **Python:** If you used the [`xrpl.transaction.submit_and_wait()` method](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.submit_and_wait), you can wait for the function to return. Other approaches, including asynchronous ones using the WebSocket client, are also possible.
- **Java** Poll the [`XrplClient.transaction()` method](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#transaction(org.xrpl.xrpl4j.model.client.transactions.TransactionRequestParams,java.lang.Class)) to see if your transaction has a final result. Periodically check that the latest validated ledger index has not passed the `LastLedgerIndex` of the transaction using the [`XrplClient.ledger()`](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#ledger(org.xrpl.xrpl4j.model.client.ledger.LedgerRequestParams)) method.
@@ -272,7 +272,7 @@ To know for sure what a transaction did, you must look up the outcome of the tra
**Tip:** In **TypeScript** you can pass a [`TxRequest`](https://js.xrpl.org/interfaces/TxRequest.html) to the [`Client.request()`](https://js.xrpl.org/classes/Client.html#request) method.
- **Python:** Use the response from `send_reliable_submission()` or call the [`xrpl.transaction.get_transaction_from_hash()` method](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.transaction.html#xrpl.transaction.get_transaction_from_hash). (See the [tx method response format](tx.html#response-format) for a detailed reference of the fields this can contain.)
- **Python:** Use the response from [`submit_and_wait()`](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.submit_and_wait) or call the [`xrpl.transaction.get_transaction_from_hash()` method](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.transaction.html#xrpl.transaction.get_transaction_from_hash). (See the [tx method response format](tx.html#response-format) for a detailed reference of the fields this can contain.)
- **Java:** Use the [`XrplClient.transaction()`](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#transaction(org.xrpl.xrpl4j.model.client.transactions.TransactionRequestParams,java.lang.Class)) method to check the status of a transaction.
@@ -326,7 +326,7 @@ _Python_
```py
from xrpl.wallet import Wallet
my_wallet = Wallet.create()
print(my_wallet.classic_address) # Example: rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f
print(my_wallet.address) # Example: rGCkuB7PBr5tNy68tPEABEtcdno4hE6Y7f
print(my_wallet.seed) # Example: sp6JS7f14BuwFY8Mw6bTtLKWauoUs
```

2
content/tutorials/manage-account-settings/assign-a-regular-key-pair.md
View File

@@ -104,7 +104,7 @@ _Python_
```py
keypair = xrpl.wallet.Wallet.create()
print("seed:", keypair.seed)
print("classic address:", keypair.classic_address)
print("classic address:", keypair.address)
```
_JavaScript_

2
content/tutorials/use-tokens/issue-a-fungible-token.md
View File

@@ -202,7 +202,7 @@ Most transactions are accepted into the next ledger version after they're submit
The code samples in this tutorial use helper functions to wait for validation when submitting a transaction:
- **JavaScript:** The `submit_and_verify()` function, as defined in the [submit-and-verify code sample](https://github.com/XRPLF/xrpl-dev-portal/tree/master/content/_code-samples/submit-and-verify).
- **Python:** The `send_reliable_submission()` [method of the xrpl-py library](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.send_reliable_submission).
- **Python:** The `submit_and_wait()` [method of the xrpl-py library](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.submit_and_wait).
- **Java:** The `submitAndWaitForValidation()` method in the [sample Java class](https://github.com/XRPLF/xrpl-dev-portal/blob/master/content/_code-samples/issue-a-token/java/IssueToken.java).
**Tip:** Technically, you can configure the hot address in parallel with configuring the issuer address. For simplicity, this tutorial waits for each transaction one at a time.