diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..871869d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# ignore idea files
+.idea/
+
+.DS_Store
+.DS_Store/
diff --git a/api/metaplex_api.py b/api/metaplex_api.py
index 2bee099..33fb30d 100644
--- a/api/metaplex_api.py
+++ b/api/metaplex_api.py
@@ -1,22 +1,25 @@
 import json
 from cryptography.fernet import Fernet
 import base58
-from solana.keypair import Keypair 
+from nacl.public import PrivateKey
+from solana.keypair import Keypair
 from metaplex.transactions import deploy, topup, mint, send, burn, update_token_metadata
 from utils.execution_engine import execute
 
-class MetaplexAPI():
+
+class MetaplexAPI:
 
     def __init__(self, cfg):
         self.private_key = list(base58.b58decode(cfg["PRIVATE_KEY"]))[:32]
         self.public_key = cfg["PUBLIC_KEY"]
-        self.keypair = Keypair(self.private_key)
+        self.keypair = Keypair(PrivateKey(bytes(self.private_key)))
         self.cipher = Fernet(cfg["DECRYPTION_KEY"])
 
-    def wallet(self):
+    @staticmethod
+    def wallet():
         """ Generate a wallet and return the address and private key. """
         keypair = Keypair()
-        pub_key = keypair.public_key 
+        pub_key = keypair.public_key
         private_key = list(keypair.seed)
         return json.dumps(
             {
@@ -25,10 +28,12 @@ def wallet(self):
             }
         )
 
-    def deploy(self, api_endpoint, name, symbol, fees, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True):
+    def deploy(self, api_endpoint, name, symbol, fees, max_retries=3, skip_confirmation=False, max_timeout=60,
+               target=20, finalized=True):
         """
-        Deploy a contract to the blockchain (on network that support contracts). Takes the network ID and contract name, plus initialisers of name and symbol. Process may vary significantly between blockchains.
-        Returns status code of success or fail, the contract address, and the native transaction data.
+        Deploy a contract to the blockchain (on network that support contracts). Takes the network ID and contract
+        name, plus initializers of name and symbol. Process may vary significantly between blockchains. Returns
+        status code of success or fail, the contract address, and the native transaction data.
         """
         try:
             tx, signers, contract = deploy(api_endpoint, self.keypair, name, symbol, fees)
