def __add_signers(keys: List[AccountMeta], owner: PublicKey, signers: List[PublicKey]) -> None: if signers: keys.append(AccountMeta(pubkey=owner, is_signer=False, is_writable=False)) for signer in signers: keys.append(AccountMeta(pubkey=signer, is_signer=True, is_writable=False)) else: keys.append(AccountMeta(pubkey=owner, is_signer=True, is_writable=False))
def initialize(params: InitializeParams) -> TransactionInstruction: """Creates a transaction instruction to initialize a new stake.""" data = INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.INITIALIZE, args=dict( node=bytes(params.node), authorized_voter=bytes(params.authorized_voter), authorized_withdrawer=bytes(params.authorized_withdrawer), commission=params.commission, ), )) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.vote, is_signer=False, is_writable=True), AccountMeta(pubkey=params.rent_sysvar or SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), AccountMeta(pubkey=params.clock_sysvar or SYSVAR_CLOCK_PUBKEY, is_signer=False, is_writable=False), AccountMeta(pubkey=params.node, is_signer=True, is_writable=False), ], program_id=VOTE_PROGRAM_ID, data=data, )
def transfer(params: TransferParams) -> TransactionInstruction: """Generate an instruction that transfers lamports from one account to another. >>> from solana.publickey import PublicKey >>> sender, reciever = PublicKey(1), PublicKey(2) >>> instruction = transfer( ... TransferParams(from_pubkey=sender, to_pubkey=reciever, lamports=1000) ... ) >>> type(instruction) <class 'solana.transaction.TransactionInstruction'> """ data = SYSTEM_INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.Transfer, args=dict(lamports=params.lamports))) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.from_pubkey, is_signer=True, is_writable=True), AccountMeta(pubkey=params.to_pubkey, is_signer=False, is_writable=True), ], program_id=SYS_PROGRAM_ID, data=data, )
def approve2(params: Approve2Params) -> TransactionInstruction: """This instruction differs from `approve` in that the token mint and decimals value is asserted by the caller. >>> delegate, mint, owner, source, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4), PublicKey(5) >>> params = Approve2Params( ... amount=1000, ... decimals=6, ... delegate=delegate, ... mint=mint, ... owner=owner, ... program_id=token, ... source=source, ... ) >>> type(approve2(params)) <class 'solana.transaction.TransactionInstruction'> """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.APPROVE2, args=dict(amount=params.amount, decimals=params.decimals))) keys = [ AccountMeta(pubkey=params.source, is_signer=False, is_writable=True), AccountMeta(pubkey=params.mint, is_signer=False, is_writable=False), AccountMeta(pubkey=params.delegate, is_signer=False, is_writable=False), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def approve(params: ApproveParams) -> TransactionInstruction: """Creates a transaction instruction to approves a delegate. >>> delegate, owner, source, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4) >>> params = ApproveParams( ... amount=123, ... delegate=delegate, ... owner=owner, ... program_id=token, ... source=source ... ) >>> type(approve(params)) <class 'solana.transaction.TransactionInstruction'> """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.APPROVE, args=dict(amount=params.amount))) keys = [ AccountMeta(pubkey=params.source, is_signer=False, is_writable=True), AccountMeta(pubkey=params.delegate, is_signer=False, is_writable=False), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def transfer(params: TransferParams) -> Transaction: """Generate a Transaction that transfers lamports from one account to another. >>> from solana.publickey import PublicKey >>> sender, reciever = PublicKey(1), PublicKey(2) >>> transfer_tx = transfer( ... TransferParams(from_pubkey=sender, to_pubkey=reciever, lamports=1000) ... ) >>> type(transfer_tx) <class 'solana.transaction.Transaction'> """ layout = SYSTEM_INSTRUCTION_LAYOUTS[_TRANSFER] data = encode_data(layout, params.lamports) txn = Transaction() txn.add( TransactionInstruction( keys=[ AccountMeta(pubkey=params.from_pubkey, is_signer=True, is_writable=True), AccountMeta(pubkey=params.to_pubkey, is_signer=False, is_writable=True), ], program_id=sys_program_id(), data=data, )) return txn
def nonce_advance(params: AdvanceNonceParams) -> TransactionInstruction: """Generate an instruction to advance the nonce in a Nonce account. Args: params: The advance nonce params Returns: The instruction to advance the nonce. """ data = SYSTEM_INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.ADVANCE_NONCE_ACCOUNT, args={}, )) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.nonce_pubkey, is_signer=False, is_writable=True), AccountMeta(pubkey=sysvar.SYSVAR_RECENT_BLOCKHASHES_PUBKEY, is_signer=False, is_writable=False), AccountMeta(pubkey=params.authorized_pubkey, is_signer=True, is_writable=True), ], program_id=SYS_PROGRAM_ID, data=data, )
def transfer_checked(params: TransferCheckedParams) -> TransactionInstruction: """This instruction differs from `transfer` in that the token mint and decimals value is asserted by the caller. Example: >>> dest, mint, owner, source, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4), PublicKey(5) >>> params = TransferCheckedParams( ... amount=1000, ... decimals=6, ... dest=dest, ... mint=mint, ... owner=owner, ... program_id=token, ... source=source, ... ) >>> type(transfer_checked(params)) <class 'solana.transaction.TransactionInstruction'> Returns: The transfer-checked instruction. """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.TRANSFER2, args=dict(amount=params.amount, decimals=params.decimals))) keys = [ AccountMeta(pubkey=params.source, is_signer=False, is_writable=True), AccountMeta(pubkey=params.mint, is_signer=False, is_writable=False), AccountMeta(pubkey=params.dest, is_signer=False, is_writable=True), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def make_resize_instruction(self, account, code_account_old, code_account_new, seed) -> TransactionInstruction: return TransactionInstruction( program_id=EVM_LOADER_ID, data=bytearray.fromhex("11") + bytes(seed), # 17- ResizeStorageAccount keys=[ AccountMeta(pubkey=PublicKey(account), is_signer=False, is_writable=True), (AccountMeta( pubkey=code_account_old, is_signer=False, is_writable=True) if code_account_old else AccountMeta( pubkey=PublicKey("11111111111111111111111111111111"), is_signer=False, is_writable=False)), AccountMeta(pubkey=code_account_new, is_signer=False, is_writable=True), AccountMeta(pubkey=self.operator_account, is_signer=True, is_writable=False) ], )
def 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): keys = [ AccountMeta(pubkey=pool_account, is_signer=True, is_writable=True), AccountMeta(pubkey=escrow_mint_account, is_signer=False, is_writable=False), AccountMeta(pubkey=escrow_account, is_signer=True, is_writable=True), AccountMeta(pubkey=long_token_mint_account, is_signer=True, is_writable=False), AccountMeta(pubkey=short_token_mint_account, is_signer=True, is_writable=False), AccountMeta(pubkey=mint_authority_account, is_signer=True, is_writable=False), AccountMeta(pubkey=update_authority_account, is_signer=True, is_writable=False), AccountMeta(pubkey=token_account, is_signer=False, is_writable=False), AccountMeta(pubkey=system_account, is_signer=False, is_writable=False), AccountMeta(pubkey=rent_account, is_signer=False, is_writable=False), ] data = struct.pack("<BB", 0, decimals) return TransactionInstruction( keys=keys, program_id=PublicKey(BINARY_OPTION_PROGRAM_ID), data=data)
def close_account(params: CloseAccountParams) -> TransactionInstruction: """Creates a transaction instruction to close an account by transferring all its SOL to the destination account. Non-native accounts may only be closed if its token amount is zero. Example: >>> account, dest, owner, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4) >>> params = CloseAccountParams( ... account=account, dest=dest, owner=owner, program_id=token) >>> type(close_account(params)) <class 'solana.transaction.TransactionInstruction'> Returns: The close-account instruction. """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.CLOSE_ACCOUNT, args=None)) keys = [ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True), AccountMeta(pubkey=params.dest, is_signer=False, is_writable=True), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def cancel_order(params: CancelOrderParams) -> TransactionInstruction: """Generate a transaction instruction to cancel order.""" return TransactionInstruction( keys=[ AccountMeta(pubkey=params.market, is_signer=False, is_writable=False), AccountMeta(pubkey=params.open_orders, is_signer=False, is_writable=True), AccountMeta(pubkey=params.request_queue, is_signer=False, is_writable=True), AccountMeta(pubkey=params.owner, is_signer=True, is_writable=False), ], program_id=params.program_id, data=INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.CancelOrder, args=dict( side=params.side, order_id=params.order_id.to_bytes(16, byteorder="little"), open_orders=bytes(params.open_orders), open_orders_slot=params.open_orders_slot, ), )), )
def create_account(params: CreateAccountParams) -> TransactionInstruction: """Generate an instruction that creates a new account. >>> from solana.publickey import PublicKey >>> from_account, new_account, program_id = PublicKey(1), PublicKey(2), PublicKey(3) >>> instruction = create_account( ... CreateAccountParams( ... from_pubkey=from_account, new_account_pubkey=new_account, ... lamports=1, space=1, program_id=program_id) ... ) >>> type(instruction) <class 'solana.transaction.TransactionInstruction'> """ data = SYSTEM_INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.CreateAccount, args=dict(lamports=params.lamports, space=params.space, program_id=bytes(params.program_id)), )) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.from_pubkey, is_signer=True, is_writable=True), AccountMeta(pubkey=params.new_account_pubkey, is_signer=False, is_writable=True), ], program_id=SYS_PROGRAM_ID, data=data, )
def initialize_multisig(params: InitializeMultisigParams) -> TransactionInstruction: """Creates a transaction instruction to initialize a multisignature account with N provided signers. This instruction requires no signers and MUST be included within the same Transaction as the system program's `CreateInstruction` that creates the account being initialized. Otherwise another party can acquire ownership of the uninitialized account. >>> m = 2 # Two signers >>> signers = [PublicKey(i) for i in range(m)] >>> multisig_account, token = PublicKey(1), PublicKey(2) >>> params = InitializeMultisigParams( ... m=m, ... multisig=multisig_account, ... signers=signers, ... program_id=token, ... ) >>> type(initialize_multisig(params)) <class 'solana.transaction.TransactionInstruction'> """ data = INSTRUCTIONS_LAYOUT.build(dict(instruction_type=InstructionType.InitializeMultisig, args=dict(m=params.m))) keys = [ AccountMeta(pubkey=params.multisig, is_signer=False, is_writable=True), AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ] for signer in params.signers: keys.append(AccountMeta(pubkey=signer, is_signer=False, is_writable=False)) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def initialize_account(params: InitializeAccountParams) -> TransactionInstruction: """Creates a transaction instruction to initialize a new account to hold tokens. This instruction requires no signers and MUST be included within the same Transaction as the system program's `CreateInstruction` that creates the account being initialized. Otherwise another party can acquire ownership of the uninitialized account. >>> account, mint, owner, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4) >>> params = InitializeAccountParams( ... account=account, ... mint=mint, ... owner=owner, ... program_id=token, ... ) >>> type(initialize_account(params)) <class 'solana.transaction.TransactionInstruction'> """ data = INSTRUCTIONS_LAYOUT.build(dict(instruction_type=InstructionType.InitializeAccount, args=None)) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True), AccountMeta(pubkey=params.mint, is_signer=False, is_writable=False), AccountMeta(pubkey=params.owner, is_signer=False, is_writable=False), AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ], program_id=params.program_id, data=data, )
def transfer(params: TransferParams) -> TransactionInstruction: """Creates a transaction instruction to transfers tokens from one account to another. Either directly or via a delegate. >>> dest, owner, source, token = PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4) >>> params = TransferParams( ... amount=1000, ... dest=dest, ... owner=owner, ... program_id=token, ... source=source, ... ) >>> type(transfer(params)) <class 'solana.transaction.TransactionInstruction'> """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.TRANSFER, args=dict(amount=params.amount))) keys = [ AccountMeta(pubkey=params.source, is_signer=False, is_writable=True), AccountMeta(pubkey=params.dest, is_signer=False, is_writable=True), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def nonce_initialization( params: InitializeNonceParams) -> TransactionInstruction: """Generate an instruction to initialize a Nonce account. Args: params: The nonce initialization params. Returns: The instruction to initialize the nonce account. """ data = SYSTEM_INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.INITIALIZE_NONCE_ACCOUNT, args=dict(authorized=bytes(params.authorized_pubkey), ), )) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.nonce_pubkey, is_signer=True, is_writable=True), AccountMeta(pubkey=sysvar.SYSVAR_RECENT_BLOCKHASHES_PUBKEY, is_signer=False, is_writable=False), AccountMeta(pubkey=sysvar.SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ], program_id=SYS_PROGRAM_ID, data=data, )
def __mint_to_instruction(params: Union[MintToParams, MintTo2Params], data: Any) -> TransactionInstruction: keys = [ AccountMeta(pubkey=params.mint, is_signer=False, is_writable=True), AccountMeta(pubkey=params.dest, is_signer=False, is_writable=True), ] __add_signers(keys, params.mint_authority, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def __burn_instruction(params: Union[BurnParams, Burn2Params], data: Any) -> TransactionInstruction: keys = [ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True), AccountMeta(pubkey=params.mint, is_signer=False, is_writable=True), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def settle_funds(params: SettleFundsParams) -> TransactionInstruction: """Generate a transaction instruction to settle fund.""" return TransactionInstruction( keys=[ AccountMeta(pubkey=params.market, is_signer=False, is_writable=True), AccountMeta(pubkey=params.open_orders, is_signer=False, is_writable=True), AccountMeta(pubkey=params.owner, is_signer=True, is_writable=False), AccountMeta(pubkey=params.base_vault, is_signer=False, is_writable=True), AccountMeta(pubkey=params.quote_vault, is_signer=False, is_writable=True), AccountMeta(pubkey=params.base_wallet, is_signer=False, is_writable=True), AccountMeta(pubkey=params.quote_wallet, is_signer=False, is_writable=True), AccountMeta(pubkey=params.vault_signer, is_signer=False, is_writable=False), AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False), ], program_id=params.program_id, data=INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.SettleFunds, args=dict())), )
def __freeze_or_thaw_instruction( params: Union[FreezeAccountParams, ThawAccountParams], instruction_type: InstructionType ) -> TransactionInstruction: data = INSTRUCTIONS_LAYOUT.build(dict(instruction_type=instruction_type, args=None)) keys = [ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True), AccountMeta(pubkey=params.mint, is_signer=False, is_writable=False), ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def make_write_transaction(self, offset: int, data: bytes) -> Transaction: return Transaction().add( TransactionInstruction( program_id=EVM_LOADER_ID, data=write_holder_layout(self.perm_accs_id, offset, data), keys=[ AccountMeta(pubkey=self.holder, is_signer=False, is_writable=True), AccountMeta(pubkey=self.operator_account, is_signer=True, is_writable=False), ]))
def create_neon_erc20_account_instruction(self, payer: PublicKey, eth_address: str): return TransactionInstruction( program_id=self.evm_loader_id, data=bytes.fromhex('0F'), keys=[ AccountMeta(pubkey=payer, is_signer=True, is_writable=True), AccountMeta( pubkey=self.get_neon_erc20_account_address(eth_address), is_signer=False, is_writable=True), AccountMeta(pubkey=self.get_neon_account_address(eth_address), is_signer=False, is_writable=True), AccountMeta(pubkey=self.solana_contract_address, is_signer=False, is_writable=True), AccountMeta(pubkey=self.token.pubkey, is_signer=False, is_writable=True), AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ])
def make_partial_call_or_continue_instruction(self, steps=0 ) -> TransactionInstruction: data = bytearray.fromhex( "0D") + self.collateral_pool_index_buf + steps.to_bytes( 8, byteorder="little") + self.msg return TransactionInstruction( program_id=EVM_LOADER_ID, data=data, keys=[ AccountMeta( pubkey=self.storage, is_signer=False, is_writable=True), AccountMeta(pubkey=SYSVAR_INSTRUCTION_PUBKEY, is_signer=False, is_writable=False), AccountMeta(pubkey=self.operator_account, is_signer=True, is_writable=True), AccountMeta(pubkey=self.collateral_pool_address, is_signer=False, is_writable=True), AccountMeta(pubkey=self.operator_neon_address, is_signer=False, is_writable=True), AccountMeta(pubkey=self.caller_token, is_signer=False, is_writable=True), AccountMeta( pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False), ] + self.eth_accounts + [ AccountMeta(pubkey=SYSVAR_INSTRUCTION_PUBKEY, is_signer=False, is_writable=False), ] + obligatory_accounts)
def createERC20TokenAccountTrx(self, token_info) -> Transaction: trx = Transaction() trx.add( TransactionInstruction( program_id=EVM_LOADER_ID, data=bytes.fromhex('0F'), keys=[ AccountMeta(pubkey=self.operator_account, is_signer=True, is_writable=True), AccountMeta(pubkey=PublicKey(token_info["key"]), is_signer=False, is_writable=True), AccountMeta(pubkey=PublicKey(token_info["owner"]), is_signer=False, is_writable=True), AccountMeta(pubkey=PublicKey(token_info["contract"]), is_signer=False, is_writable=True), AccountMeta(pubkey=PublicKey(token_info["mint"]), is_signer=False, is_writable=True), AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ])) return trx
def create_account_instruction(self, eth_address: str, payer: PublicKey): dest_address_solana, nonce = get_evm_loader_account_address( eth_address) neon_token_account = get_associated_token_address( dest_address_solana, ETH_TOKEN_MINT_ID) return TransactionInstruction( program_id=EVM_LOADER_ID, data=create_account_layout(0, 0, bytes.fromhex(eth_address[2:]), nonce), keys=[ AccountMeta(pubkey=payer, is_signer=True, is_writable=True), AccountMeta(pubkey=dest_address_solana, is_signer=False, is_writable=True), AccountMeta(pubkey=neon_token_account, is_signer=False, is_writable=True), AccountMeta(pubkey=SYS_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=ETH_TOKEN_MINT_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=ASSOCIATED_TOKEN_PROGRAM_ID, is_signer=False, is_writable=False), AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False), ])
def assign( params: Union[AssignParams, AssignWithSeedParams]) -> TransactionInstruction: """Generate an instruction that assigns an account to a program. >>> from solana.publickey import PublicKey >>> account, program_id = PublicKey(1), PublicKey(2) >>> instruction = assign( ... AssignParams(account_pubkey=account, program_id=program_id) ... ) >>> type(instruction) <class 'solana.transaction.TransactionInstruction'> """ if isinstance(params, AssignWithSeedParams): raise NotImplementedError("assign with key is not implemented") else: data = SYSTEM_INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.Assign, args=dict(program_id=bytes(params.program_id)))) return TransactionInstruction( keys=[ AccountMeta(pubkey=params.account_pubkey, is_signer=True, is_writable=True), ], program_id=SYS_PROGRAM_ID, data=data, )
def revoke(params: RevokeParams) -> TransactionInstruction: """Creates a transaction instruction that revokes delegate authority for a given account. Example: >>> account, owner, token = PublicKey(1), PublicKey(2), PublicKey(3) >>> params = RevokeParams( ... account=account, owner=owner, program_id=token ... ) >>> type(revoke(params)) <class 'solana.transaction.TransactionInstruction'> Returns: The revoke instruction. """ data = INSTRUCTIONS_LAYOUT.build( dict(instruction_type=InstructionType.REVOKE, args=None)) keys = [ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True) ] __add_signers(keys, params.owner, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def set_authority(params: SetAuthorityParams) -> TransactionInstruction: """Creates a transaction instruction to sets a new authority of a mint or account. >>> account, current_authority, new_authority, token = ( ... PublicKey(1), PublicKey(2), PublicKey(3), PublicKey(4) ... ) >>> params = SetAuthorityParams( ... account=account, ... authority=AuthorityType.ACCOUNT_OWNER, ... current_authority=current_authority, ... new_authority=new_authority, ... program_id=token, ... ) >>> type(set_authority(params)) <class 'solana.transaction.TransactionInstruction'> """ new_authority, opt = (params.new_authority, 1) if params.new_authority else (PublicKey(0), 0) data = INSTRUCTIONS_LAYOUT.build( dict( instruction_type=InstructionType.SET_AUTHORITY, args=dict(authority_type=params.authority, new_authority_option=opt, new_authority=bytes(new_authority)), )) keys = [ AccountMeta(pubkey=params.account, is_signer=False, is_writable=True) ] __add_signers(keys, params.current_authority, params.signers) return TransactionInstruction(keys=keys, program_id=params.program_id, data=data)
def create_input_liquidity_instruction(self, payer: PublicKey, from_address: PublicKey, to_address: str, amount: int): return TransactionInstruction( program_id=TOKEN_PROGRAM_ID, data=b'\3' + struct.pack('<Q', amount), keys=[ AccountMeta(pubkey=from_address, is_signer=False, is_writable=True), AccountMeta( pubkey=self.get_neon_erc20_account_address(to_address), is_signer=False, is_writable=True), AccountMeta(pubkey=payer, is_signer=True, is_writable=False) ])