WrongKeyLengthError: key length must be 58

AlgoSDK
1

Hi

I’m trying to create an asset and then send it to other addresses (all on the testnet). I can successfully create assets, signing with my account but when I try to send them, I get a wrongkeylength error despite using the same private key. I just can’t figure out what the issue is.

Has anyone of you encountered a similar error and knows how to solve it?

Thanks a lot in advance!!

Here the code:
for lockers in directory_lockers:
asset_id = directory_lockers[lockers][‘asset_id’]
receiving_address = directory_lockers[lockers][‘receiving_address’]
locker_object = directory_lockers[lockers][‘object’]
print(getattr(locker_object,“Master_Account”))
locker_object.distribute(asset_id,receiving_address)

The error I get is the following:

WrongKeyLengthError Traceback (most recent call last)
in
6 locker_object = directory_lockers[lockers][‘object’]
7 print(getattr(locker_object,“Master_Account”))
----> 8 locker_object.distribute(asset_id,receiving_address)
9

~\JLPY\lockertoken.py in distribute(self, asset_id, receiving_address)
120 }
121 txn = transaction.AssetTransferTxn(**data)
→ 122 stxn = txn.sign(self.Master_Account[‘sk’])
123 txid = algod_client.send_transaction(stxn)
124 gf.wait_for_confirmation

C:\Anaconda\lib\site-packages\algosdk\transaction.py in sign(self, private_key)
61 SignedTransaction: signed transaction with the signature
62 “”"
—> 63 sig = self.raw_sign(private_key)
64 sig = base64.b64encode(sig).decode()
65 authorizing_address = None

C:\Anaconda\lib\site-packages\algosdk\transaction.py in raw_sign(self, private_key)
80 “”"
81 private_key = base64.b64decode(private_key)
—> 82 txn = encoding.msgpack_encode(self)
83 to_sign = constants.txid_prefix + base64.b64decode(txn)
84 signing_key = SigningKey(private_key[:constants.key_len_bytes])

C:\Anaconda\lib\site-packages\algosdk\encoding.py in msgpack_encode(obj)
29 d = obj
30 if not isinstance(obj, dict):
—> 31 d = obj.dictify()
32 od = _sort_dict(d)
33 return base64.b64encode(msgpack.packb(od, use_bin_type=True)).decode()

C:\Anaconda\lib\site-packages\algosdk\transaction.py in dictify(self)
750 d[“aclose”] = encoding.decode_address(self.close_assets_to)
751 if self.receiver:
→ 752 d[“arcv”] = encoding.decode_address(self.receiver)
753 if self.revocation_target:
754 d[“asnd”] = encoding.decode_address(self.revocation_target)

C:\Anaconda\lib\site-packages\algosdk\encoding.py in decode_address(addr)
165 return addr
166 if not len(addr) == constants.address_len:
→ 167 raise error.WrongKeyLengthError
168 decoded = base64.b32decode(_correct_padding(addr))
169 addr = decoded[:-constants.check_sum_len_bytes]

WrongKeyLengthError: key length must be 58

2

Can you post the sdk code that actually creates the transactions?

3

Hi Jason

Of course and thanks already for looking at this thread. I am falling into despair…

The code uses the distribute function which is part of the LokerToken-class:

import json
from algosdk import account, algod, mnemonic, transaction, kmd

import generalfunctions as gf
import generalconstants as gc

class LockerToken:

algod_client = algod.AlgodClient(gc.algod_token, gc.algod_address, gc.headers)

def __init__(self, Master_Account, Locker_ID):
    self.Master_Account = Master_Account
    self.Locker_ID = Locker_ID


def wait_for_tx_confirmation(self,txid):
    algod_client = algod.AlgodClient(gc.algod_token, gc.algod_address, gc.headers)   
    last_round = algod_client.status().get('lastRound')
    while True:
        txinfo = algod_client.pending_transaction_info(txid)
        if txinfo.get('round') and txinfo.get('round') > 0:
            print("Transaction {} confirmed in round {}.".format(
               txid, txinfo.get('round')))
            break
        else:
            print("Waiting for confirmation...")
            last_round += 1
            algod_client.status_after_block(last_round)