@@ -49,9 +54,11 @@ def deploy(self, api_endpoint, name, symbol, fees, max_retries=3, skip_confirmat
         except:
             return json.dumps({"status": 400})
 
-    def topup(self, api_endpoint, to, amount=None, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True):
+    def topup(self, api_endpoint, to, amount=None, max_retries=3, skip_confirmation=False, max_timeout=60, target=20,
+              finalized=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.
+        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.
         """
         try:
             tx, signers = topup(api_endpoint, self.keypair, to, amount=amount)
@@ -70,7 +77,8 @@ def topup(self, api_endpoint, to, amount=None, max_retries=3, skip_confirmation=
         except:
             return json.dumps({"status": 400})
 
-    def mint(self, api_endpoint, contract_key, dest_key, link, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True, supply=1 ):
+    def mint(self, api_endpoint, contract_key, dest_key, link, max_retries=3, skip_confirmation=False, max_timeout=60,
+             target=20, finalized=True, supply=1):
         """
         Mints an NFT to an account, updates the metadata and creates a master edition
         """
@@ -89,27 +97,30 @@ def mint(self, api_endpoint, contract_key, dest_key, link, max_retries=3, skip_c
         return json.dumps(resp)
         # except:
         #     return json.dumps({"status": 400})
-        
-    def update_token_metadata(self, api_endpoint, mint_token_id, link,  data, creators_addresses, creators_verified, creators_share,fee, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True, supply=1 ):
-            """
+
+    def update_token_metadata(self, api_endpoint, mint_token_id, link, data, creators_addresses, creators_verified,
+                              creators_share, fee, max_retries=3, skip_confirmation=False, max_timeout=60, target=20,
+                              finalized=True, supply=1):
+        """
             Updates the json metadata for a given mint token id.
             """
-            tx, signers = update_token_metadata(api_endpoint, self.keypair, mint_token_id, link, data, fee, creators_addresses, creators_verified, creators_share)
-            resp = execute(
-                api_endpoint,
-                tx,
-                signers,
-                max_retries=max_retries,
-                skip_confirmation=skip_confirmation,
-                max_timeout=max_timeout,
-                target=target,
-                finalized=finalized,
-            )
-            resp["status"] = 200
-            return json.dumps(resp)
-
+        tx, signers = update_token_metadata(api_endpoint, self.keypair, mint_token_id, link, data, fee,
+                                            creators_addresses, creators_verified, creators_share)
+        resp = execute(
+            api_endpoint,
+            tx,
+            signers,
+            max_retries=max_retries,
+            skip_confirmation=skip_confirmation,
+            max_timeout=max_timeout,
+            target=target,
+            finalized=finalized,
+        )
+        resp["status"] = 200
+        return json.dumps(resp)
 
-    def send(self, api_endpoint, contract_key, sender_key, dest_key, encrypted_private_key, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True):
+    def send(self, api_endpoint, contract_key, sender_key, dest_key, encrypted_private_key, max_retries=3,
+             skip_confirmation=False, max_timeout=60, target=20, finalized=True):
         """
         Transfer a token on a given network and contract from the sender to the recipient.
         May require a private key, if so this will be provided encrypted using Fernet: https://cryptography.io/en/latest/fernet/
@@ -133,7 +144,8 @@ def send(self, api_endpoint, contract_key, sender_key, dest_key, encrypted_priva
         except:
             return json.dumps({"status": 400})
 
-    def burn(self, api_endpoint, contract_key, owner_key, encrypted_private_key, max_retries=3, skip_confirmation=False, max_timeout=60, target=20, finalized=True):
+    def burn(self, api_endpoint, contract_key, owner_key, encrypted_private_key, max_retries=3, skip_confirmation=False,
+             max_timeout=60, target=20, finalized=True):
         """
         Burn a token, permanently removing it from the blockchain.
         May require a private key, if so this will be provided encrypted using Fernet: https://cryptography.io/en/latest/fernet/
diff --git a/metaplex/metadata.py b/metaplex/metadata.py
index 5187dc6..a7dfd62 100644
--- a/metaplex/metadata.py
+++ b/metaplex/metadata.py
@@ -13,28 +13,34 @@
 MAX_URI_LENGTH = 200
 MAX_CREATOR_LENGTH = 34
 MAX_CREATOR_LIMIT = 5
+
+
 class InstructionType(IntEnum):
     CREATE_METADATA = 0
     UPDATE_METADATA = 1
 
+
 METADATA_PROGRAM_ID = PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s')
 SYSTEM_PROGRAM_ID = PublicKey('11111111111111111111111111111111')
-SYSVAR_RENT_PUBKEY = PublicKey('SysvarRent111111111111111111111111111111111') 
+SYSVAR_RENT_PUBKEY = PublicKey('SysvarRent111111111111111111111111111111111')
 ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID = PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL')
 TOKEN_PROGRAM_ID = PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')
 
+
 def get_metadata_account(mint_key):
     return PublicKey.find_program_address(
         [b'metadata', bytes(METADATA_PROGRAM_ID), bytes(PublicKey(mint_key))],
         METADATA_PROGRAM_ID
     )[0]
 
+
 def get_edition(mint_key):
     return PublicKey.find_program_address(
         [b'metadata', bytes(METADATA_PROGRAM_ID), bytes(PublicKey(mint_key)), b"edition"],
         METADATA_PROGRAM_ID
     )[0]
 
+
 def create_associated_token_account_instruction(associated_token_account, payer, wallet_address, token_mint_address):
     keys = [
         AccountMeta(pubkey=payer, is_signer=True, is_writable=True),
@@ -47,12 +53,13 @@ def create_associated_token_account_instruction(associated_token_account, payer,
     ]
     return TransactionInstruction(keys=keys, program_id=ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID)
 
+
 def _get_data_buffer(name, symbol, uri, fee, creators, verified=None, share=None):
     if isinstance(share, list):
-        assert(len(share) == len(creators))
+        assert (len(share) == len(creators))
     if isinstance(verified, list):
-        assert(len(verified) == len(creators))
-    args =  [
+        assert (len(verified) == len(creators))
+    args = [
         len(name),
         *list(name.encode()),
         len(symbol),
@@ -61,19 +68,19 @@ def _get_data_buffer(name, symbol, uri, fee, creators, verified=None, share=None
         *list(uri.encode()),
         fee,
     ]
- 
-    byte_fmt = "<" 
-    byte_fmt += "I" + "B"*len(name)
-    byte_fmt += "I" + "B"*len(symbol)
-    byte_fmt += "I" + "B"*len(uri)
+
+    byte_fmt = "<"
+    byte_fmt += "I" + "B" * len(name)
+    byte_fmt += "I" + "B" * len(symbol)
+    byte_fmt += "I" + "B" * len(uri)
     byte_fmt += "h"
     byte_fmt += "B"
     if creators:
         args.append(1)
         byte_fmt += "I"
         args.append(len(creators))
-        for i, creator in enumerate(creators): 
-            byte_fmt +=  "B"*32 + "B" + "B"
+        for i, creator in enumerate(creators):
+            byte_fmt += "B" * 32 + "B" + "B"
             args.extend(list(base58.b58decode(creator)))
             if isinstance(verified, list):
                 args.append(verified[i])
@@ -84,12 +91,13 @@ def _get_data_buffer(name, symbol, uri, fee, creators, verified=None, share=None
             else:
                 args.append(100)
     else:
-        args.append(0) 
+        args.append(0)
     buffer = struct.pack(byte_fmt, *args)
     return buffer
-    
+
+
 def create_metadata_instruction_data(name, symbol, fee, creators):
-    _data = _get_data_buffer(name, symbol, " "*64, fee, creators)
+    _data = _get_data_buffer(name, symbol, " " * 64, fee, creators)
     metadata_args_layout = cStruct(
         "data" / Bytes(len(_data)),
         "is_mutable" / Flag,
@@ -106,6 +114,7 @@ def create_metadata_instruction_data(name, symbol, fee, creators):
         )
     )
 
+
 def create_metadata_instruction(data, update_authority, mint_key, mint_authority_key, payer):
     metadata_account = get_metadata_account(mint_key)
     print(metadata_account)
@@ -120,37 +129,38 @@ def create_metadata_instruction(data, update_authority, mint_key, mint_authority
     ]
     return TransactionInstruction(keys=keys, program_id=METADATA_PROGRAM_ID, data=data)
 
+
 def unpack_metadata_account(data):
-    assert(data[0] == 4)
+    assert (data[0] == 4)
     i = 1
-    source_account = base58.b58encode(bytes(struct.unpack('<' + "B"*32, data[i:i+32])))
+    source_account = base58.b58encode(bytes(struct.unpack('<' + "B" * 32, data[i:i + 32])))
     i += 32
-    mint_account = base58.b58encode(bytes(struct.unpack('<' + "B"*32, data[i:i+32])))
+    mint_account = base58.b58encode(bytes(struct.unpack('<' + "B" * 32, data[i:i + 32])))
     i += 32
-    name_len = struct.unpack('<I', data[i:i+4])[0]
+    name_len = struct.unpack('<I', data[i:i + 4])[0]
     i += 4
-    name = struct.unpack('<' + "B"*name_len, data[i:i+name_len])
+    name = struct.unpack('<' + "B" * name_len, data[i:i + name_len])
     i += name_len
-    symbol_len = struct.unpack('<I', data[i:i+4])[0]
-    i += 4 
-    symbol = struct.unpack('<' + "B"*symbol_len, data[i:i+symbol_len])
+    symbol_len = struct.unpack('<I', data[i:i + 4])[0]
+    i += 4
+    symbol = struct.unpack('<' + "B" * symbol_len, data[i:i + symbol_len])
     i += symbol_len
-    uri_len = struct.unpack('<I', data[i:i+4])[0]
-    i += 4 
-    uri = struct.unpack('<' + "B"*uri_len, data[i:i+uri_len])
+    uri_len = struct.unpack('<I', data[i:i + 4])[0]
+    i += 4
+    uri = struct.unpack('<' + "B" * uri_len, data[i:i + uri_len])
     i += uri_len
-    fee = struct.unpack('<h', data[i:i+2])[0]
+    fee = struct.unpack('<h', data[i:i + 2])[0]
     i += 2
-    has_creator = data[i] 
+    has_creator = data[i]
     i += 1
     creators = []
     verified = []
     share = []
     if has_creator:
-        creator_len = struct.unpack('<I', data[i:i+4])[0]
+        creator_len = struct.unpack('<I', data[i:i + 4])[0]
         i += 4
         for _ in range(creator_len):
-            creator = base58.b58encode(bytes(struct.unpack('<' + "B"*32, data[i:i+32])))
+            creator = base58.b58encode(bytes(struct.unpack('<' + "B" * 32, data[i:i + 32])))
             creators.append(creator)
             i += 32
             verified.append(data[i])
@@ -177,14 +187,16 @@ def unpack_metadata_account(data):
     }
     return metadata
 
+
 def get_metadata(client, mint_key):
     metadata_account = get_metadata_account(mint_key)
     data = base64.b64decode(client.get_account_info(metadata_account)['result']['value']['data'][0])
     metadata = unpack_metadata_account(data)
     return metadata
 
+
 def update_metadata_instruction_data(name, symbol, uri, fee, creators, verified, share):
-    _data = bytes([1]) + _get_data_buffer(name, symbol, uri, fee, creators,  verified, share) + bytes([0, 0])
+    _data = bytes([1]) + _get_data_buffer(name, symbol, uri, fee, creators, verified, share) + bytes([0, 0])
     instruction_layout = cStruct(
         "instruction_type" / Int8ul,
         "args" / Bytes(len(_data)),
@@ -196,6 +208,7 @@ def update_metadata_instruction_data(name, symbol, uri, fee, creators, verified,
         )
     )
 
+
 def update_metadata_instruction(data, update_authority, mint_key):
     metadata_account = get_metadata_account(mint_key)
     keys = [
@@ -204,12 +217,13 @@ def update_metadata_instruction(data, update_authority, mint_key):
     ]
     return TransactionInstruction(keys=keys, program_id=METADATA_PROGRAM_ID, data=data)
 
+
 def create_master_edition_instruction(
-    mint: PublicKey,
-    update_authority: PublicKey,
-    mint_authority: PublicKey,
-    payer: PublicKey,
-    supply: Union[int, None],
+        mint: PublicKey,
+        update_authority: PublicKey,
+        mint_authority: PublicKey,
+        payer: PublicKey,
+        supply: Union[int, None],
 ):
     edition_account = get_edition(mint)
     metadata_account = get_metadata_account(mint)
@@ -224,9 +238,9 @@ def create_master_edition_instruction(
         AccountMeta(pubkey=mint_authority, is_signer=True, is_writable=False),
         AccountMeta(pubkey=payer, is_signer=True, is_writable=False),
         AccountMeta(pubkey=metadata_account, is_signer=False, is_writable=False),
-        AccountMeta(pubkey=PublicKey(TOKEN_PROGRAM_ID), is_signer=False, is_writable=False),
-        AccountMeta(pubkey=PublicKey(SYSTEM_PROGRAM_ID), is_signer=False, is_writable=False),
-        AccountMeta(pubkey=PublicKey(SYSVAR_RENT_PUBKEY), is_signer=False, is_writable=False),
+        AccountMeta(pubkey=TOKEN_PROGRAM_ID, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=SYSTEM_PROGRAM_ID, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=SYSVAR_RENT_PUBKEY, is_signer=False, is_writable=False),
     ]
     return TransactionInstruction(
         keys=keys,
diff --git a/metaplex/transactions.py b/metaplex/transactions.py
index 4718a16..2c93644 100644
--- a/metaplex/transactions.py
+++ b/metaplex/transactions.py
@@ -1,10 +1,10 @@
 import json
 import base64
-from solana.publickey import PublicKey 
+from solana.publickey import PublicKey
 from solana.transaction import Transaction
-from solana.keypair import Keypair 
+from solana.keypair import Keypair
 from solana.rpc.api import Client
-from solana.system_program import transfer, TransferParams, create_account, CreateAccountParams 
+from solana.system_program import transfer, TransferParams, create_account, CreateAccountParams
 from spl.token._layouts import MINT_LAYOUT, ACCOUNT_LAYOUT
 from spl.token.instructions import (
     get_associated_token_address, mint_to, MintToParams,
@@ -15,7 +15,7 @@
 from metaplex.metadata import (
     create_associated_token_account_instruction,
     create_master_edition_instruction,
-    create_metadata_instruction_data, 
+    create_metadata_instruction_data,
     create_metadata_instruction,
     get_metadata,
     update_metadata_instruction_data,
@@ -26,18 +26,18 @@
 
 
 def deploy(api_endpoint, source_account, name, symbol, fees):
-    # Initalize Client
+    # Initialize Client
     client = Client(api_endpoint)
     # List non-derived accounts
     mint_account = Keypair()
-    token_account = TOKEN_PROGRAM_ID 
+    token_account = TOKEN_PROGRAM_ID
     # List signers
     signers = [source_account, mint_account]
     # Start transaction
     tx = Transaction()
     # Get the minimum rent balance for a mint account
-    min_rent_reseponse = client.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof()) # type: ignore
-    lamports = min_rent_reseponse["result"]
+    min_rent_response = client.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof())  # type: ignore
+    lamports = min_rent_response["result"]
     # Generate Mint 
     create_mint_account_ix = create_account(
         CreateAccountParams(
@@ -69,12 +69,12 @@ def deploy(api_endpoint, source_account, name, symbol, fees):
     )
     tx = tx.add(create_metadata_ix)
     return tx, signers, str(mint_account.public_key)
-    
+
 
 def wallet():
     """ Generate a wallet and return the address and private key. """
     account = Keypair()
-    pub_key = account.public_key 
+    pub_key = account.public_key
     private_key = list(account.seed)
     return json.dumps(
         {
@@ -103,11 +103,14 @@ def topup(api_endpoint, sender_account, to, amount=None):
     else:
         lamports = int(amount)
     # Generate transaction
-    transfer_ix = transfer(TransferParams(from_pubkey=sender_account.public_key, to_pubkey=dest_account, lamports=lamports))
+    transfer_ix = transfer(
+        TransferParams(from_pubkey=sender_account.public_key, to_pubkey=dest_account, lamports=lamports))
     tx = tx.add(transfer_ix)
     return tx, signers
 
-def update_token_metadata(api_endpoint, source_account, mint_token_id, link, data, fee, creators_addresses, creators_verified, creators_share):
+
+def update_token_metadata(api_endpoint, source_account, mint_token_id, link, data, fee, creators_addresses,
+                          creators_verified, creators_share):
     """
     Updates the json metadata for a given mint token id.
     """
@@ -120,7 +123,7 @@ def update_token_metadata(api_endpoint, source_account, mint_token_id, link, dat
         data['symbol'],
         link,
         fee,
-        creators_addresses,        
+        creators_addresses,
         creators_verified,
         creators_share,
     )
@@ -129,7 +132,7 @@ def update_token_metadata(api_endpoint, source_account, mint_token_id, link, dat
         source_account.public_key,
         mint_account,
     )
-    tx = tx.add(update_metadata_ix) 
+    tx = tx.add(update_metadata_ix)
     return tx, signers
 
 
@@ -159,19 +162,19 @@ def mint(api_endpoint, source_account, contract_key, dest_key, link, supply=1):
     associated_token_account_info = client.get_account_info(associated_token_account)
     # Check if PDA is initialized. If not, create the account
     account_info = associated_token_account_info['result']['value']
-    if account_info is not None: 
+    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:
         associated_token_account_ix = create_associated_token_account_instruction(
             associated_token_account=associated_token_account,
-            payer=source_account.public_key, # signer
+            payer=source_account.public_key,  # signer
             wallet_address=user_account,
             token_mint_address=mint_account,
         )
-        tx = tx.add(associated_token_account_ix)  
-    # Mint NFT to the newly create associated token account
+        tx = tx.add(associated_token_account_ix)
+        # Mint NFT to the newly create associated token account
     mint_to_ix = mint_to(
         MintToParams(
             program_id=TOKEN_PROGRAM_ID,
@@ -182,7 +185,7 @@ def mint(api_endpoint, source_account, contract_key, dest_key, link, supply=1):
             signers=[source_account.public_key],
         )
     )
-    tx = tx.add(mint_to_ix) 
+    tx = tx.add(mint_to_ix)
     metadata = get_metadata(client, mint_account)
     update_metadata_data = update_metadata_instruction_data(
         metadata['data']['name'],
@@ -198,7 +201,7 @@ def mint(api_endpoint, source_account, contract_key, dest_key, link, supply=1):
         source_account.public_key,
         mint_account,
     )
-    tx = tx.add(update_metadata_ix) 
+    tx = tx.add(update_metadata_ix)
     create_master_edition_ix = create_master_edition_instruction(
         mint=mint_account,
         update_authority=source_account.public_key,
@@ -206,7 +209,7 @@ def mint(api_endpoint, source_account, contract_key, dest_key, link, supply=1):
         payer=source_account.public_key,
         supply=supply,
     )
-    tx = tx.add(create_master_edition_ix) 
+    tx = tx.add(create_master_edition_ix)
     return tx, signers
 
 
@@ -219,8 +222,8 @@ def send(api_endpoint, source_account, contract_key, sender_key, dest_key, priva
     # Initialize Client
     client = Client(api_endpoint)
     # List non-derived accounts
-    owner_account = Keypair(private_key) # Owner of contract 
-    sender_account = PublicKey(sender_key) # Public key of `owner_account`
+    owner_account = Keypair(private_key)  # Owner of contract
+    sender_account = PublicKey(sender_key)  # Public key of `owner_account`
     token_account = TOKEN_PROGRAM_ID
     mint_account = PublicKey(contract_key)
     dest_account = PublicKey(dest_key)
@@ -230,25 +233,25 @@ def send(api_endpoint, source_account, contract_key, sender_key, dest_key, priva
     tx = Transaction()
     # Find PDA for sender
     token_pda_address = get_associated_token_address(sender_account, mint_account)
-    if client.get_account_info(token_pda_address)['result']['value'] is None: 
+    if client.get_account_info(token_pda_address)['result']['value'] is None:
         raise Exception
     # Check if PDA is initialized for receiver. If not, create the account
     associated_token_account = get_associated_token_address(dest_account, mint_account)
     associated_token_account_info = client.get_account_info(associated_token_account)
     account_info = associated_token_account_info['result']['value']
-    if account_info is not None: 
+    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:
         associated_token_account_ix = create_associated_token_account_instruction(
             associated_token_account=associated_token_account,
-            payer=source_account.public_key, # signer
+            payer=source_account.public_key,  # signer
             wallet_address=dest_account,
             token_mint_address=mint_account,
         )
-        tx = tx.add(associated_token_account_ix)        
-    # Transfer the Token from the sender account to the associated token account
+        tx = tx.add(associated_token_account_ix)
+        # Transfer the Token from the sender account to the associated token account
     spl_transfer_ix = spl_transfer(
         SPLTransferParams(
             program_id=token_account,
@@ -281,7 +284,7 @@ def burn(api_endpoint, contract_key, owner_key, private_key):
     tx = Transaction()
     # Find PDA for sender
     token_pda_address = get_associated_token_address(owner_account, mint_account)
-    if client.get_account_info(token_pda_address)['result']['value'] is None: 
+    if client.get_account_info(token_pda_address)['result']['value'] is None:
         raise Exception
     # Burn token
     burn_ix = spl_burn(
diff --git a/requirements.txt b/requirements.txt
index 3732285..21bfba3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -13,7 +13,7 @@ cryptography==35.0.0
 ed25519==1.5
 h11==0.12.0
 httpcore==0.13.7
-httpx==0.20.0
+httpx==0.18.2
 idna==3.3
 iniconfig==1.1.1
 jaraco.classes==3.2.1
@@ -34,10 +34,10 @@ requests==2.26.0
 rfc3986==1.5.0
 six==1.16.0
 sniffio==1.2.0
-solana==0.18.1
+solana==0.20.0
 tempora==4.1.2
 toml==0.10.2
 typing-extensions==3.10.0.2
 urllib3==1.26.7
-websockets==10.0
+websockets==10.1
 zc.lockfile==2.0
diff --git a/test/test_api.py b/test/test_api.py
index 988e91e..4f7f4be 100644
--- a/test/test_api.py
+++ b/test/test_api.py
@@ -10,6 +10,7 @@
 from cryptography.fernet import Fernet
 from api.metaplex_api import MetaplexAPI
 
+
 def await_full_confirmation(client, txn, max_timeout=60):
     if txn is None:
         return
@@ -25,6 +26,7 @@ def await_full_confirmation(client, txn, max_timeout=60):
             print(f"Took {elapsed} seconds to confirm transaction {txn}")
             break
 
+
 def test(api_endpoint="https://api.devnet.solana.com/"):
     keypair = Keypair()
     cfg = {
@@ -51,18 +53,19 @@ def test(api_endpoint="https://api.devnet.solana.com/"):
     assert deploy_response["status"] == 200
     contract = deploy_response.get("contract")
     print(get_metadata(client, contract))
-    wallet = json.loads(api.wallet())
+    wallet = json.loads(MetaplexAPI.wallet())
     address1 = wallet.get('address')
     encrypted_pk1 = api.cipher.encrypt(bytes(wallet.get('private_key')))
     topup_response = json.loads(api.topup(api_endpoint, address1))
     print(f"Topup {address1}:", topup_response)
     assert topup_response["status"] == 200
-    mint_to_response = json.loads(api.mint(api_endpoint, contract, address1, "https://arweave.net/1eH7bZS-6HZH4YOc8T_tGp2Rq25dlhclXJkoa6U55mM/"))
+    mint_to_response = json.loads(
+        api.mint(api_endpoint, contract, address1, "https://arweave.net/1eH7bZS-6HZH4YOc8T_tGp2Rq25dlhclXJkoa6U55mM/"))
     print("Mint:", mint_to_response)
     # await_confirmation(client, mint_to_response['tx'])
     assert mint_to_response["status"] == 200
     print(get_metadata(client, contract))
-    wallet2 = json.loads(api.wallet())
+    wallet2 = json.loads(wallet())
     address2 = wallet2.get('address')
     encrypted_pk2 = api.cipher.encrypt(bytes(wallet2.get('private_key')))
     print(client.request_airdrop(api.public_key, int(1e10)))
@@ -79,11 +82,12 @@ def test(api_endpoint="https://api.devnet.solana.com/"):
     assert burn_response["status"] == 200
     print("Success!")
 
+
 if __name__ == "__main__":
     ap = argparse.ArgumentParser()
     ap.add_argument("--network", default=None)
     args = ap.parse_args()
-    if args.network == None or args.network == 'devnet':
+    if args.network is None or args.network == 'devnet':
         test()
     elif args.network == 'testnet':
         test(api_endpoint="https://api.testnet.solana.com/")
diff --git a/utils/execution_engine.py b/utils/execution_engine.py
index 2ae2049..7a00c1d 100644
--- a/utils/execution_engine.py
+++ b/utils/execution_engine.py
@@ -1,11 +1,19 @@
 import time
-from solana.keypair import Keypair 
 from solana.rpc.api import Client
-from solana.rpc.types import TxOpts 
+from solana.rpc.types import TxOpts
 
-def execute(api_endpoint, tx, signers, max_retries=3, skip_confirmation=True, max_timeout=60, target=20, finalized=True):
+
+def remove_duplicated(items):
+    # removes duplicated items in an iterator while preserving order
+    seen = set()
+    return [x for x in items if not (x in seen or seen.add(x))]
+
+
+def execute(api_endpoint, tx, signers, max_retries=3, skip_confirmation=True, max_timeout=60, target=20,
+            finalized=True):
     client = Client(api_endpoint)
-    signers = list(map(Keypair, set(map(lambda s: s.seed, signers))))
+    signers = remove_duplicated(signers)
+    last_error = None
     for attempt in range(max_retries):
         try:
             result = client.send_transaction(tx, *signers, opts=TxOpts(skip_preflight=True))
@@ -16,8 +24,10 @@ def execute(api_endpoint, tx, signers, max_retries=3, skip_confirmation=True, ma
             return result
         except Exception as e:
             print(f"Failed attempt {attempt}: {e}")
+            last_error = e
             continue
-    raise e
+    raise last_error
+
 
 def await_confirmation(client, signatures, max_timeout=60, target=20, finalized=True):
     elapsed = 0
@@ -37,4 +47,4 @@ def await_confirmation(client, signatures, max_timeout=60, target=20, finalized=
                 return
         elif is_finalized:
             print(f"Took {elapsed} seconds to confirm transaction")
-            return
\ No newline at end of file
+            return