def test_dedup_signatures(stubbed_blockhash):
"""Test signature deduplication."""
acc1, acc2 = Account(), Account()
transfer1 = sp.transfer(sp.TransferParams(from_pubkey=acc1.public_key(), to_pubkey=acc2.public_key(), lamports=123))
transfer2 = sp.transfer(sp.TransferParams(from_pubkey=acc1.public_key(), to_pubkey=acc2.public_key(), lamports=123))
txn = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(transfer1, transfer2)
txn.sign(acc1)
def test_transfer():
"""Test creating a transaction for transfer."""
params = sp.TransferParams(from_pubkey=Account().public_key(),
to_pubkey=Account().public_key(),
lamports=123)
txn = sp.transfer(params)
assert len(txn.instructions) == 1
assert sp.decode_transfer(txn.instructions[0]) == params
def test_account_keypair():
"""Validate account keypair against account's private and public key."""
expected_account = Account()
keypair = expected_account.keypair()
decoded_keypair = b58decode(keypair)
actual_account = Account(decoded_keypair[:32])
assert expected_account.public_key() == actual_account.public_key()
assert expected_account.secret_key() == actual_account.secret_key()
def test_create_account():
"""Test creating a transaction for creat account."""
params = sp.CreateAccountParams(
from_pubkey=Account().public_key(),
new_account_pubkey=Account().public_key(),
lamports=123,
space=1,
program_id=PublicKey(1),
)
assert sp.decode_create_account(sp.create_account(params)) == params
def test_transfer_signatures(stubbed_blockhash):
"""Test signing transfer transactions."""
acc1, acc2 = Account(), Account()
transfer1 = sp.transfer(sp.TransferParams(from_pubkey=acc1.public_key(), to_pubkey=acc2.public_key(), lamports=123))
transfer2 = sp.transfer(sp.TransferParams(from_pubkey=acc2.public_key(), to_pubkey=acc1.public_key(), lamports=123))
txn = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(transfer1, transfer2)
txn.sign(acc1, acc2)
expected = txlib.Transaction(recent_blockhash=stubbed_blockhash, signatures=txn.signatures).add(
transfer1, transfer2
)
assert txn == expected
def test_sign_partial(stubbed_blockhash):
"""Test paritally sigining a transaction."""
acc1, acc2 = Account(), Account()
transfer = sp.transfer(sp.TransferParams(from_pubkey=acc1.public_key(), to_pubkey=acc2.public_key(), lamports=123))
partial_txn = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(transfer)
partial_txn.sign_partial(acc1, acc2.public_key())
assert len(partial_txn.signature()) == txlib.SIG_LENGTH
assert len(partial_txn.signatures) == 2
assert not partial_txn.signatures[1].signature
partial_txn.add_signer(acc2)
expected_txn = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(transfer)
expected_txn.sign(acc1, acc2)
assert partial_txn == expected_txn
async def test_token(alt_stubbed_sender, test_http_client_async) -> AsyncToken:
"""Test create mint."""
resp = await test_http_client_async.request_airdrop(alt_stubbed_sender.public_key(), AIRDROP_AMOUNT)
confirmed = await aconfirm_transaction(test_http_client_async, resp["result"])
assert_valid_response(confirmed)
expected_decimals = 6
expected_freeze_authority = Account()
token_client = await AsyncToken.create_mint(
test_http_client_async,
alt_stubbed_sender,
alt_stubbed_sender.public_key(),
expected_decimals,
TOKEN_PROGRAM_ID,
expected_freeze_authority.public_key(),
)
assert token_client.pubkey
assert token_client.program_id == TOKEN_PROGRAM_ID
assert token_client.payer.public_key() == alt_stubbed_sender.public_key()
resp = await test_http_client_async.get_account_info(token_client.pubkey)
assert_valid_response(resp)
assert resp["result"]["value"]["owner"] == str(TOKEN_PROGRAM_ID)
mint_data = layouts.MINT_LAYOUT.parse(decode_byte_string(resp["result"]["value"]["data"][0]))
assert mint_data.is_initialized
assert mint_data.decimals == expected_decimals
assert mint_data.supply == 0
assert PublicKey(mint_data.mint_authority) == alt_stubbed_sender.public_key()
assert PublicKey(mint_data.freeze_authority) == expected_freeze_authority.public_key()
return token_client
def test_verify_confirmed_block(stubbed_blockhash):
"""Test verifying signature in a confirmed block."""
acc0, acc1, acc2, acc3 = (Account() for _ in range(4))
# Create a couple signed transaction
txn1 = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(
transfer(
TransferParams(from_pubkey=acc0.public_key(),
to_pubkey=acc1.public_key(),
lamports=123)))
txn1.sign(acc0)
txn2 = txlib.Transaction(recent_blockhash=stubbed_blockhash).add(
transfer(
TransferParams(from_pubkey=acc2.public_key(),
to_pubkey=acc3.public_key(),
lamports=456)))
txn2.sign(acc2)
# Build confirmed_block with dummy data for blockhases and balances
confirmed_block = {
"blockhash":
stubbed_blockhash,
"previousBlockhash":
stubbed_blockhash,
"transactions": [
{
"transaction": txn1,
"meta": {
"fee": 0,
"preBalances": [100000, 100000, 1, 1, 1],
"postBalances": [99877, 100123, 1, 1, 1],
"status": {
"Ok": None
},
"err": None,
},
},
{
"transaction": txn2,
"meta": {
"fee": 0,
"preBalances": [100000, 100000, 1, 1, 1],
"postBalances": [99544, 100456, 1, 1, 1],
"status": {
"Ok": None
},
"err": None,
},
},
],
"rewards": [],
}
# Verify signatures in confirmed_block
assert all(tx_with_meta["transaction"].verify_signatures()
for tx_with_meta in confirmed_block["transactions"])
# Test block with bogus signature
bogus_signature = txlib._SigPubkeyPair(acc2.public_key(), bytes([9] * 64)) # pylint: disable=protected-access
txn1.signatures[0] = bogus_signature
bad_confirmed_block = confirmed_block
bad_confirmed_block["transactions"][0]["transaction"] = txn1
assert not all(tx_with_meta["transaction"].verify_signatures()
for tx_with_meta in confirmed_block["transactions"])
def test_assign():
"""Test creating a transaction for transfer."""
params = sp.AssignParams(
account_pubkey=Account().public_key(),
program_id=PublicKey(1),
)
assert sp.decode_assign(sp.assign(params)) == params
def _create_account_args(
self,
owner: PublicKey,
skip_confirmation: bool,
balance_needed: int,
) -> Tuple[PublicKey, Transaction, Account, Account, TxOpts]:
new_account = Account()
# Allocate memory for the account
# Construct transaction
txn = Transaction()
txn.add(
sp.create_account(
sp.CreateAccountParams(
from_pubkey=self.payer.public_key(),
new_account_pubkey=new_account.public_key(),
lamports=balance_needed,
space=ACCOUNT_LAYOUT.sizeof(),
program_id=self.program_id,
)))
txn.add(
spl_token.initialize_account(
spl_token.InitializeAccountParams(
account=new_account.public_key(),
mint=self.pubkey,
owner=owner,
program_id=self.program_id)))
return (
new_account.public_key(),
txn,
self.payer,
new_account,
TxOpts(skip_preflight=True, skip_confirmation=skip_confirmation),
)
def test_allocate():
"""Test creating a transaction for allocate."""
params = sp.AllocateParams(
account_pubkey=Account().public_key(),
space=12345,
)
assert sp.decode_allocate(sp.allocate(params)) == params
def topup(self, api_endpoint, to, amount=None, skip_confirmation=True):
"""
Send a small amount of native currency to the specified wallet to handle gas fees. Return a status flag of success or fail and the native transaction data.
"""
msg = ""
try:
# Connect to the api_endpoint
client = Client(api_endpoint)
msg += "Initialized client"
# List accounts
sender_account = Account(self.private_key)
dest_account = PublicKey(to)
msg += " | Gathered accounts"
# List signers
signers = [sender_account]
# Start transaction
tx = Transaction()
# Determine the amount to send
try:
if amount is None:
min_rent_reseponse = client.get_minimum_balance_for_rent_exemption(
ACCOUNT_LAYOUT.sizeof())
lamports = min_rent_reseponse["result"]
else:
lamports = int(amount)
msg += f" | Fetched lamports: {lamports * 1e-9} SOL"
except Exception as e:
msg += " | ERROR: couldn't process lamports"
raise (e)
# Generate transaction
transfer_ix = transfer(
TransferParams(from_pubkey=sender_account.public_key(),
to_pubkey=dest_account,
lamports=lamports))
tx = tx.add(transfer_ix)
msg += f" | Transferring funds"
# Send request
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'msg':
f"Successfully sent {lamports * 1e-9} SOL to {to}",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
raise (e)
except Exception as e:
return json.dumps({
'status': HTTPStatus.BAD_REQUEST,
'msg': msg,
})
def mint_to(self,
api_endpoint,
pool_account,
dest,
amount,
skip_confirmation=True):
msg = ""
client = Client(api_endpoint)
msg += "Initialized client"
# Create account objects
source_account = Account(self.private_key)
signers = [source_account]
pool = self.load_binary_option(api_endpoint, pool_account)
# List non-derived accounts
pool_account = PublicKey(pool_account)
dest_account = PublicKey(dest)
escrow_mint_account = PublicKey(pool["escrow_mint"])
mint_authority_account = source_account.public_key()
payer_account = source_account.public_key()
token_account = PublicKey(TOKEN_PROGRAM_ID)
tx = Transaction()
token_pda_address = get_associated_token_address(
dest_account, escrow_mint_account)
associated_token_account_ix = create_associated_token_account(
payer=payer_account,
owner=dest_account,
mint=escrow_mint_account,
)
tx = tx.add(associated_token_account_ix)
mint_to_ix = mint_to(
MintToParams(
program_id=token_account,
mint=escrow_mint_account,
dest=token_pda_address,
mint_authority=mint_authority_account,
amount=int(amount),
signers=[mint_authority_account],
))
tx = tx.add(mint_to_ix)
# Send request
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'msg':
msg + f" | MintTo {dest} successful",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
raise (e)
def create_mint(
conn: Client,
payer: Account,
mint_authority: PublicKey,
decimals: int,
program_id: PublicKey,
freeze_authority: Optional[PublicKey] = None,
skip_confirmation: bool = False,
) -> Token:
"""Create and initialize a token.
:param conn: RPC connection to a solana cluster.
:param payer: Fee payer for transaction.
:param mint_authority: Account or multisig that will control minting.
:param decimals: Location of the decimal place.
:param program_id: SPL Token program account.
:param freeze_authority: (optional) Account or multisig that can freeze token accounts.
:param skip_confirmation: (optional) Option to skip transaction confirmation.
:return: Token object for the newly minted token.
If skip confirmation is set to `False`, this method will block for at most 30 seconds
or until the transaction is confirmed.
"""
mint_account = Account()
token = Token(conn, mint_account.public_key(), program_id, payer)
# Allocate memory for the account
balance_needed = Token.get_min_balance_rent_for_exempt_for_mint(conn)
# Construct transaction
txn = Transaction()
txn.add(
sp.create_account(
sp.CreateAccountParams(
from_pubkey=payer.public_key(),
new_account_pubkey=mint_account.public_key(),
lamports=balance_needed,
space=MINT_LAYOUT.sizeof(),
program_id=program_id,
)
)
)
txn.add(
spl_token.initialize_mint(
spl_token.InitializeMintParams(
program_id=program_id,
mint=mint_account.public_key(),
decimals=decimals,
mint_authority=mint_authority,
freeze_authority=freeze_authority,
)
)
)
# Send the two instructions
conn.send_transaction(
txn, payer, mint_account, opts=TxOpts(skip_confirmation=skip_confirmation, skip_preflight=True)
)
return token
def __init__(self, upper: float, lower: float, amount: float, grid: int,
pair: str, base: str, quote: str, owner: str, private: str):
"""
:params upper: price up
:params lower: price down
:params amount: amount of the order
:params grid: amount of grid
:params pair: dexlab trading pair address
:params base: youur base coin address for trading
:params quote: your quote coin address for trading
:params owner: your solana wallet address
:params private: your private key for pay the transaction gas
"""
self.upper = upper
self.lower = lower
self.amount = amount
self.grid = grid
self.pair = pair
self.base = base
self.quote = quote
self.owner = owner
self.key = base58.b58decode(private)
self.payer = Account(self.key[:32])
self.client = Client('', '')
self.cc = conn('https://api.mainnet-beta.solana.com/')
self.market = Market.load(
self.cc,
PublicKey(self.pair),
program_id=PublicKey(
'9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin'))
try:
self.open_acc = self.market.find_open_orders_accounts_for_owner(
self.payer.public_key())[0].address
except:
self.open_acc = ''
self.base_decimal = self.market.state.base_spl_token_decimals()
self.quote_decimal = self.market.state.quote_spl_token_decimals()
print(f'Initialize...\n\n'
f'----parameters----\n\n'
f'upper: {self.upper}\n'
f'lower: {self.lower}\n'
f'amount: {self.amount}\n'
f'grid: {self.grid}\n'
f'base decimal: {self.base_decimal}\n'
f'quote decimal: {self.quote_decimal}\n'
f'pair: {self.pair}\n'
f'base: {self.base}\n'
f'quote: {self.quote}\n'
f'owner: {self.owner}\n'
f'open orders account: {self.open_acc}\n'
f'key: {self.key[:32]}\n\n'
f'----start----\n')
def test_allocate_with_seed():
"""Test creating a transaction for allocate with seed."""
params = sp.AllocateWithSeedParams(
account_pubkey=Account().public_key(),
base_pubkey=PublicKey(1),
seed={
"length": 4,
"chars": "gqln"
},
space=65537,
program_id=PublicKey(2),
)
assert sp.decode_allocate_with_seed(sp.allocate(params)) == params
def create_account(
self,
owner: PublicKey,
skip_confirmation: bool = False,
) -> PublicKey:
"""Create and initialize a new account.
This account may then be used as a `transfer()` or `approve()` destination.
:param owner: User account that will own the new account.
:param skip_confirmation: (optional) Option to skip transaction confirmation.
:return: Public key of the new empty account.
If skip confirmation is set to `False`, this method will block for at most 30 seconds
or until the transaction is confirmed.
"""
new_account = Account()
# Allocate memory for the account
balance_needed = Token.get_min_balance_rent_for_exempt_for_account(
self._conn)
# Construct transaction
txn = Transaction()
txn.add(
sp.create_account(
sp.CreateAccountParams(
from_pubkey=self.payer.public_key(),
new_account_pubkey=new_account.public_key(),
lamports=balance_needed,
space=ACCOUNT_LAYOUT.sizeof(),
program_id=self.program_id,
)))
txn.add(
spl_token.initialize_account(
spl_token.InitializeAccountParams(
account=new_account.public_key(),
mint=self.pubkey,
owner=owner,
program_id=self.program_id)))
# Send the two instructions
self._conn.send_transaction(txn,
self.payer,
new_account,
opts=TxOpts(
skip_preflight=True,
skip_confirmation=skip_confirmation))
return new_account.public_key()
def settle(self,
api_endpoint,
pool_account,
winning_mint,
skip_confirmation=True):
msg = ""
client = Client(api_endpoint)
msg += "Initialized client"
# Create account objects
source_account = Account(self.private_key)
# Signers
signers = [source_account]
# List non-derived accounts
pool_account = PublicKey(pool_account)
winning_mint_account = PublicKey(winning_mint)
tx = Transaction()
settle_ix = settle_instruction(
pool_account,
winning_mint_account,
source_account.public_key(),
)
tx = tx.add(settle_ix)
# Send request
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'msg':
msg +
f" | Settle successful, winner: {str(winning_mint_account)}",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
raise (e)
def test_generate_account_from_secret_key():
"""Generate an account with provided secret key."""
secret_key = bytes(
[
153,
218,
149,
89,
225,
94,
145,
62,
233,
171,
46,
83,
227,
223,
173,
87,
93,
163,
59,
73,
190,
17,
37,
187,
146,
46,
51,
73,
79,
73,
136,
40,
]
)
acc = Account(secret_key)
assert str(acc.public_key()) == "2q7pyhPwAwZ3QMfZrnAbDhnh9mDUqycszcpf86VgQxhF"
def _create_wrapped_native_account_args(
program_id: PublicKey,
owner: PublicKey,
payer: Account,
amount: int,
skip_confirmation: bool,
balance_needed: int,
) -> Tuple[PublicKey, Transaction, Account, Account, TxOpts]:
new_account = Account()
# Allocate memory for the account
# Construct transaction
txn = Transaction()
txn.add(
sp.create_account(
sp.CreateAccountParams(
from_pubkey=payer.public_key(),
new_account_pubkey=new_account.public_key(),
lamports=balance_needed,
space=ACCOUNT_LAYOUT.sizeof(),
program_id=program_id,
)))
txn.add(
sp.transfer(
sp.TransferParams(from_pubkey=payer.public_key(),
to_pubkey=new_account.public_key(),
lamports=amount)))
txn.add(
spl_token.initialize_account(
spl_token.InitializeAccountParams(
account=new_account.public_key(),
mint=WRAPPED_SOL_MINT,
owner=owner,
program_id=program_id)))
return new_account.public_key(), txn, payer, new_account, TxOpts(
skip_confirmation=skip_confirmation)
def _create_mint_args(
conn: Union[Client, AsyncClient],
payer: Account,
mint_authority: PublicKey,
decimals: int,
program_id: PublicKey,
freeze_authority: Optional[PublicKey],
skip_confirmation: bool,
balance_needed: int,
cls: Union[Type[Token], Type[AsyncToken]],
) -> Tuple[Union[Token, AsyncToken], Transaction, Account, Account,
TxOpts]:
mint_account = Account()
token = cls(conn, mint_account.public_key(), program_id,
payer) # type: ignore
# Construct transaction
txn = Transaction()
txn.add(
sp.create_account(
sp.CreateAccountParams(
from_pubkey=payer.public_key(),
new_account_pubkey=mint_account.public_key(),
lamports=balance_needed,
space=MINT_LAYOUT.sizeof(),
program_id=program_id,
)))
txn.add(
spl_token.initialize_mint(
spl_token.InitializeMintParams(
program_id=program_id,
mint=mint_account.public_key(),
decimals=decimals,
mint_authority=mint_authority,
freeze_authority=freeze_authority,
)))
return token, txn, payer, mint_account, TxOpts(
skip_confirmation=skip_confirmation, skip_preflight=True)
def test_generate_account():
"""Generate an account."""
acc = Account()
assert len(acc.secret_key()) == crypto_box_SECRETKEYBYTES
def create() -> "Wallet":
new_account = Account()
new_secret_key = new_account.secret_key()
return Wallet(new_secret_key)
def test_transfer():
"""Test creating a transaction for transfer."""
params = sp.TransferParams(from_pubkey=Account().public_key(),
to_pubkey=Account().public_key(),
lamports=123)
assert sp.decode_transfer(sp.transfer(params)) == params
def place_order( # pylint: disable=too-many-arguments,too-many-locals
self,
payer: PublicKey,
owner: Account,
order_type: OrderType,
side: Side,
limit_price: int,
max_quantity: int,
client_id: int = 0,
opts: TxOpts = TxOpts(),
) -> RPCResponse: # TODO: Add open_orders_address_key param and fee_discount_pubkey
transaction = Transaction()
signers: List[Account] = [owner]
open_order_accounts = self.find_open_orders_accounts_for_owner(
owner.public_key())
if not open_order_accounts:
new_open_orders_account = Account()
mbfre_resp = self._conn.get_minimum_balance_for_rent_exemption(
OPEN_ORDERS_LAYOUT.sizeof())
balanced_needed = mbfre_resp["result"]
transaction.add(
make_create_account_instruction(
owner.public_key(),
new_open_orders_account.public_key(),
balanced_needed,
self.state.program_id(),
))
signers.append(new_open_orders_account)
# TODO: Cache new_open_orders_account
# TODO: Handle open_orders_address_key
# TODO: Handle fee_discount_pubkey
if payer == owner.public_key():
raise ValueError("Invalid payer account")
# TODO: add integration test for SOL wrapping.
should_wrap_sol = (side == side.Buy and self.state.quote_mint()
== WRAPPED_SOL_MINT) or (side == side.Sell
and self.state.base_mint
== WRAPPED_SOL_MINT)
wrapped_sol_account = Account()
if should_wrap_sol:
transaction.add(
create_account(
CreateAccountParams(
from_pubkey=owner.public_key(),
new_account_pubkey=wrapped_sol_account.public_key(),
lamports=Market._get_lamport_need_for_sol_wrapping(
limit_price, max_quantity, side,
open_order_accounts),
space=ACCOUNT_LEN,
program_id=TOKEN_PROGRAM_ID,
)))
transaction.add(
initialize_account(
InitializeAccountParams(
account=wrapped_sol_account.public_key(),
mint=WRAPPED_SOL_MINT,
owner=owner.public_key(),
program_id=SYSVAR_RENT_PUBKEY,
)))
transaction.add(
self.make_place_order_instruction(
wrapped_sol_account.public_key() if should_wrap_sol else payer,
owner,
order_type,
side,
limit_price,
max_quantity,
client_id,
open_order_accounts[0].address if open_order_accounts else
new_open_orders_account.public_key(),
))
if should_wrap_sol:
transaction.add(
close_account(
CloseAccountParams(
account=wrapped_sol_account.public_key(),
owner=owner.public_key(),
dest=owner.public_key(),
)))
# TODO: extract `make_place_order_transaction`.
return self._conn.send_transaction(transaction, *signers, opts=opts)
def stubbed_sender() -> Account:
"""Arbitrary known account to be used as sender."""
return Account(bytes([8] * PublicKey.LENGTH))
def trade(self,
api_endpoint,
pool_account,
buyer_encrypted_private_key,
seller_encrypted_private_key,
size,
buyer_price,
seller_price,
skip_confirmation=True):
msg = ""
client = Client(api_endpoint)
msg += "Initialized client"
# Create account objects
buyer_private_key = list(
self.cipher.decrypt(buyer_encrypted_private_key))
seller_private_key = list(
self.cipher.decrypt(seller_encrypted_private_key))
assert (len(buyer_private_key) == 32)
assert (len(seller_private_key) == 32)
source_account = Account(self.private_key)
buyer = Account(buyer_private_key)
seller = Account(seller_private_key)
# Signers
signers = [buyer, seller, source_account]
pool = self.load_binary_option(api_endpoint, pool_account)
# List non-derived accounts
pool_account = PublicKey(pool_account)
escrow_account = PublicKey(pool["escrow"])
escrow_mint_account = PublicKey(pool["escrow_mint"])
long_token_mint_account = PublicKey(pool["long_mint"])
short_token_mint_account = PublicKey(pool["short_mint"])
buyer_account = buyer.public_key()
seller_account = seller.public_key()
token_account = PublicKey(TOKEN_PROGRAM_ID)
escrow_owner_account = PublicKey.find_program_address(
[
bytes(long_token_mint_account),
bytes(short_token_mint_account),
bytes(token_account),
bytes(PublicKey(BINARY_OPTION_PROGRAM_ID))
],
PublicKey(BINARY_OPTION_PROGRAM_ID),
)[0]
# Transaction
tx = Transaction()
atas = []
for acct in [buyer_account, seller_account]:
acct_atas = []
for mint_account in (long_token_mint_account,
short_token_mint_account,
escrow_mint_account):
token_pda_address = get_associated_token_address(
acct, mint_account)
associated_token_account_info = client.get_account_info(
token_pda_address)
account_info = associated_token_account_info['result']['value']
if account_info is not None:
account_state = ACCOUNT_LAYOUT.parse(
base64.b64decode(account_info['data'][0])).state
else:
account_state = 0
if account_state == 0:
msg += f" | Creating PDA: {token_pda_address}"
associated_token_account_ix = create_associated_token_account(
payer=source_account.public_key(),
owner=acct,
mint=mint_account,
)
tx = tx.add(associated_token_account_ix)
else:
msg += f" | Fetched PDA: {token_pda_address}"
acct_atas.append(token_pda_address)
atas.append(acct_atas)
trade_ix = trade_instruction(
pool_account,
escrow_account,
long_token_mint_account,
short_token_mint_account,
buyer_account,
seller_account,
atas[0][2],
atas[1][2],
atas[0][0],
atas[0][1],
atas[1][0],
atas[1][1],
escrow_owner_account,
token_account,
int(size),
int(buyer_price),
int(seller_price),
)
tx = tx.add(trade_ix)
# Send request
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'msg':
msg + f" | Trade successful",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
raise (e)
def collect(self,
api_endpoint,
pool_account,
collector,
skip_confirmation=True):
msg = ""
client = Client(api_endpoint)
msg += "Initialized client"
signers = [Account(self.private_key)]
pool = self.load_binary_option(api_endpoint, pool_account)
pool_account = PublicKey(pool_account)
collector_account = PublicKey(collector)
escrow_account = PublicKey(pool["escrow"])
escrow_mint_account = PublicKey(pool["escrow_mint"])
long_token_mint_account = PublicKey(pool["long_mint"])
short_token_mint_account = PublicKey(pool["short_mint"])
token_account = PublicKey(TOKEN_PROGRAM_ID)
escrow_authority_account = PublicKey.find_program_address(
[
bytes(long_token_mint_account),
bytes(short_token_mint_account),
bytes(token_account),
bytes(PublicKey(BINARY_OPTION_PROGRAM_ID))
],
PublicKey(BINARY_OPTION_PROGRAM_ID),
)[0]
# Transaction
tx = Transaction()
atas = []
for mint_account in (long_token_mint_account, short_token_mint_account,
escrow_mint_account):
token_pda_address = get_associated_token_address(
collector_account, mint_account)
associated_token_account_info = client.get_account_info(
token_pda_address)
account_info = associated_token_account_info['result']['value']
if account_info is not None:
account_state = ACCOUNT_LAYOUT.parse(
base64.b64decode(account_info['data'][0])).state
else:
account_state = 0
if account_state == 0:
msg += f" | Error Fetching PDA: {token_pda_address}"
raise Exception()
else:
msg += f" | Fetched PDA: {token_pda_address}"
atas.append(token_pda_address)
collect_ix = collect_instruction(
pool_account,
collector_account,
atas[0],
atas[1],
atas[2],
long_token_mint_account,
short_token_mint_account,
escrow_account,
escrow_authority_account,
token_account,
)
tx = tx.add(collect_ix)
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'msg':
msg + f" | Collect successful",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
print(msg)
raise (e)
quote_ccy = pair.split("/")[0]
quote_ccy_mint = {}
for mkt in get_token_mints():
quote_ccy_mint.update({mkt.name: mkt.address})
print("Token Mint is: {}".format(quote_ccy_mint[quote_ccy]))
# %%
# Get private key and use that the create a new account
#pubkey = "GKksmU6hSJ2X7zz1mcE3Qhr7DDEpvxqbygzb17SxygUD"
f = open('./my-solana-wallet/my-keypair.json')
private_key = json.load(f)
mid = len(private_key) // 2
private_key = private_key[:mid] # to 32 bytes
payer = Account(private_key) # Your account to pay fees
print("Public Key is: {}".format(payer.public_key()))
# %%
cc = conn("https://api.mainnet-beta.solana.com/")
quote_token = Token(
cc,
pubkey=PublicKey(quote_ccy_mint[quote_ccy]), # mint address of token
program_id=TOKEN_PROGRAM_ID,
payer=payer,
)
quote_wallet = quote_token.create_account(
payer.public_key(),
def initialize(self,
api_endpoint,
escrow_mint,
decimals=2,
skip_confirmation=True):
msg = ""
# Initialize Clinet
client = Client(api_endpoint)
msg += "Initialized client"
# Create account objects
source_account = Account(self.private_key)
pool = Account()
long_escrow = Account()
short_escrow = Account()
long_mint = Account()
short_mint = Account()
# List non-derived accounts
pool_account = pool.public_key()
escrow_mint_account = PublicKey(escrow_mint)
escrow_account = long_escrow.public_key()
long_token_mint_account = long_mint.public_key()
short_token_mint_account = short_mint.public_key()
mint_authority_account = source_account.public_key()
update_authority_account = source_account.public_key()
token_account = PublicKey(TOKEN_PROGRAM_ID)
system_account = PublicKey(SYSTEM_PROGRAM_ID)
rent_account = PublicKey(SYSVAR_RENT_ID)
msg += " | Gathered accounts"
# List signers
signers = [
source_account, long_mint, short_mint, long_escrow, short_escrow,
pool
]
# Start transaction
tx = Transaction()
# Create Token Metadata
init_binary_option_ix = initialize_binary_option_instruction(
pool_account,
escrow_mint_account,
escrow_account,
long_token_mint_account,
short_token_mint_account,
mint_authority_account,
update_authority_account,
token_account,
system_account,
rent_account,
decimals,
)
tx = tx.add(init_binary_option_ix)
msg += f" | Creating binary option"
# Send request
try:
response = client.send_transaction(
tx,
*signers,
opts=types.TxOpts(skip_confirmation=skip_confirmation))
return json.dumps({
'status':
HTTPStatus.OK,
'binary_option':
str(pool_account),
'msg':
msg +
f" | Successfully created binary option {str(pool_account)}",
'tx':
response.get('result') if skip_confirmation else
response['result']['transaction']['signatures'],
})
except Exception as e:
msg += f" | ERROR: Encountered exception while attempting to send transaction: {e}"
raise (e)