def create(self):
    # Get network params for transactions.   
    algod_client = algod.AlgodClient(gc.algod_token, gc.algod_address, gc.headers)
    params = algod_client.suggested_params()
    first = params.get("lastRound")
    last = first + 1000
    gen = params.get("genesisID")
    gh = params.get("genesishashb64")
    min_fee = params.get("minFee")

    # Define parameters of new BCGLT
    data = {
        "sender": self.Master_Account['pk'],
        "fee": min_fee,
        "first": first,
        "last": last,
        "gh": gh,
        "total": 1,
        "default_frozen": False,
        "unit_name": "BCGLT",
        "asset_name": "BCG Locker Token " + self.Locker_ID,
        "manager": self.Master_Account['pk'],
        "reserve": self.Master_Account['pk'],
        "freeze": self.Master_Account['pk'],
        "clawback": self.Master_Account['pk'],
        "url": "https://path/to/my/asset/details",
        #url should point towards manual
        "flat_fee": True,
        "decimals": 0
    }

    # Construct Asset Creation transaction
    txn = transaction.AssetConfigTxn(**data)
    # Sign with secret key of creator
    stxn = txn.sign(self.Master_Account['sk'])

    # Send the transaction to the network and retrieve the txid.
    txid = algod_client.send_transaction(stxn)
    print("Transaction ID = ", txid)

    # Retrieve the asset ID of the newly created asset by first
    # ensuring that the creation transaction was confirmed,
    # then pulling account info of the creator and grabbing the
    # asset with the max asset ID.

    # Wait for the transaction to be confirmed
    self.wait_for_tx_confirmation(txid)
    return txid


def info(self):
    algod_client = algod.AlgodClient(gc.algod_token, gc.algod_address, gc.headers)
    try:
        # Pull account info for the creator
        account_info = algod_client.account_info(self.Master_Account['pk'])
        # Get max asset ID
        asset_id = max(
            map(lambda x: int(x), account_info.get('thisassettotal').keys()))
        print("Asset ID: {}".format(asset_id), json.dumps(account_info['thisassettotal'][str(asset_id)], indent=4))
        return asset_id
    except Exception as e:
        print(e)
        


def distribute(self, asset_id, receiving_address):
    algod_client = algod.AlgodClient(gc.algod_token, gc.algod_address, gc.headers)
    params = algod_client.suggested_params()   
    data = {
            "sender": self.Master_Account['pk'],
            "fee": params.get("minFee"),
            "first": params.get("lastRound"),
            "last": params.get("lastRound") + 1000,
            "gh": params.get("genesishashb64"),
            "receiver": receiving_address,
            "amt": 1,
            "index": asset_id,
            "flat_fee": True
            }
    txn = transaction.AssetTransferTxn(**data)
    stxn = txn.sign(self.Master_Account['sk'])
    txid = algod_client.send_transaction(stxn)
    gf.wait_for_confirmation
    account_info = algod_client.account_info(receiving_address)
    print(json.dumps(account_info['assets'][str(asset_id)], indent=4))

kind regards,
Max

4

Hey @maxpower glad you are here building assets. I believe your receiving_address is the issue, not the Master_Account. I see in the distribute method you pass in the receiving_address but I did not find where that was generated. Please ensure that the value being passed is a valid address, as it seems the length is not proper.

5

In addition, for an account to receive an asset, it must first opt into the asset by sending an opt in transaction to themselves.

6

Hey @maxpower did you get you asset transfer transaction sorted? We are here to help you succeed.

1 Like
7

Hey Ryan and Jason

Thanks so much for your answers (and sorry for my late reply)! I was really desperate cause I did not understand the error and couldn’t proceed. It was indeed the missing opt-in for some of the accounts that I tried to send assets to.

This community is so cool. Always so helpful :slight_smile:
Have a great day!

8

Glad you got it to work!

1 Like