diff --git a/.gitignore b/.gitignore
index 37bd23e3..a0d422f5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,4 +29,5 @@ tests/mytest.py
 *.swo
 
 # IDES
-.idea/
\ No newline at end of file
+.idea/
+.vscode/
\ No newline at end of file
diff --git a/skycoin/__init__.py b/skycoin/__init__.py
index b3d9f8a3..3fc52b7f 100644
--- a/skycoin/__init__.py
+++ b/skycoin/__init__.py
@@ -1,4 +1,3 @@
-
 __version__ = "0.25.0"
 init_error = None
 
@@ -7,7 +6,6 @@ def _print2stderr(msg):
 
 try:
     from .skycoin import *
-    from .skyerror import *
 except (AttributeError, ImportError) as _err :
     init_error = _err
 
diff --git a/skycoin/skycoin.py b/skycoin/skycoin.py
index a49247a7..9b02a7be 100644
--- a/skycoin/skycoin.py
+++ b/skycoin/skycoin.py
@@ -641,333 +641,397 @@ def __init__(self):
 GoSlice_swigregister(GoSlice)
 
 
-def SKY_coin_NewBlock(p0, p1, p2, p3, p4):
-    return _skycoin.SKY_coin_NewBlock(p0, p1, p2, p3, p4)
-SKY_coin_NewBlock = _skycoin.SKY_coin_NewBlock
+def SKY_api_NewWalletResponse(p0):
+    return _skycoin.SKY_api_NewWalletResponse(p0)
+SKY_api_NewWalletResponse = _skycoin.SKY_api_NewWalletResponse
 
-def SKY_coin_SignedBlock_VerifySignature(p0, p1):
-    return _skycoin.SKY_coin_SignedBlock_VerifySignature(p0, p1)
-SKY_coin_SignedBlock_VerifySignature = _skycoin.SKY_coin_SignedBlock_VerifySignature
+def SKY_cli_GenerateAddressesInFile(p0, p1, p2):
+    return _skycoin.SKY_cli_GenerateAddressesInFile(p0, p1, p2)
+SKY_cli_GenerateAddressesInFile = _skycoin.SKY_cli_GenerateAddressesInFile
 
-def SKY_coin_NewGenesisBlock(p0, p1, p2):
-    return _skycoin.SKY_coin_NewGenesisBlock(p0, p1, p2)
-SKY_coin_NewGenesisBlock = _skycoin.SKY_coin_NewGenesisBlock
+def SKY_cli_FormatAddressesAsJSON(p0):
+    return _skycoin.SKY_cli_FormatAddressesAsJSON(p0)
+SKY_cli_FormatAddressesAsJSON = _skycoin.SKY_cli_FormatAddressesAsJSON
 
-def SKY_coin_Block_HashHeader(p0, p1):
-    return _skycoin.SKY_coin_Block_HashHeader(p0, p1)
-SKY_coin_Block_HashHeader = _skycoin.SKY_coin_Block_HashHeader
+def SKY_cli_FormatAddressesAsJoinedArray(p0):
+    return _skycoin.SKY_cli_FormatAddressesAsJoinedArray(p0)
+SKY_cli_FormatAddressesAsJoinedArray = _skycoin.SKY_cli_FormatAddressesAsJoinedArray
 
-def SKY_coin_Block_PreHashHeader(p0, p1):
-    return _skycoin.SKY_coin_Block_PreHashHeader(p0, p1)
-SKY_coin_Block_PreHashHeader = _skycoin.SKY_coin_Block_PreHashHeader
+def SKY_cli_AddressesToStrings(p0):
+    return _skycoin.SKY_cli_AddressesToStrings(p0)
+SKY_cli_AddressesToStrings = _skycoin.SKY_cli_AddressesToStrings
 
-def SKY_coin_Block_Time(p0):
-    return _skycoin.SKY_coin_Block_Time(p0)
-SKY_coin_Block_Time = _skycoin.SKY_coin_Block_Time
+def SKY_wallet_NewReadableEntry(p0, p1):
+    return _skycoin.SKY_wallet_NewReadableEntry(p0, p1)
+SKY_wallet_NewReadableEntry = _skycoin.SKY_wallet_NewReadableEntry
 
-def SKY_coin_Block_Seq(p0):
-    return _skycoin.SKY_coin_Block_Seq(p0)
-SKY_coin_Block_Seq = _skycoin.SKY_coin_Block_Seq
+def SKY_wallet_LoadReadableWallet(p0):
+    return _skycoin.SKY_wallet_LoadReadableWallet(p0)
+SKY_wallet_LoadReadableWallet = _skycoin.SKY_wallet_LoadReadableWallet
 
-def SKY_coin_Block_HashBody(p0, p1):
-    return _skycoin.SKY_coin_Block_HashBody(p0, p1)
-SKY_coin_Block_HashBody = _skycoin.SKY_coin_Block_HashBody
+def SKY_wallet_ReadableWallet_Save(p0, p1):
+    return _skycoin.SKY_wallet_ReadableWallet_Save(p0, p1)
+SKY_wallet_ReadableWallet_Save = _skycoin.SKY_wallet_ReadableWallet_Save
 
-def SKY_coin_Block_Size(p0):
-    return _skycoin.SKY_coin_Block_Size(p0)
-SKY_coin_Block_Size = _skycoin.SKY_coin_Block_Size
+def SKY_wallet_ReadableWallet_Load(p0, p1):
+    return _skycoin.SKY_wallet_ReadableWallet_Load(p0, p1)
+SKY_wallet_ReadableWallet_Load = _skycoin.SKY_wallet_ReadableWallet_Load
 
-def SKY_coin_Block_String(p0):
-    return _skycoin.SKY_coin_Block_String(p0)
-SKY_coin_Block_String = _skycoin.SKY_coin_Block_String
+def SKY_wallet_ReadableWallet_Erase(p0):
+    return _skycoin.SKY_wallet_ReadableWallet_Erase(p0)
+SKY_wallet_ReadableWallet_Erase = _skycoin.SKY_wallet_ReadableWallet_Erase
 
-def SKY_coin_Block_GetTransaction(p0, p1):
-    return _skycoin.SKY_coin_Block_GetTransaction(p0, p1)
-SKY_coin_Block_GetTransaction = _skycoin.SKY_coin_Block_GetTransaction
+def SKY_logging_EnableColors():
+    return _skycoin.SKY_logging_EnableColors()
+SKY_logging_EnableColors = _skycoin.SKY_logging_EnableColors
 
-def SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5):
-    return _skycoin.SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5)
-SKY_coin_NewBlockHeader = _skycoin.SKY_coin_NewBlockHeader
+def SKY_logging_DisableColors():
+    return _skycoin.SKY_logging_DisableColors()
+SKY_logging_DisableColors = _skycoin.SKY_logging_DisableColors
 
-def SKY_coin_BlockHeader_Hash(p0, p1):
-    return _skycoin.SKY_coin_BlockHeader_Hash(p0, p1)
-SKY_coin_BlockHeader_Hash = _skycoin.SKY_coin_BlockHeader_Hash
+def SKY_logging_Disable():
+    return _skycoin.SKY_logging_Disable()
+SKY_logging_Disable = _skycoin.SKY_logging_Disable
 
-def SKY_coin_BlockHeader_Bytes(p0):
-    return _skycoin.SKY_coin_BlockHeader_Bytes(p0)
-SKY_coin_BlockHeader_Bytes = _skycoin.SKY_coin_BlockHeader_Bytes
+def SKY_fee_VerifyTransactionFee(p0, p1, p2):
+    return _skycoin.SKY_fee_VerifyTransactionFee(p0, p1, p2)
+SKY_fee_VerifyTransactionFee = _skycoin.SKY_fee_VerifyTransactionFee
 
-def SKY_coin_BlockHeader_String(p0):
-    return _skycoin.SKY_coin_BlockHeader_String(p0)
-SKY_coin_BlockHeader_String = _skycoin.SKY_coin_BlockHeader_String
+def SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2):
+    return _skycoin.SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2)
+SKY_fee_VerifyTransactionFeeForHours = _skycoin.SKY_fee_VerifyTransactionFeeForHours
 
-def SKY_coin_BlockBody_Hash(p0, p1):
-    return _skycoin.SKY_coin_BlockBody_Hash(p0, p1)
-SKY_coin_BlockBody_Hash = _skycoin.SKY_coin_BlockBody_Hash
+def SKY_fee_RequiredFee(p0, p1):
+    return _skycoin.SKY_fee_RequiredFee(p0, p1)
+SKY_fee_RequiredFee = _skycoin.SKY_fee_RequiredFee
 
-def SKY_coin_BlockBody_Size():
-    return _skycoin.SKY_coin_BlockBody_Size()
-SKY_coin_BlockBody_Size = _skycoin.SKY_coin_BlockBody_Size
+def SKY_fee_RemainingHours(p0, p1):
+    return _skycoin.SKY_fee_RemainingHours(p0, p1)
+SKY_fee_RemainingHours = _skycoin.SKY_fee_RemainingHours
 
-def SKY_coin_BlockBody_Bytes(p0):
-    return _skycoin.SKY_coin_BlockBody_Bytes(p0)
-SKY_coin_BlockBody_Bytes = _skycoin.SKY_coin_BlockBody_Bytes
+def SKY_fee_TransactionFee(*args):
+    return _skycoin.SKY_fee_TransactionFee(*args)
+SKY_fee_TransactionFee = _skycoin.SKY_fee_TransactionFee
 
-def SKY_coin_CreateUnspents(*args):
-    return _skycoin.SKY_coin_CreateUnspents(*args)
-SKY_coin_CreateUnspents = _skycoin.SKY_coin_CreateUnspents
+def SKY_JsonEncode_Handle(p0):
+    return _skycoin.SKY_JsonEncode_Handle(p0)
+SKY_JsonEncode_Handle = _skycoin.SKY_JsonEncode_Handle
 
-def SKY_coin_CreateUnspent(p0, p1, p2, p3):
-    return _skycoin.SKY_coin_CreateUnspent(p0, p1, p2, p3)
-SKY_coin_CreateUnspent = _skycoin.SKY_coin_CreateUnspent
+def SKY_Handle_Progress_GetCurrent(p0):
+    return _skycoin.SKY_Handle_Progress_GetCurrent(p0)
+SKY_Handle_Progress_GetCurrent = _skycoin.SKY_Handle_Progress_GetCurrent
 
-def SKY_coin_GetBlockObject(p0):
-    return _skycoin.SKY_coin_GetBlockObject(p0)
-SKY_coin_GetBlockObject = _skycoin.SKY_coin_GetBlockObject
+def SKY_Handle_Block_GetHeadSeq(p0):
+    return _skycoin.SKY_Handle_Block_GetHeadSeq(p0)
+SKY_Handle_Block_GetHeadSeq = _skycoin.SKY_Handle_Block_GetHeadSeq
 
-def SKY_coin_GetBlockBody(p0):
-    return _skycoin.SKY_coin_GetBlockBody(p0)
-SKY_coin_GetBlockBody = _skycoin.SKY_coin_GetBlockBody
+def SKY_Handle_Block_GetHeadHash(p0):
+    return _skycoin.SKY_Handle_Block_GetHeadHash(p0)
+SKY_Handle_Block_GetHeadHash = _skycoin.SKY_Handle_Block_GetHeadHash
 
-def SKY_coin_NewEmptyBlock(p0):
-    return _skycoin.SKY_coin_NewEmptyBlock(p0)
-SKY_coin_NewEmptyBlock = _skycoin.SKY_coin_NewEmptyBlock
+def SKY_Handle_Block_GetPreviousBlockHash(p0):
+    return _skycoin.SKY_Handle_Block_GetPreviousBlockHash(p0)
+SKY_Handle_Block_GetPreviousBlockHash = _skycoin.SKY_Handle_Block_GetPreviousBlockHash
 
-def SKY_bip39_NewDefaultMnemomic():
-    return _skycoin.SKY_bip39_NewDefaultMnemomic()
-SKY_bip39_NewDefaultMnemomic = _skycoin.SKY_bip39_NewDefaultMnemomic
+def SKY_Handle_Blocks_GetAt(p0, p1):
+    return _skycoin.SKY_Handle_Blocks_GetAt(p0, p1)
+SKY_Handle_Blocks_GetAt = _skycoin.SKY_Handle_Blocks_GetAt
 
-def SKY_bip39_NewEntropy(p0):
-    return _skycoin.SKY_bip39_NewEntropy(p0)
-SKY_bip39_NewEntropy = _skycoin.SKY_bip39_NewEntropy
+def SKY_Handle_Blocks_GetCount(p0):
+    return _skycoin.SKY_Handle_Blocks_GetCount(p0)
+SKY_Handle_Blocks_GetCount = _skycoin.SKY_Handle_Blocks_GetCount
 
-def SKY_bip39_NewMnemonic(p0):
-    return _skycoin.SKY_bip39_NewMnemonic(p0)
-SKY_bip39_NewMnemonic = _skycoin.SKY_bip39_NewMnemonic
+def SKY_Handle_Connections_GetCount(p0):
+    return _skycoin.SKY_Handle_Connections_GetCount(p0)
+SKY_Handle_Connections_GetCount = _skycoin.SKY_Handle_Connections_GetCount
 
-def SKY_bip39_MnemonicToByteArray(p0):
-    return _skycoin.SKY_bip39_MnemonicToByteArray(p0)
-SKY_bip39_MnemonicToByteArray = _skycoin.SKY_bip39_MnemonicToByteArray
+def SKY_Handle_Strings_GetCount(p0):
+    return _skycoin.SKY_Handle_Strings_GetCount(p0)
+SKY_Handle_Strings_GetCount = _skycoin.SKY_Handle_Strings_GetCount
 
-def SKY_bip39_IsMnemonicValid(p0):
-    return _skycoin.SKY_bip39_IsMnemonicValid(p0)
-SKY_bip39_IsMnemonicValid = _skycoin.SKY_bip39_IsMnemonicValid
+def SKY_Handle_Strings_Sort(p0):
+    return _skycoin.SKY_Handle_Strings_Sort(p0)
+SKY_Handle_Strings_Sort = _skycoin.SKY_Handle_Strings_Sort
 
-def SKY_api_NewClient(p0):
-    return _skycoin.SKY_api_NewClient(p0)
-SKY_api_NewClient = _skycoin.SKY_api_NewClient
+def SKY_Handle_Strings_GetAt(p0, p1):
+    return _skycoin.SKY_Handle_Strings_GetAt(p0, p1)
+SKY_Handle_Strings_GetAt = _skycoin.SKY_Handle_Strings_GetAt
 
-def SKY_api_Client_CSRF(p0):
-    return _skycoin.SKY_api_Client_CSRF(p0)
-SKY_api_Client_CSRF = _skycoin.SKY_api_Client_CSRF
+def SKY_api_Handle_Client_GetWalletDir(p0):
+    return _skycoin.SKY_api_Handle_Client_GetWalletDir(p0)
+SKY_api_Handle_Client_GetWalletDir = _skycoin.SKY_api_Handle_Client_GetWalletDir
 
-def SKY_api_Client_Version(p0):
-    return _skycoin.SKY_api_Client_Version(p0)
-SKY_api_Client_Version = _skycoin.SKY_api_Client_Version
+def SKY_api_Handle_Client_GetWalletFileName(p0):
+    return _skycoin.SKY_api_Handle_Client_GetWalletFileName(p0)
+SKY_api_Handle_Client_GetWalletFileName = _skycoin.SKY_api_Handle_Client_GetWalletFileName
 
-def SKY_api_Client_Outputs(p0):
-    return _skycoin.SKY_api_Client_Outputs(p0)
-SKY_api_Client_Outputs = _skycoin.SKY_api_Client_Outputs
+def SKY_api_Handle_Client_GetWalletLabel(p0):
+    return _skycoin.SKY_api_Handle_Client_GetWalletLabel(p0)
+SKY_api_Handle_Client_GetWalletLabel = _skycoin.SKY_api_Handle_Client_GetWalletLabel
 
-def SKY_api_Client_OutputsForAddresses(p0, p1):
-    return _skycoin.SKY_api_Client_OutputsForAddresses(p0, p1)
-SKY_api_Client_OutputsForAddresses = _skycoin.SKY_api_Client_OutputsForAddresses
+def SKY_api_Handle_Client_GetWalletFullPath(p0, p1):
+    return _skycoin.SKY_api_Handle_Client_GetWalletFullPath(p0, p1)
+SKY_api_Handle_Client_GetWalletFullPath = _skycoin.SKY_api_Handle_Client_GetWalletFullPath
 
-def SKY_api_Client_OutputsForHashes(p0, p1):
-    return _skycoin.SKY_api_Client_OutputsForHashes(p0, p1)
-SKY_api_Client_OutputsForHashes = _skycoin.SKY_api_Client_OutputsForHashes
+def SKY_api_Handle_GetWalletMeta(p0):
+    return _skycoin.SKY_api_Handle_GetWalletMeta(p0)
+SKY_api_Handle_GetWalletMeta = _skycoin.SKY_api_Handle_GetWalletMeta
 
-def SKY_api_Client_CoinSupply(p0):
-    return _skycoin.SKY_api_Client_CoinSupply(p0)
-SKY_api_Client_CoinSupply = _skycoin.SKY_api_Client_CoinSupply
+def SKY_api_Handle_GetWalletEntriesCount(p0):
+    return _skycoin.SKY_api_Handle_GetWalletEntriesCount(p0)
+SKY_api_Handle_GetWalletEntriesCount = _skycoin.SKY_api_Handle_GetWalletEntriesCount
 
-def SKY_api_Client_BlockByHash(p0, p1):
-    return _skycoin.SKY_api_Client_BlockByHash(p0, p1)
-SKY_api_Client_BlockByHash = _skycoin.SKY_api_Client_BlockByHash
+def SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0):
+    return _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0)
+SKY_api_Handle_Client_GetWalletResponseEntriesCount = _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount
 
-def SKY_api_Client_BlockBySeq(p0, p1):
-    return _skycoin.SKY_api_Client_BlockBySeq(p0, p1)
-SKY_api_Client_BlockBySeq = _skycoin.SKY_api_Client_BlockBySeq
+def SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3):
+    return _skycoin.SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3)
+SKY_api_Handle_WalletGetEntry = _skycoin.SKY_api_Handle_WalletGetEntry
 
-def SKY_api_Client_Blocks(p0, p1):
-    return _skycoin.SKY_api_Client_Blocks(p0, p1)
-SKY_api_Client_Blocks = _skycoin.SKY_api_Client_Blocks
+def SKY_api_Handle_WalletResponseGetEntry(p0, p1):
+    return _skycoin.SKY_api_Handle_WalletResponseGetEntry(p0, p1)
+SKY_api_Handle_WalletResponseGetEntry = _skycoin.SKY_api_Handle_WalletResponseGetEntry
 
-def SKY_api_Client_LastBlocks(p0, p1):
-    return _skycoin.SKY_api_Client_LastBlocks(p0, p1)
-SKY_api_Client_LastBlocks = _skycoin.SKY_api_Client_LastBlocks
+def SKY_api_Handle_WalletResponseIsEncrypted(p0):
+    return _skycoin.SKY_api_Handle_WalletResponseIsEncrypted(p0)
+SKY_api_Handle_WalletResponseIsEncrypted = _skycoin.SKY_api_Handle_WalletResponseIsEncrypted
 
-def SKY_api_Client_BlockchainMetadata(p0):
-    return _skycoin.SKY_api_Client_BlockchainMetadata(p0)
-SKY_api_Client_BlockchainMetadata = _skycoin.SKY_api_Client_BlockchainMetadata
+def SKY_api_Handle_WalletResponseGetCryptoType(p0):
+    return _skycoin.SKY_api_Handle_WalletResponseGetCryptoType(p0)
+SKY_api_Handle_WalletResponseGetCryptoType = _skycoin.SKY_api_Handle_WalletResponseGetCryptoType
 
-def SKY_api_Client_BlockchainProgress(p0):
-    return _skycoin.SKY_api_Client_BlockchainProgress(p0)
-SKY_api_Client_BlockchainProgress = _skycoin.SKY_api_Client_BlockchainProgress
+def SKY_api_Handle_WalletsResponseGetCount(p0):
+    return _skycoin.SKY_api_Handle_WalletsResponseGetCount(p0)
+SKY_api_Handle_WalletsResponseGetCount = _skycoin.SKY_api_Handle_WalletsResponseGetCount
 
-def SKY_api_Client_Balance(p0, p1, p2):
-    return _skycoin.SKY_api_Client_Balance(p0, p1, p2)
-SKY_api_Client_Balance = _skycoin.SKY_api_Client_Balance
+def SKY_api_Handle_WalletsResponseGetAt(p0, p1):
+    return _skycoin.SKY_api_Handle_WalletsResponseGetAt(p0, p1)
+SKY_api_Handle_WalletsResponseGetAt = _skycoin.SKY_api_Handle_WalletsResponseGetAt
 
-def SKY_api_Client_UxOut(p0, p1):
-    return _skycoin.SKY_api_Client_UxOut(p0, p1)
-SKY_api_Client_UxOut = _skycoin.SKY_api_Client_UxOut
+def SKY_api_Handle_GetWalletFolderAddress(p0):
+    return _skycoin.SKY_api_Handle_GetWalletFolderAddress(p0)
+SKY_api_Handle_GetWalletFolderAddress = _skycoin.SKY_api_Handle_GetWalletFolderAddress
 
-def SKY_api_Client_AddressUxOuts(p0, p1):
-    return _skycoin.SKY_api_Client_AddressUxOuts(p0, p1)
-SKY_api_Client_AddressUxOuts = _skycoin.SKY_api_Client_AddressUxOuts
+def SKY_api_Handle_GetWalletSeed(p0):
+    return _skycoin.SKY_api_Handle_GetWalletSeed(p0)
+SKY_api_Handle_GetWalletSeed = _skycoin.SKY_api_Handle_GetWalletSeed
 
-def SKY_api_Client_Wallet(p0, p1):
-    return _skycoin.SKY_api_Client_Wallet(p0, p1)
-SKY_api_Client_Wallet = _skycoin.SKY_api_Client_Wallet
+def SKY_api_Handle_GetWalletLastSeed(p0):
+    return _skycoin.SKY_api_Handle_GetWalletLastSeed(p0)
+SKY_api_Handle_GetWalletLastSeed = _skycoin.SKY_api_Handle_GetWalletLastSeed
 
-def SKY_api_Client_Wallets(p0):
-    return _skycoin.SKY_api_Client_Wallets(p0)
-SKY_api_Client_Wallets = _skycoin.SKY_api_Client_Wallets
+def SKY_api_Handle_GetBuildInfoData(p0):
+    return _skycoin.SKY_api_Handle_GetBuildInfoData(p0)
+SKY_api_Handle_GetBuildInfoData = _skycoin.SKY_api_Handle_GetBuildInfoData
 
-def SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3):
-    return _skycoin.SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3)
-SKY_api_Client_CreateUnencryptedWallet = _skycoin.SKY_api_Client_CreateUnencryptedWallet
+def SKY_cli_AddPrivateKey(p0, p1):
+    return _skycoin.SKY_cli_AddPrivateKey(p0, p1)
+SKY_cli_AddPrivateKey = _skycoin.SKY_cli_AddPrivateKey
 
-def SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4):
-    return _skycoin.SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4)
-SKY_api_Client_CreateEncryptedWallet = _skycoin.SKY_api_Client_CreateEncryptedWallet
+def SKY_cli_AddPrivateKeyToFile(p0, p1, p2):
+    return _skycoin.SKY_cli_AddPrivateKeyToFile(p0, p1, p2)
+SKY_cli_AddPrivateKeyToFile = _skycoin.SKY_cli_AddPrivateKeyToFile
 
-def SKY_api_Client_NewWalletAddress(p0, p1, p2, p3):
-    return _skycoin.SKY_api_Client_NewWalletAddress(p0, p1, p2, p3)
-SKY_api_Client_NewWalletAddress = _skycoin.SKY_api_Client_NewWalletAddress
+def SKY_coin_Create_Transaction():
+    return _skycoin.SKY_coin_Create_Transaction()
+SKY_coin_Create_Transaction = _skycoin.SKY_coin_Create_Transaction
 
-def SKY_api_Client_WalletBalance(p0, p1, p2):
-    return _skycoin.SKY_api_Client_WalletBalance(p0, p1, p2)
-SKY_api_Client_WalletBalance = _skycoin.SKY_api_Client_WalletBalance
+def SKY_coin_Transaction_Copy(p0):
+    return _skycoin.SKY_coin_Transaction_Copy(p0)
+SKY_coin_Transaction_Copy = _skycoin.SKY_coin_Transaction_Copy
 
-def SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5):
-    return _skycoin.SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5)
-SKY_api_Client_Spend = _skycoin.SKY_api_Client_Spend
+def SKY_coin_GetTransactionObject(p0):
+    return _skycoin.SKY_coin_GetTransactionObject(p0)
+SKY_coin_GetTransactionObject = _skycoin.SKY_coin_GetTransactionObject
 
-def SKY_api_Client_CreateTransaction(p0):
-    return _skycoin.SKY_api_Client_CreateTransaction(p0)
-SKY_api_Client_CreateTransaction = _skycoin.SKY_api_Client_CreateTransaction
+def SKY_coin_Transaction_ResetInputs(p0, p1):
+    return _skycoin.SKY_coin_Transaction_ResetInputs(p0, p1)
+SKY_coin_Transaction_ResetInputs = _skycoin.SKY_coin_Transaction_ResetInputs
 
-def SKY_api_Client_UpdateWallet(p0, p1, p2):
-    return _skycoin.SKY_api_Client_UpdateWallet(p0, p1, p2)
-SKY_api_Client_UpdateWallet = _skycoin.SKY_api_Client_UpdateWallet
+def SKY_coin_Transaction_GetInputsCount(p0):
+    return _skycoin.SKY_coin_Transaction_GetInputsCount(p0)
+SKY_coin_Transaction_GetInputsCount = _skycoin.SKY_coin_Transaction_GetInputsCount
 
-def SKY_api_Client_WalletFolderName(p0):
-    return _skycoin.SKY_api_Client_WalletFolderName(p0)
-SKY_api_Client_WalletFolderName = _skycoin.SKY_api_Client_WalletFolderName
+def SKY_coin_Transaction_GetInputAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_GetInputAt(p0, p1, p2)
+SKY_coin_Transaction_GetInputAt = _skycoin.SKY_coin_Transaction_GetInputAt
 
-def SKY_api_Client_NewSeed(p0, p1):
-    return _skycoin.SKY_api_Client_NewSeed(p0, p1)
-SKY_api_Client_NewSeed = _skycoin.SKY_api_Client_NewSeed
+def SKY_coin_Transaction_SetInputAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_SetInputAt(p0, p1, p2)
+SKY_coin_Transaction_SetInputAt = _skycoin.SKY_coin_Transaction_SetInputAt
 
-def SKY_api_Client_WalletSeed(p0, p1, p2):
-    return _skycoin.SKY_api_Client_WalletSeed(p0, p1, p2)
-SKY_api_Client_WalletSeed = _skycoin.SKY_api_Client_WalletSeed
+def SKY_coin_Transaction_GetOutputsCount(p0):
+    return _skycoin.SKY_coin_Transaction_GetOutputsCount(p0)
+SKY_coin_Transaction_GetOutputsCount = _skycoin.SKY_coin_Transaction_GetOutputsCount
+
+def SKY_coin_Transaction_GetOutputAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_GetOutputAt(p0, p1, p2)
+SKY_coin_Transaction_GetOutputAt = _skycoin.SKY_coin_Transaction_GetOutputAt
+
+def SKY_coin_Transaction_SetOutputAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_SetOutputAt(p0, p1, p2)
+SKY_coin_Transaction_SetOutputAt = _skycoin.SKY_coin_Transaction_SetOutputAt
+
+def SKY_coin_Transaction_GetSignaturesCount(p0):
+    return _skycoin.SKY_coin_Transaction_GetSignaturesCount(p0)
+SKY_coin_Transaction_GetSignaturesCount = _skycoin.SKY_coin_Transaction_GetSignaturesCount
+
+def SKY_coin_Transaction_GetSignatureAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_GetSignatureAt(p0, p1, p2)
+SKY_coin_Transaction_GetSignatureAt = _skycoin.SKY_coin_Transaction_GetSignatureAt
+
+def SKY_coin_Transaction_SetSignatureAt(p0, p1, p2):
+    return _skycoin.SKY_coin_Transaction_SetSignatureAt(p0, p1, p2)
+SKY_coin_Transaction_SetSignatureAt = _skycoin.SKY_coin_Transaction_SetSignatureAt
+
+def SKY_coin_Transaction_PushSignature(p0, p1):
+    return _skycoin.SKY_coin_Transaction_PushSignature(p0, p1)
+SKY_coin_Transaction_PushSignature = _skycoin.SKY_coin_Transaction_PushSignature
+
+def SKY_coin_Transaction_ResetOutputs(p0, p1):
+    return _skycoin.SKY_coin_Transaction_ResetOutputs(p0, p1)
+SKY_coin_Transaction_ResetOutputs = _skycoin.SKY_coin_Transaction_ResetOutputs
+
+def SKY_coin_Transaction_ResetSignatures(p0, p1):
+    return _skycoin.SKY_coin_Transaction_ResetSignatures(p0, p1)
+SKY_coin_Transaction_ResetSignatures = _skycoin.SKY_coin_Transaction_ResetSignatures
+
+def SKY_coin_Transaction_Verify(p0):
+    return _skycoin.SKY_coin_Transaction_Verify(p0)
+SKY_coin_Transaction_Verify = _skycoin.SKY_coin_Transaction_Verify
+
+def SKY_coin_Transaction_VerifyInput(*args):
+    return _skycoin.SKY_coin_Transaction_VerifyInput(*args)
+SKY_coin_Transaction_VerifyInput = _skycoin.SKY_coin_Transaction_VerifyInput
+
+def SKY_coin_Transaction_PushInput(p0, p1):
+    return _skycoin.SKY_coin_Transaction_PushInput(p0, p1)
+SKY_coin_Transaction_PushInput = _skycoin.SKY_coin_Transaction_PushInput
+
+def SKY_coin_TransactionOutput_UxID(p0, p1, p2):
+    return _skycoin.SKY_coin_TransactionOutput_UxID(p0, p1, p2)
+SKY_coin_TransactionOutput_UxID = _skycoin.SKY_coin_TransactionOutput_UxID
+
+def SKY_coin_Transaction_PushOutput(p0, p1, p2, p3):
+    return _skycoin.SKY_coin_Transaction_PushOutput(p0, p1, p2, p3)
+SKY_coin_Transaction_PushOutput = _skycoin.SKY_coin_Transaction_PushOutput
+
+def SKY_coin_Transaction_SignInputs(*args):
+    return _skycoin.SKY_coin_Transaction_SignInputs(*args)
+SKY_coin_Transaction_SignInputs = _skycoin.SKY_coin_Transaction_SignInputs
+
+def SKY_coin_Transaction_Size(p0):
+    return _skycoin.SKY_coin_Transaction_Size(p0)
+SKY_coin_Transaction_Size = _skycoin.SKY_coin_Transaction_Size
+
+def SKY_coin_Transaction_Hash(p0, p1):
+    return _skycoin.SKY_coin_Transaction_Hash(p0, p1)
+SKY_coin_Transaction_Hash = _skycoin.SKY_coin_Transaction_Hash
 
-def SKY_api_Client_NetworkConnection(p0, p1):
-    return _skycoin.SKY_api_Client_NetworkConnection(p0, p1)
-SKY_api_Client_NetworkConnection = _skycoin.SKY_api_Client_NetworkConnection
+def SKY_coin_Transaction_SizeHash(p0, p2):
+    return _skycoin.SKY_coin_Transaction_SizeHash(p0, p2)
+SKY_coin_Transaction_SizeHash = _skycoin.SKY_coin_Transaction_SizeHash
 
-def SKY_api_Client_NetworkConnections(p0, p1):
-    return _skycoin.SKY_api_Client_NetworkConnections(p0, p1)
-SKY_api_Client_NetworkConnections = _skycoin.SKY_api_Client_NetworkConnections
+def SKY_coin_Transaction_TxID(p0):
+    return _skycoin.SKY_coin_Transaction_TxID(p0)
+SKY_coin_Transaction_TxID = _skycoin.SKY_coin_Transaction_TxID
 
-def SKY_api_Client_NetworkDefaultPeers(p0):
-    return _skycoin.SKY_api_Client_NetworkDefaultPeers(p0)
-SKY_api_Client_NetworkDefaultPeers = _skycoin.SKY_api_Client_NetworkDefaultPeers
+def SKY_coin_Transaction_TxIDHex(p0):
+    return _skycoin.SKY_coin_Transaction_TxIDHex(p0)
+SKY_coin_Transaction_TxIDHex = _skycoin.SKY_coin_Transaction_TxIDHex
 
-def SKY_api_Client_NetworkTrustedPeers(p0):
-    return _skycoin.SKY_api_Client_NetworkTrustedPeers(p0)
-SKY_api_Client_NetworkTrustedPeers = _skycoin.SKY_api_Client_NetworkTrustedPeers
+def SKY_coin_Transaction_UpdateHeader(p0):
+    return _skycoin.SKY_coin_Transaction_UpdateHeader(p0)
+SKY_coin_Transaction_UpdateHeader = _skycoin.SKY_coin_Transaction_UpdateHeader
 
-def SKY_api_Client_NetworkExchangedPeers(p0):
-    return _skycoin.SKY_api_Client_NetworkExchangedPeers(p0)
-SKY_api_Client_NetworkExchangedPeers = _skycoin.SKY_api_Client_NetworkExchangedPeers
+def SKY_coin_Transaction_HashInner(p0, p1):
+    return _skycoin.SKY_coin_Transaction_HashInner(p0, p1)
+SKY_coin_Transaction_HashInner = _skycoin.SKY_coin_Transaction_HashInner
 
-def SKY_api_Client_PendingTransactions(p0):
-    return _skycoin.SKY_api_Client_PendingTransactions(p0)
-SKY_api_Client_PendingTransactions = _skycoin.SKY_api_Client_PendingTransactions
+def SKY_coin_Transaction_Serialize(p0):
+    return _skycoin.SKY_coin_Transaction_Serialize(p0)
+SKY_coin_Transaction_Serialize = _skycoin.SKY_coin_Transaction_Serialize
 
-def SKY_api_Client_Transaction(p0, p1):
-    return _skycoin.SKY_api_Client_Transaction(p0, p1)
-SKY_api_Client_Transaction = _skycoin.SKY_api_Client_Transaction
+def SKY_coin_TransactionDeserialize(p0):
+    return _skycoin.SKY_coin_TransactionDeserialize(p0)
+SKY_coin_TransactionDeserialize = _skycoin.SKY_coin_TransactionDeserialize
 
-def SKY_api_Client_Transactions(p0, p1):
-    return _skycoin.SKY_api_Client_Transactions(p0, p1)
-SKY_api_Client_Transactions = _skycoin.SKY_api_Client_Transactions
+def SKY_coin_Transaction_OutputHours(p0):
+    return _skycoin.SKY_coin_Transaction_OutputHours(p0)
+SKY_coin_Transaction_OutputHours = _skycoin.SKY_coin_Transaction_OutputHours
 
-def SKY_api_Client_ConfirmedTransactions(p0, p1):
-    return _skycoin.SKY_api_Client_ConfirmedTransactions(p0, p1)
-SKY_api_Client_ConfirmedTransactions = _skycoin.SKY_api_Client_ConfirmedTransactions
+def SKY_coin_Create_Transactions():
+    return _skycoin.SKY_coin_Create_Transactions()
+SKY_coin_Create_Transactions = _skycoin.SKY_coin_Create_Transactions
 
-def SKY_api_Client_UnconfirmedTransactions(p0, p1):
-    return _skycoin.SKY_api_Client_UnconfirmedTransactions(p0, p1)
-SKY_api_Client_UnconfirmedTransactions = _skycoin.SKY_api_Client_UnconfirmedTransactions
+def SKY_coin_GetTransactionsObject(p0, p1):
+    return _skycoin.SKY_coin_GetTransactionsObject(p0, p1)
+SKY_coin_GetTransactionsObject = _skycoin.SKY_coin_GetTransactionsObject
 
-def SKY_api_Client_InjectTransaction(p0, p1):
-    return _skycoin.SKY_api_Client_InjectTransaction(p0, p1)
-SKY_api_Client_InjectTransaction = _skycoin.SKY_api_Client_InjectTransaction
+def SKY_coin_Transactions_Length(p0):
+    return _skycoin.SKY_coin_Transactions_Length(p0)
+SKY_coin_Transactions_Length = _skycoin.SKY_coin_Transactions_Length
 
-def SKY_api_Client_ResendUnconfirmedTransactions(p0):
-    return _skycoin.SKY_api_Client_ResendUnconfirmedTransactions(p0)
-SKY_api_Client_ResendUnconfirmedTransactions = _skycoin.SKY_api_Client_ResendUnconfirmedTransactions
+def SKY_coin_Transactions_Add(p0, p1):
+    return _skycoin.SKY_coin_Transactions_Add(p0, p1)
+SKY_coin_Transactions_Add = _skycoin.SKY_coin_Transactions_Add
 
-def SKY_api_Client_RawTransaction(p0, p1):
-    return _skycoin.SKY_api_Client_RawTransaction(p0, p1)
-SKY_api_Client_RawTransaction = _skycoin.SKY_api_Client_RawTransaction
+def SKY_coin_Transactions_Fees(p0, p1):
+    return _skycoin.SKY_coin_Transactions_Fees(p0, p1)
+SKY_coin_Transactions_Fees = _skycoin.SKY_coin_Transactions_Fees
 
-def SKY_api_Client_AddressTransactions(p0, p1):
-    return _skycoin.SKY_api_Client_AddressTransactions(p0, p1)
-SKY_api_Client_AddressTransactions = _skycoin.SKY_api_Client_AddressTransactions
+def SKY_coin_Transactions_GetAt(p0, p1):
+    return _skycoin.SKY_coin_Transactions_GetAt(p0, p1)
+SKY_coin_Transactions_GetAt = _skycoin.SKY_coin_Transactions_GetAt
 
-def SKY_api_Client_Richlist(p0, p1):
-    return _skycoin.SKY_api_Client_Richlist(p0, p1)
-SKY_api_Client_Richlist = _skycoin.SKY_api_Client_Richlist
+def SKY_coin_Transactions_Hashes(*args):
+    return _skycoin.SKY_coin_Transactions_Hashes(*args)
+SKY_coin_Transactions_Hashes = _skycoin.SKY_coin_Transactions_Hashes
 
-def SKY_api_Client_AddressCount(p0):
-    return _skycoin.SKY_api_Client_AddressCount(p0)
-SKY_api_Client_AddressCount = _skycoin.SKY_api_Client_AddressCount
+def SKY_coin_Transactions_Size(p0):
+    return _skycoin.SKY_coin_Transactions_Size(p0)
+SKY_coin_Transactions_Size = _skycoin.SKY_coin_Transactions_Size
 
-def SKY_api_Client_UnloadWallet(p0, p1):
-    return _skycoin.SKY_api_Client_UnloadWallet(p0, p1)
-SKY_api_Client_UnloadWallet = _skycoin.SKY_api_Client_UnloadWallet
+def SKY_coin_Transactions_TruncateBytesTo(p0, p1):
+    return _skycoin.SKY_coin_Transactions_TruncateBytesTo(p0, p1)
+SKY_coin_Transactions_TruncateBytesTo = _skycoin.SKY_coin_Transactions_TruncateBytesTo
 
-def SKY_api_Client_Health(p0):
-    return _skycoin.SKY_api_Client_Health(p0)
-SKY_api_Client_Health = _skycoin.SKY_api_Client_Health
+def SKY_coin_SortTransactions(p0, p1):
+    return _skycoin.SKY_coin_SortTransactions(p0, p1)
+SKY_coin_SortTransactions = _skycoin.SKY_coin_SortTransactions
 
-def SKY_api_Client_EncryptWallet(p0, p1, p2):
-    return _skycoin.SKY_api_Client_EncryptWallet(p0, p1, p2)
-SKY_api_Client_EncryptWallet = _skycoin.SKY_api_Client_EncryptWallet
+def SKY_coin_NewSortableTransactions(p0, p1, p2):
+    return _skycoin.SKY_coin_NewSortableTransactions(p0, p1, p2)
+SKY_coin_NewSortableTransactions = _skycoin.SKY_coin_NewSortableTransactions
 
-def SKY_api_Client_DecryptWallet(p0, p1, p2):
-    return _skycoin.SKY_api_Client_DecryptWallet(p0, p1, p2)
-SKY_api_Client_DecryptWallet = _skycoin.SKY_api_Client_DecryptWallet
+def SKY_coin_SortableTransactions_Sort(p0):
+    return _skycoin.SKY_coin_SortableTransactions_Sort(p0)
+SKY_coin_SortableTransactions_Sort = _skycoin.SKY_coin_SortableTransactions_Sort
 
-def SKY_api_NewWalletResponse(p0):
-    return _skycoin.SKY_api_NewWalletResponse(p0)
-SKY_api_NewWalletResponse = _skycoin.SKY_api_NewWalletResponse
+def SKY_coin_SortableTransactions_Len(p0):
+    return _skycoin.SKY_coin_SortableTransactions_Len(p0)
+SKY_coin_SortableTransactions_Len = _skycoin.SKY_coin_SortableTransactions_Len
 
-def SKY_api_NewCreateTransactionResponse(p0, p1):
-    return _skycoin.SKY_api_NewCreateTransactionResponse(p0, p1)
-SKY_api_NewCreateTransactionResponse = _skycoin.SKY_api_NewCreateTransactionResponse
+def SKY_coin_SortableTransactions_Less(p0, p1, p2):
+    return _skycoin.SKY_coin_SortableTransactions_Less(p0, p1, p2)
+SKY_coin_SortableTransactions_Less = _skycoin.SKY_coin_SortableTransactions_Less
 
-def SKY_api_NewCreatedTransaction(p0, p1):
-    return _skycoin.SKY_api_NewCreatedTransaction(p0, p1)
-SKY_api_NewCreatedTransaction = _skycoin.SKY_api_NewCreatedTransaction
+def SKY_coin_SortableTransactions_Swap(p0, p1, p2):
+    return _skycoin.SKY_coin_SortableTransactions_Swap(p0, p1, p2)
+SKY_coin_SortableTransactions_Swap = _skycoin.SKY_coin_SortableTransactions_Swap
 
-def SKY_api_CreatedTransaction_ToTransaction(p0):
-    return _skycoin.SKY_api_CreatedTransaction_ToTransaction(p0)
-SKY_api_CreatedTransaction_ToTransaction = _skycoin.SKY_api_CreatedTransaction_ToTransaction
+def SKY_coin_VerifyTransactionCoinsSpending(*args):
+    return _skycoin.SKY_coin_VerifyTransactionCoinsSpending(*args)
+SKY_coin_VerifyTransactionCoinsSpending = _skycoin.SKY_coin_VerifyTransactionCoinsSpending
 
-def SKY_api_NewCreatedTransactionOutput(p0, p1):
-    return _skycoin.SKY_api_NewCreatedTransactionOutput(p0, p1)
-SKY_api_NewCreatedTransactionOutput = _skycoin.SKY_api_NewCreatedTransactionOutput
+def SKY_coin_VerifyTransactionHoursSpending(*args):
+    return _skycoin.SKY_coin_VerifyTransactionHoursSpending(*args)
+SKY_coin_VerifyTransactionHoursSpending = _skycoin.SKY_coin_VerifyTransactionHoursSpending
 
-def SKY_api_NewCreatedTransactionInput(p0):
-    return _skycoin.SKY_api_NewCreatedTransactionInput(p0)
-SKY_api_NewCreatedTransactionInput = _skycoin.SKY_api_NewCreatedTransactionInput
+def SKY_testutil_MakeAddress(p0):
+    return _skycoin.SKY_testutil_MakeAddress(p0)
+SKY_testutil_MakeAddress = _skycoin.SKY_testutil_MakeAddress
 
 def SKY_wallet_NewError(p0):
     return _skycoin.SKY_wallet_NewError(p0)
@@ -1057,117 +1121,89 @@ def SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2):
     return _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2)
 SKY_wallet_ChooseSpendsMaximizeUxOuts = _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts
 
-def SKY_cli_CheckWalletBalance(p0, p1, p2):
-    return _skycoin.SKY_cli_CheckWalletBalance(p0, p1, p2)
-SKY_cli_CheckWalletBalance = _skycoin.SKY_cli_CheckWalletBalance
-
-def SKY_cli_GetBalanceOfAddresses(p0, p1, p2):
-    return _skycoin.SKY_cli_GetBalanceOfAddresses(p0, p1, p2)
-SKY_cli_GetBalanceOfAddresses = _skycoin.SKY_cli_GetBalanceOfAddresses
-
-def SKY_wallet_NewReadableEntry(p0, p1):
-    return _skycoin.SKY_wallet_NewReadableEntry(p0, p1)
-SKY_wallet_NewReadableEntry = _skycoin.SKY_wallet_NewReadableEntry
-
-def SKY_wallet_LoadReadableWallet(p0):
-    return _skycoin.SKY_wallet_LoadReadableWallet(p0)
-SKY_wallet_LoadReadableWallet = _skycoin.SKY_wallet_LoadReadableWallet
-
-def SKY_wallet_ReadableWallet_Save(p0, p1):
-    return _skycoin.SKY_wallet_ReadableWallet_Save(p0, p1)
-SKY_wallet_ReadableWallet_Save = _skycoin.SKY_wallet_ReadableWallet_Save
-
-def SKY_wallet_ReadableWallet_Load(p0, p1):
-    return _skycoin.SKY_wallet_ReadableWallet_Load(p0, p1)
-SKY_wallet_ReadableWallet_Load = _skycoin.SKY_wallet_ReadableWallet_Load
-
-def SKY_wallet_ReadableWallet_Erase(p0):
-    return _skycoin.SKY_wallet_ReadableWallet_Erase(p0)
-SKY_wallet_ReadableWallet_Erase = _skycoin.SKY_wallet_ReadableWallet_Erase
-
-def SKY_base58_String2Hex(p0):
-    return _skycoin.SKY_base58_String2Hex(p0)
-SKY_base58_String2Hex = _skycoin.SKY_base58_String2Hex
+def SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6):
+    return _skycoin.SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6)
+SKY_wallet_CreateOptionsHandle = _skycoin.SKY_wallet_CreateOptionsHandle
 
-def SKY_base58_Base58_ToInt(p0):
-    return _skycoin.SKY_base58_Base58_ToInt(p0)
-SKY_base58_Base58_ToInt = _skycoin.SKY_base58_Base58_ToInt
+def SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4):
+    return _skycoin.SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4)
+SKY_cli_CreateRawTxFromWallet = _skycoin.SKY_cli_CreateRawTxFromWallet
 
-def SKY_base58_Base58_ToHex(p0):
-    return _skycoin.SKY_base58_Base58_ToHex(p0)
-SKY_base58_Base58_ToHex = _skycoin.SKY_base58_Base58_ToHex
+def SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5):
+    return _skycoin.SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5)
+SKY_cli_CreateRawTxFromAddress = _skycoin.SKY_cli_CreateRawTxFromAddress
 
-def SKY_base58_Base58_Base582Int(p0):
-    return _skycoin.SKY_base58_Base58_Base582Int(p0)
-SKY_base58_Base58_Base582Int = _skycoin.SKY_base58_Base58_Base582Int
+def SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5):
+    return _skycoin.SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5)
+SKY_cli_CreateRawTx = _skycoin.SKY_cli_CreateRawTx
 
-def SKY_base58_Base582Hex(p0):
-    return _skycoin.SKY_base58_Base582Hex(p0)
-SKY_base58_Base582Hex = _skycoin.SKY_base58_Base582Hex
+def SKY_cli_NewTransaction(p0, p1, p2):
+    return _skycoin.SKY_cli_NewTransaction(p0, p1, p2)
+SKY_cli_NewTransaction = _skycoin.SKY_cli_NewTransaction
 
-def SKY_base58_Base58_BitHex(p0):
-    return _skycoin.SKY_base58_Base58_BitHex(p0)
-SKY_base58_Base58_BitHex = _skycoin.SKY_base58_Base58_BitHex
+def SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2):
+    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2)
+SKY_encrypt_ScryptChacha20poly1305_Encrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt
 
-def SKY_base58_Int2Base58(p0):
-    return _skycoin.SKY_base58_Int2Base58(p0)
-SKY_base58_Int2Base58 = _skycoin.SKY_base58_Int2Base58
+def SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2):
+    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2)
+SKY_encrypt_ScryptChacha20poly1305_Decrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt
 
-def SKY_base58_Hex2Base58(p0):
-    return _skycoin.SKY_base58_Hex2Base58(p0)
-SKY_base58_Hex2Base58 = _skycoin.SKY_base58_Hex2Base58
+def SKY_cli_CheckWalletBalance(p0, p1, p2):
+    return _skycoin.SKY_cli_CheckWalletBalance(p0, p1, p2)
+SKY_cli_CheckWalletBalance = _skycoin.SKY_cli_CheckWalletBalance
 
-def SKY_base58_Hex2Base58String(p0):
-    return _skycoin.SKY_base58_Hex2Base58String(p0)
-SKY_base58_Hex2Base58String = _skycoin.SKY_base58_Hex2Base58String
+def SKY_cli_GetBalanceOfAddresses(p0, p1, p2):
+    return _skycoin.SKY_cli_GetBalanceOfAddresses(p0, p1, p2)
+SKY_cli_GetBalanceOfAddresses = _skycoin.SKY_cli_GetBalanceOfAddresses
 
-def SKY_base58_Hex2Base58Str(p0):
-    return _skycoin.SKY_base58_Hex2Base58Str(p0)
-SKY_base58_Hex2Base58Str = _skycoin.SKY_base58_Hex2Base58Str
+def SKY_cli_GetWalletOutputsFromFile(p0, p1, p2):
+    return _skycoin.SKY_cli_GetWalletOutputsFromFile(p0, p1, p2)
+SKY_cli_GetWalletOutputsFromFile = _skycoin.SKY_cli_GetWalletOutputsFromFile
 
-def SKY_cli_GenerateWallet(p0, p2):
-    return _skycoin.SKY_cli_GenerateWallet(p0, p2)
-SKY_cli_GenerateWallet = _skycoin.SKY_cli_GenerateWallet
+def SKY_cli_GetWalletOutputs(p0, p2):
+    return _skycoin.SKY_cli_GetWalletOutputs(p0, p2)
+SKY_cli_GetWalletOutputs = _skycoin.SKY_cli_GetWalletOutputs
 
-def SKY_cli_MakeAlphanumericSeed():
-    return _skycoin.SKY_cli_MakeAlphanumericSeed()
-SKY_cli_MakeAlphanumericSeed = _skycoin.SKY_cli_MakeAlphanumericSeed
+def SKY_coin_AddUint64(p0, p1):
+    return _skycoin.SKY_coin_AddUint64(p0, p1)
+SKY_coin_AddUint64 = _skycoin.SKY_coin_AddUint64
 
-def SKY_webrpc_NewClient(p0):
-    return _skycoin.SKY_webrpc_NewClient(p0)
-SKY_webrpc_NewClient = _skycoin.SKY_webrpc_NewClient
+def SKY_coin_Uint64ToInt64(p0):
+    return _skycoin.SKY_coin_Uint64ToInt64(p0)
+SKY_coin_Uint64ToInt64 = _skycoin.SKY_coin_Uint64ToInt64
 
-def SKY_webrpc_Client_CSRF(p0):
-    return _skycoin.SKY_webrpc_Client_CSRF(p0)
-SKY_webrpc_Client_CSRF = _skycoin.SKY_webrpc_Client_CSRF
+def SKY_coin_Int64ToUint64(p0):
+    return _skycoin.SKY_coin_Int64ToUint64(p0)
+SKY_coin_Int64ToUint64 = _skycoin.SKY_coin_Int64ToUint64
 
-def SKY_webrpc_Client_InjectTransaction(p0, p1):
-    return _skycoin.SKY_webrpc_Client_InjectTransaction(p0, p1)
-SKY_webrpc_Client_InjectTransaction = _skycoin.SKY_webrpc_Client_InjectTransaction
+def SKY_coin_IntToUint32(p0):
+    return _skycoin.SKY_coin_IntToUint32(p0)
+SKY_coin_IntToUint32 = _skycoin.SKY_coin_IntToUint32
 
-def SKY_webrpc_Client_GetStatus(p0, p1):
-    return _skycoin.SKY_webrpc_Client_GetStatus(p0, p1)
-SKY_webrpc_Client_GetStatus = _skycoin.SKY_webrpc_Client_GetStatus
+def SKY_handle_close(p0):
+    return _skycoin.SKY_handle_close(p0)
+SKY_handle_close = _skycoin.SKY_handle_close
 
-def SKY_webrpc_Client_GetTransactionByID(p0, p1, p2):
-    return _skycoin.SKY_webrpc_Client_GetTransactionByID(p0, p1, p2)
-SKY_webrpc_Client_GetTransactionByID = _skycoin.SKY_webrpc_Client_GetTransactionByID
+def SKY_handle_copy(p0):
+    return _skycoin.SKY_handle_copy(p0)
+SKY_handle_copy = _skycoin.SKY_handle_copy
 
-def SKY_webrpc_Client_GetAddressUxOuts(p0, p1):
-    return _skycoin.SKY_webrpc_Client_GetAddressUxOuts(p0, p1)
-SKY_webrpc_Client_GetAddressUxOuts = _skycoin.SKY_webrpc_Client_GetAddressUxOuts
+def SKY_file_InitDataDir(p0):
+    return _skycoin.SKY_file_InitDataDir(p0)
+SKY_file_InitDataDir = _skycoin.SKY_file_InitDataDir
 
-def SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2):
-    return _skycoin.SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2)
-SKY_webrpc_Client_GetBlocksInRange = _skycoin.SKY_webrpc_Client_GetBlocksInRange
+def SKY_file_UserHome():
+    return _skycoin.SKY_file_UserHome()
+SKY_file_UserHome = _skycoin.SKY_file_UserHome
 
-def SKY_webrpc_Client_GetBlocksBySeq(p0, p1):
-    return _skycoin.SKY_webrpc_Client_GetBlocksBySeq(p0, p1)
-SKY_webrpc_Client_GetBlocksBySeq = _skycoin.SKY_webrpc_Client_GetBlocksBySeq
+def SKY_file_ResolveResourceDirectory(p0):
+    return _skycoin.SKY_file_ResolveResourceDirectory(p0)
+SKY_file_ResolveResourceDirectory = _skycoin.SKY_file_ResolveResourceDirectory
 
-def SKY_webrpc_Client_GetLastBlocks(p0, p1):
-    return _skycoin.SKY_webrpc_Client_GetLastBlocks(p0, p1)
-SKY_webrpc_Client_GetLastBlocks = _skycoin.SKY_webrpc_Client_GetLastBlocks
+def SKY_file_DetermineResourcePath(p0, p1, p2):
+    return _skycoin.SKY_file_DetermineResourcePath(p0, p1, p2)
+SKY_file_DetermineResourcePath = _skycoin.SKY_file_DetermineResourcePath
 
 def SKY_iputil_LocalhostIP():
     return _skycoin.SKY_iputil_LocalhostIP()
@@ -1181,37 +1217,73 @@ def SKY_iputil_SplitAddr(p0):
     return _skycoin.SKY_iputil_SplitAddr(p0)
 SKY_iputil_SplitAddr = _skycoin.SKY_iputil_SplitAddr
 
-def SKY_cli_GenerateAddressesInFile(p0, p1, p2):
-    return _skycoin.SKY_cli_GenerateAddressesInFile(p0, p1, p2)
-SKY_cli_GenerateAddressesInFile = _skycoin.SKY_cli_GenerateAddressesInFile
+def SKY_cipher_DecodeBase58BitcoinAddress(p0, p1):
+    return _skycoin.SKY_cipher_DecodeBase58BitcoinAddress(p0, p1)
+SKY_cipher_DecodeBase58BitcoinAddress = _skycoin.SKY_cipher_DecodeBase58BitcoinAddress
 
-def SKY_cli_FormatAddressesAsJSON(p0):
-    return _skycoin.SKY_cli_FormatAddressesAsJSON(p0)
-SKY_cli_FormatAddressesAsJSON = _skycoin.SKY_cli_FormatAddressesAsJSON
+def SKY_cipher_BitcoinAddressFromPubKey(p0, p1):
+    return _skycoin.SKY_cipher_BitcoinAddressFromPubKey(p0, p1)
+SKY_cipher_BitcoinAddressFromPubKey = _skycoin.SKY_cipher_BitcoinAddressFromPubKey
 
-def SKY_cli_FormatAddressesAsJoinedArray(p0):
-    return _skycoin.SKY_cli_FormatAddressesAsJoinedArray(p0)
-SKY_cli_FormatAddressesAsJoinedArray = _skycoin.SKY_cli_FormatAddressesAsJoinedArray
+def SKY_cipher_BitcoinAddressFromSecKey(p0, p1):
+    return _skycoin.SKY_cipher_BitcoinAddressFromSecKey(p0, p1)
+SKY_cipher_BitcoinAddressFromSecKey = _skycoin.SKY_cipher_BitcoinAddressFromSecKey
 
-def SKY_cli_AddressesToStrings(p0):
-    return _skycoin.SKY_cli_AddressesToStrings(p0)
-SKY_cli_AddressesToStrings = _skycoin.SKY_cli_AddressesToStrings
+def SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0):
+    return _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0)
+SKY_cipher_BitcoinWalletImportFormatFromSeckey = _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey
 
-def SKY_coin_AddUint64(p0, p1):
-    return _skycoin.SKY_coin_AddUint64(p0, p1)
-SKY_coin_AddUint64 = _skycoin.SKY_coin_AddUint64
+def SKY_cipher_BitcoinAddressFromBytes(p0, p1):
+    return _skycoin.SKY_cipher_BitcoinAddressFromBytes(p0, p1)
+SKY_cipher_BitcoinAddressFromBytes = _skycoin.SKY_cipher_BitcoinAddressFromBytes
 
-def SKY_coin_Uint64ToInt64(p0):
-    return _skycoin.SKY_coin_Uint64ToInt64(p0)
-SKY_coin_Uint64ToInt64 = _skycoin.SKY_coin_Uint64ToInt64
+def SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1):
+    return _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1)
+SKY_cipher_SecKeyFromBitcoinWalletImportFormat = _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat
 
-def SKY_coin_Int64ToUint64(p0):
-    return _skycoin.SKY_coin_Int64ToUint64(p0)
-SKY_coin_Int64ToUint64 = _skycoin.SKY_coin_Int64ToUint64
+def SKY_cipher_BitcoinAddress_Null(p0):
+    return _skycoin.SKY_cipher_BitcoinAddress_Null(p0)
+SKY_cipher_BitcoinAddress_Null = _skycoin.SKY_cipher_BitcoinAddress_Null
 
-def SKY_coin_IntToUint32(p0):
-    return _skycoin.SKY_coin_IntToUint32(p0)
-SKY_coin_IntToUint32 = _skycoin.SKY_coin_IntToUint32
+def SKY_cipher_BitcoinAddress_Bytes(p0):
+    return _skycoin.SKY_cipher_BitcoinAddress_Bytes(p0)
+SKY_cipher_BitcoinAddress_Bytes = _skycoin.SKY_cipher_BitcoinAddress_Bytes
+
+def SKY_cipher_BitcoinAddress_Verify(p0, p1):
+    return _skycoin.SKY_cipher_BitcoinAddress_Verify(p0, p1)
+SKY_cipher_BitcoinAddress_Verify = _skycoin.SKY_cipher_BitcoinAddress_Verify
+
+def SKY_cipher_BitcoinAddress_String(p0):
+    return _skycoin.SKY_cipher_BitcoinAddress_String(p0)
+SKY_cipher_BitcoinAddress_String = _skycoin.SKY_cipher_BitcoinAddress_String
+
+def SKY_cipher_BitcoinAddress_Checksum(p0, p1):
+    return _skycoin.SKY_cipher_BitcoinAddress_Checksum(p0, p1)
+SKY_cipher_BitcoinAddress_Checksum = _skycoin.SKY_cipher_BitcoinAddress_Checksum
+
+def SKY_map_Get(p1):
+    return _skycoin.SKY_map_Get(p1)
+SKY_map_Get = _skycoin.SKY_map_Get
+
+def SKY_map_HasKey(p1):
+    return _skycoin.SKY_map_HasKey(p1)
+SKY_map_HasKey = _skycoin.SKY_map_HasKey
+
+def SKY_map_Close():
+    return _skycoin.SKY_map_Close()
+SKY_map_Close = _skycoin.SKY_map_Close
+
+def SKY_droplet_FromString(p0):
+    return _skycoin.SKY_droplet_FromString(p0)
+SKY_droplet_FromString = _skycoin.SKY_droplet_FromString
+
+def SKY_droplet_ToString(p0):
+    return _skycoin.SKY_droplet_ToString(p0)
+SKY_droplet_ToString = _skycoin.SKY_droplet_ToString
+
+def SKY_wallet_CryptoTypeFromString(p0):
+    return _skycoin.SKY_wallet_CryptoTypeFromString(p0)
+SKY_wallet_CryptoTypeFromString = _skycoin.SKY_wallet_CryptoTypeFromString
 
 def SKY_cipher_RandByte(p0):
     return _skycoin.SKY_cipher_RandByte(p0)
@@ -1321,401 +1393,361 @@ def SKY_cipher_CheckSecKeyHash(p0, p1):
     return _skycoin.SKY_cipher_CheckSecKeyHash(p0, p1)
 SKY_cipher_CheckSecKeyHash = _skycoin.SKY_cipher_CheckSecKeyHash
 
-def SKY_cli_App_Run(p0, p1):
-    return _skycoin.SKY_cli_App_Run(p0, p1)
-SKY_cli_App_Run = _skycoin.SKY_cli_App_Run
-
-def SKY_cli_Config_GetCoin(p0):
-    return _skycoin.SKY_cli_Config_GetCoin(p0)
-SKY_cli_Config_GetCoin = _skycoin.SKY_cli_Config_GetCoin
-
-def SKY_cli_Config_GetRPCAddress(p0):
-    return _skycoin.SKY_cli_Config_GetRPCAddress(p0)
-SKY_cli_Config_GetRPCAddress = _skycoin.SKY_cli_Config_GetRPCAddress
-
-def SKY_cli_RPCClientFromApp(p0):
-    return _skycoin.SKY_cli_RPCClientFromApp(p0)
-SKY_cli_RPCClientFromApp = _skycoin.SKY_cli_RPCClientFromApp
-
-def SKY_cli_Getenv(p0):
-    return _skycoin.SKY_cli_Getenv(p0)
-SKY_cli_Getenv = _skycoin.SKY_cli_Getenv
-
-def SKY_cli_Setenv(p0, p1):
-    return _skycoin.SKY_cli_Setenv(p0, p1)
-SKY_cli_Setenv = _skycoin.SKY_cli_Setenv
-
-def SKY_wallet_NewBalance(p0, p1, p2):
-    return _skycoin.SKY_wallet_NewBalance(p0, p1, p2)
-SKY_wallet_NewBalance = _skycoin.SKY_wallet_NewBalance
-
-def SKY_wallet_NewBalanceFromUxOut(p0, p1, p2):
-    return _skycoin.SKY_wallet_NewBalanceFromUxOut(p0, p1, p2)
-SKY_wallet_NewBalanceFromUxOut = _skycoin.SKY_wallet_NewBalanceFromUxOut
-
-def SKY_wallet_Balance_Add(p0, p1, p2):
-    return _skycoin.SKY_wallet_Balance_Add(p0, p1, p2)
-SKY_wallet_Balance_Add = _skycoin.SKY_wallet_Balance_Add
-
-def SKY_wallet_Balance_Sub(p0, p1, p2):
-    return _skycoin.SKY_wallet_Balance_Sub(p0, p1, p2)
-SKY_wallet_Balance_Sub = _skycoin.SKY_wallet_Balance_Sub
-
-def SKY_wallet_Balance_Equals(p0, p1):
-    return _skycoin.SKY_wallet_Balance_Equals(p0, p1)
-SKY_wallet_Balance_Equals = _skycoin.SKY_wallet_Balance_Equals
-
-def SKY_wallet_Balance_IsZero(p0):
-    return _skycoin.SKY_wallet_Balance_IsZero(p0)
-SKY_wallet_Balance_IsZero = _skycoin.SKY_wallet_Balance_IsZero
+def SKY_api_NewCreateTransactionResponse(p0, p1):
+    return _skycoin.SKY_api_NewCreateTransactionResponse(p0, p1)
+SKY_api_NewCreateTransactionResponse = _skycoin.SKY_api_NewCreateTransactionResponse
 
-def SKY_httphelper_Address_UnmarshalJSON(p0, p1):
-    return _skycoin.SKY_httphelper_Address_UnmarshalJSON(p0, p1)
-SKY_httphelper_Address_UnmarshalJSON = _skycoin.SKY_httphelper_Address_UnmarshalJSON
+def SKY_api_NewCreatedTransaction(p0, p1):
+    return _skycoin.SKY_api_NewCreatedTransaction(p0, p1)
+SKY_api_NewCreatedTransaction = _skycoin.SKY_api_NewCreatedTransaction
 
-def SKY_httphelper_Address_MarshalJSON(p0):
-    return _skycoin.SKY_httphelper_Address_MarshalJSON(p0)
-SKY_httphelper_Address_MarshalJSON = _skycoin.SKY_httphelper_Address_MarshalJSON
+def SKY_api_CreatedTransaction_ToTransaction(p0):
+    return _skycoin.SKY_api_CreatedTransaction_ToTransaction(p0)
+SKY_api_CreatedTransaction_ToTransaction = _skycoin.SKY_api_CreatedTransaction_ToTransaction
 
-def SKY_httphelper_Coins_UnmarshalJSON(p1):
-    return _skycoin.SKY_httphelper_Coins_UnmarshalJSON(p1)
-SKY_httphelper_Coins_UnmarshalJSON = _skycoin.SKY_httphelper_Coins_UnmarshalJSON
+def SKY_api_NewCreatedTransactionOutput(p0, p1):
+    return _skycoin.SKY_api_NewCreatedTransactionOutput(p0, p1)
+SKY_api_NewCreatedTransactionOutput = _skycoin.SKY_api_NewCreatedTransactionOutput
 
-def SKY_httphelper_Coins_MarshalJSON():
-    return _skycoin.SKY_httphelper_Coins_MarshalJSON()
-SKY_httphelper_Coins_MarshalJSON = _skycoin.SKY_httphelper_Coins_MarshalJSON
+def SKY_api_NewCreatedTransactionInput(p0):
+    return _skycoin.SKY_api_NewCreatedTransactionInput(p0)
+SKY_api_NewCreatedTransactionInput = _skycoin.SKY_api_NewCreatedTransactionInput
 
-def SKY_httphelper_Coins_Value():
-    return _skycoin.SKY_httphelper_Coins_Value()
-SKY_httphelper_Coins_Value = _skycoin.SKY_httphelper_Coins_Value
+def SKY_base58_String2Hex(p0):
+    return _skycoin.SKY_base58_String2Hex(p0)
+SKY_base58_String2Hex = _skycoin.SKY_base58_String2Hex
 
-def SKY_httphelper_Hours_UnmarshalJSON(p1):
-    return _skycoin.SKY_httphelper_Hours_UnmarshalJSON(p1)
-SKY_httphelper_Hours_UnmarshalJSON = _skycoin.SKY_httphelper_Hours_UnmarshalJSON
+def SKY_base58_Base58_ToInt(p0):
+    return _skycoin.SKY_base58_Base58_ToInt(p0)
+SKY_base58_Base58_ToInt = _skycoin.SKY_base58_Base58_ToInt
 
-def SKY_httphelper_Hours_MarshalJSON():
-    return _skycoin.SKY_httphelper_Hours_MarshalJSON()
-SKY_httphelper_Hours_MarshalJSON = _skycoin.SKY_httphelper_Hours_MarshalJSON
+def SKY_base58_Base58_ToHex(p0):
+    return _skycoin.SKY_base58_Base58_ToHex(p0)
+SKY_base58_Base58_ToHex = _skycoin.SKY_base58_Base58_ToHex
 
-def SKY_httphelper_Hours_Value():
-    return _skycoin.SKY_httphelper_Hours_Value()
-SKY_httphelper_Hours_Value = _skycoin.SKY_httphelper_Hours_Value
+def SKY_base58_Base58_Base582Int(p0):
+    return _skycoin.SKY_base58_Base58_Base582Int(p0)
+SKY_base58_Base58_Base582Int = _skycoin.SKY_base58_Base58_Base582Int
 
-def SKY_wallet_Entry_Verify(p0):
-    return _skycoin.SKY_wallet_Entry_Verify(p0)
-SKY_wallet_Entry_Verify = _skycoin.SKY_wallet_Entry_Verify
+def SKY_base58_Base582Hex(p0):
+    return _skycoin.SKY_base58_Base582Hex(p0)
+SKY_base58_Base582Hex = _skycoin.SKY_base58_Base582Hex
 
-def SKY_wallet_Entry_VerifyPublic(p0):
-    return _skycoin.SKY_wallet_Entry_VerifyPublic(p0)
-SKY_wallet_Entry_VerifyPublic = _skycoin.SKY_wallet_Entry_VerifyPublic
+def SKY_base58_Base58_BitHex(p0):
+    return _skycoin.SKY_base58_Base58_BitHex(p0)
+SKY_base58_Base58_BitHex = _skycoin.SKY_base58_Base58_BitHex
 
-def SKY_droplet_FromString(p0):
-    return _skycoin.SKY_droplet_FromString(p0)
-SKY_droplet_FromString = _skycoin.SKY_droplet_FromString
+def SKY_base58_Int2Base58(p0):
+    return _skycoin.SKY_base58_Int2Base58(p0)
+SKY_base58_Int2Base58 = _skycoin.SKY_base58_Int2Base58
 
-def SKY_droplet_ToString(p0):
-    return _skycoin.SKY_droplet_ToString(p0)
-SKY_droplet_ToString = _skycoin.SKY_droplet_ToString
+def SKY_base58_Hex2Base58(p0):
+    return _skycoin.SKY_base58_Hex2Base58(p0)
+SKY_base58_Hex2Base58 = _skycoin.SKY_base58_Hex2Base58
 
-def SKY_wallet_CryptoTypeFromString(p0):
-    return _skycoin.SKY_wallet_CryptoTypeFromString(p0)
-SKY_wallet_CryptoTypeFromString = _skycoin.SKY_wallet_CryptoTypeFromString
+def SKY_base58_Hex2Base58String(p0):
+    return _skycoin.SKY_base58_Hex2Base58String(p0)
+SKY_base58_Hex2Base58String = _skycoin.SKY_base58_Hex2Base58String
 
-def SKY_handle_close(p0):
-    return _skycoin.SKY_handle_close(p0)
-SKY_handle_close = _skycoin.SKY_handle_close
+def SKY_base58_Hex2Base58Str(p0):
+    return _skycoin.SKY_base58_Hex2Base58Str(p0)
+SKY_base58_Hex2Base58Str = _skycoin.SKY_base58_Hex2Base58Str
 
-def SKY_handle_copy(p0):
-    return _skycoin.SKY_handle_copy(p0)
-SKY_handle_copy = _skycoin.SKY_handle_copy
+def SKY_webrpc_NewClient(p0):
+    return _skycoin.SKY_webrpc_NewClient(p0)
+SKY_webrpc_NewClient = _skycoin.SKY_webrpc_NewClient
 
-def SKY_logging_EnableColors():
-    return _skycoin.SKY_logging_EnableColors()
-SKY_logging_EnableColors = _skycoin.SKY_logging_EnableColors
+def SKY_webrpc_Client_CSRF(p0):
+    return _skycoin.SKY_webrpc_Client_CSRF(p0)
+SKY_webrpc_Client_CSRF = _skycoin.SKY_webrpc_Client_CSRF
 
-def SKY_logging_DisableColors():
-    return _skycoin.SKY_logging_DisableColors()
-SKY_logging_DisableColors = _skycoin.SKY_logging_DisableColors
+def SKY_webrpc_Client_InjectTransaction(p0, p1):
+    return _skycoin.SKY_webrpc_Client_InjectTransaction(p0, p1)
+SKY_webrpc_Client_InjectTransaction = _skycoin.SKY_webrpc_Client_InjectTransaction
 
-def SKY_logging_Disable():
-    return _skycoin.SKY_logging_Disable()
-SKY_logging_Disable = _skycoin.SKY_logging_Disable
+def SKY_webrpc_Client_GetStatus(p0, p1):
+    return _skycoin.SKY_webrpc_Client_GetStatus(p0, p1)
+SKY_webrpc_Client_GetStatus = _skycoin.SKY_webrpc_Client_GetStatus
 
-def SKY_map_Get(p1):
-    return _skycoin.SKY_map_Get(p1)
-SKY_map_Get = _skycoin.SKY_map_Get
+def SKY_webrpc_Client_GetTransactionByID(p0, p1, p2):
+    return _skycoin.SKY_webrpc_Client_GetTransactionByID(p0, p1, p2)
+SKY_webrpc_Client_GetTransactionByID = _skycoin.SKY_webrpc_Client_GetTransactionByID
 
-def SKY_map_HasKey(p1):
-    return _skycoin.SKY_map_HasKey(p1)
-SKY_map_HasKey = _skycoin.SKY_map_HasKey
+def SKY_webrpc_Client_GetAddressUxOuts(p0, p1):
+    return _skycoin.SKY_webrpc_Client_GetAddressUxOuts(p0, p1)
+SKY_webrpc_Client_GetAddressUxOuts = _skycoin.SKY_webrpc_Client_GetAddressUxOuts
 
-def SKY_map_Close():
-    return _skycoin.SKY_map_Close()
-SKY_map_Close = _skycoin.SKY_map_Close
+def SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2):
+    return _skycoin.SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2)
+SKY_webrpc_Client_GetBlocksInRange = _skycoin.SKY_webrpc_Client_GetBlocksInRange
 
-def SKY_cipher_DecodeBase58Address(p0, p1):
-    return _skycoin.SKY_cipher_DecodeBase58Address(p0, p1)
-SKY_cipher_DecodeBase58Address = _skycoin.SKY_cipher_DecodeBase58Address
+def SKY_webrpc_Client_GetBlocksBySeq(p0, p1):
+    return _skycoin.SKY_webrpc_Client_GetBlocksBySeq(p0, p1)
+SKY_webrpc_Client_GetBlocksBySeq = _skycoin.SKY_webrpc_Client_GetBlocksBySeq
 
-def SKY_cipher_AddressFromBytes(p0, p1):
-    return _skycoin.SKY_cipher_AddressFromBytes(p0, p1)
-SKY_cipher_AddressFromBytes = _skycoin.SKY_cipher_AddressFromBytes
+def SKY_webrpc_Client_GetLastBlocks(p0, p1):
+    return _skycoin.SKY_webrpc_Client_GetLastBlocks(p0, p1)
+SKY_webrpc_Client_GetLastBlocks = _skycoin.SKY_webrpc_Client_GetLastBlocks
 
-def SKY_cipher_AddressFromPubKey(p0, p1):
-    return _skycoin.SKY_cipher_AddressFromPubKey(p0, p1)
-SKY_cipher_AddressFromPubKey = _skycoin.SKY_cipher_AddressFromPubKey
+def SKY_cli_LoadConfig():
+    return _skycoin.SKY_cli_LoadConfig()
+SKY_cli_LoadConfig = _skycoin.SKY_cli_LoadConfig
 
-def SKY_cipher_AddressFromSecKey(p0, p1):
-    return _skycoin.SKY_cipher_AddressFromSecKey(p0, p1)
-SKY_cipher_AddressFromSecKey = _skycoin.SKY_cipher_AddressFromSecKey
+def SKY_cli_Config_FullWalletPath(p0):
+    return _skycoin.SKY_cli_Config_FullWalletPath(p0)
+SKY_cli_Config_FullWalletPath = _skycoin.SKY_cli_Config_FullWalletPath
 
-def SKY_cipher_Address_Null(p0):
-    return _skycoin.SKY_cipher_Address_Null(p0)
-SKY_cipher_Address_Null = _skycoin.SKY_cipher_Address_Null
+def SKY_cli_Config_FullDBPath(p0):
+    return _skycoin.SKY_cli_Config_FullDBPath(p0)
+SKY_cli_Config_FullDBPath = _skycoin.SKY_cli_Config_FullDBPath
 
-def SKY_cipher_Address_Bytes(p0):
-    return _skycoin.SKY_cipher_Address_Bytes(p0)
-SKY_cipher_Address_Bytes = _skycoin.SKY_cipher_Address_Bytes
+def SKY_cli_NewApp(p0):
+    return _skycoin.SKY_cli_NewApp(p0)
+SKY_cli_NewApp = _skycoin.SKY_cli_NewApp
 
-def SKY_cipher_Address_Verify(p0, p1):
-    return _skycoin.SKY_cipher_Address_Verify(p0, p1)
-SKY_cipher_Address_Verify = _skycoin.SKY_cipher_Address_Verify
+def SKY_cli_RPCClientFromContext(p0):
+    return _skycoin.SKY_cli_RPCClientFromContext(p0)
+SKY_cli_RPCClientFromContext = _skycoin.SKY_cli_RPCClientFromContext
 
-def SKY_cipher_Address_String(p0):
-    return _skycoin.SKY_cipher_Address_String(p0)
-SKY_cipher_Address_String = _skycoin.SKY_cipher_Address_String
+def SKY_cli_ConfigFromContext(p0):
+    return _skycoin.SKY_cli_ConfigFromContext(p0)
+SKY_cli_ConfigFromContext = _skycoin.SKY_cli_ConfigFromContext
 
-def SKY_cipher_Address_Checksum(p0, p1):
-    return _skycoin.SKY_cipher_Address_Checksum(p0, p1)
-SKY_cipher_Address_Checksum = _skycoin.SKY_cipher_Address_Checksum
+def SKY_cli_PasswordFromBytes_Password():
+    return _skycoin.SKY_cli_PasswordFromBytes_Password()
+SKY_cli_PasswordFromBytes_Password = _skycoin.SKY_cli_PasswordFromBytes_Password
 
-def SKY_JsonEncode_Handle(p0):
-    return _skycoin.SKY_JsonEncode_Handle(p0)
-SKY_JsonEncode_Handle = _skycoin.SKY_JsonEncode_Handle
+def SKY_cli_PasswordFromTerm_Password():
+    return _skycoin.SKY_cli_PasswordFromTerm_Password()
+SKY_cli_PasswordFromTerm_Password = _skycoin.SKY_cli_PasswordFromTerm_Password
 
-def SKY_Handle_Progress_GetCurrent(p0):
-    return _skycoin.SKY_Handle_Progress_GetCurrent(p0)
-SKY_Handle_Progress_GetCurrent = _skycoin.SKY_Handle_Progress_GetCurrent
+def SKY_cli_GenerateWallet(p0, p2):
+    return _skycoin.SKY_cli_GenerateWallet(p0, p2)
+SKY_cli_GenerateWallet = _skycoin.SKY_cli_GenerateWallet
 
-def SKY_Handle_Block_GetHeadSeq(p0):
-    return _skycoin.SKY_Handle_Block_GetHeadSeq(p0)
-SKY_Handle_Block_GetHeadSeq = _skycoin.SKY_Handle_Block_GetHeadSeq
+def SKY_cli_MakeAlphanumericSeed():
+    return _skycoin.SKY_cli_MakeAlphanumericSeed()
+SKY_cli_MakeAlphanumericSeed = _skycoin.SKY_cli_MakeAlphanumericSeed
 
-def SKY_Handle_Block_GetHeadHash(p0):
-    return _skycoin.SKY_Handle_Block_GetHeadHash(p0)
-SKY_Handle_Block_GetHeadHash = _skycoin.SKY_Handle_Block_GetHeadHash
+def SKY_coin_NewBlock(p0, p1, p2, p3, p4):
+    return _skycoin.SKY_coin_NewBlock(p0, p1, p2, p3, p4)
+SKY_coin_NewBlock = _skycoin.SKY_coin_NewBlock
 
-def SKY_Handle_Block_GetPreviousBlockHash(p0):
-    return _skycoin.SKY_Handle_Block_GetPreviousBlockHash(p0)
-SKY_Handle_Block_GetPreviousBlockHash = _skycoin.SKY_Handle_Block_GetPreviousBlockHash
+def SKY_coin_SignedBlock_VerifySignature(p0, p1):
+    return _skycoin.SKY_coin_SignedBlock_VerifySignature(p0, p1)
+SKY_coin_SignedBlock_VerifySignature = _skycoin.SKY_coin_SignedBlock_VerifySignature
 
-def SKY_Handle_Blocks_GetAt(p0, p1):
-    return _skycoin.SKY_Handle_Blocks_GetAt(p0, p1)
-SKY_Handle_Blocks_GetAt = _skycoin.SKY_Handle_Blocks_GetAt
+def SKY_coin_NewGenesisBlock(p0, p1, p2):
+    return _skycoin.SKY_coin_NewGenesisBlock(p0, p1, p2)
+SKY_coin_NewGenesisBlock = _skycoin.SKY_coin_NewGenesisBlock
 
-def SKY_Handle_Blocks_GetCount(p0):
-    return _skycoin.SKY_Handle_Blocks_GetCount(p0)
-SKY_Handle_Blocks_GetCount = _skycoin.SKY_Handle_Blocks_GetCount
+def SKY_coin_Block_HashHeader(p0, p1):
+    return _skycoin.SKY_coin_Block_HashHeader(p0, p1)
+SKY_coin_Block_HashHeader = _skycoin.SKY_coin_Block_HashHeader
 
-def SKY_Handle_Connections_GetCount(p0):
-    return _skycoin.SKY_Handle_Connections_GetCount(p0)
-SKY_Handle_Connections_GetCount = _skycoin.SKY_Handle_Connections_GetCount
+def SKY_coin_Block_PreHashHeader(p0, p1):
+    return _skycoin.SKY_coin_Block_PreHashHeader(p0, p1)
+SKY_coin_Block_PreHashHeader = _skycoin.SKY_coin_Block_PreHashHeader
 
-def SKY_Handle_Strings_GetCount(p0):
-    return _skycoin.SKY_Handle_Strings_GetCount(p0)
-SKY_Handle_Strings_GetCount = _skycoin.SKY_Handle_Strings_GetCount
+def SKY_coin_Block_Time(p0):
+    return _skycoin.SKY_coin_Block_Time(p0)
+SKY_coin_Block_Time = _skycoin.SKY_coin_Block_Time
 
-def SKY_Handle_Strings_Sort(p0):
-    return _skycoin.SKY_Handle_Strings_Sort(p0)
-SKY_Handle_Strings_Sort = _skycoin.SKY_Handle_Strings_Sort
+def SKY_coin_Block_Seq(p0):
+    return _skycoin.SKY_coin_Block_Seq(p0)
+SKY_coin_Block_Seq = _skycoin.SKY_coin_Block_Seq
 
-def SKY_Handle_Strings_GetAt(p0, p1):
-    return _skycoin.SKY_Handle_Strings_GetAt(p0, p1)
-SKY_Handle_Strings_GetAt = _skycoin.SKY_Handle_Strings_GetAt
+def SKY_coin_Block_HashBody(p0, p1):
+    return _skycoin.SKY_coin_Block_HashBody(p0, p1)
+SKY_coin_Block_HashBody = _skycoin.SKY_coin_Block_HashBody
 
-def SKY_api_Handle_Client_GetWalletDir(p0):
-    return _skycoin.SKY_api_Handle_Client_GetWalletDir(p0)
-SKY_api_Handle_Client_GetWalletDir = _skycoin.SKY_api_Handle_Client_GetWalletDir
+def SKY_coin_Block_Size(p0):
+    return _skycoin.SKY_coin_Block_Size(p0)
+SKY_coin_Block_Size = _skycoin.SKY_coin_Block_Size
 
-def SKY_api_Handle_Client_GetWalletFileName(p0):
-    return _skycoin.SKY_api_Handle_Client_GetWalletFileName(p0)
-SKY_api_Handle_Client_GetWalletFileName = _skycoin.SKY_api_Handle_Client_GetWalletFileName
+def SKY_coin_Block_String(p0):
+    return _skycoin.SKY_coin_Block_String(p0)
+SKY_coin_Block_String = _skycoin.SKY_coin_Block_String
 
-def SKY_api_Handle_Client_GetWalletLabel(p0):
-    return _skycoin.SKY_api_Handle_Client_GetWalletLabel(p0)
-SKY_api_Handle_Client_GetWalletLabel = _skycoin.SKY_api_Handle_Client_GetWalletLabel
+def SKY_coin_Block_GetTransaction(p0, p1):
+    return _skycoin.SKY_coin_Block_GetTransaction(p0, p1)
+SKY_coin_Block_GetTransaction = _skycoin.SKY_coin_Block_GetTransaction
 
-def SKY_api_Handle_Client_GetWalletFullPath(p0, p1):
-    return _skycoin.SKY_api_Handle_Client_GetWalletFullPath(p0, p1)
-SKY_api_Handle_Client_GetWalletFullPath = _skycoin.SKY_api_Handle_Client_GetWalletFullPath
+def SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5):
+    return _skycoin.SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5)
+SKY_coin_NewBlockHeader = _skycoin.SKY_coin_NewBlockHeader
 
-def SKY_api_Handle_GetWalletMeta(p0):
-    return _skycoin.SKY_api_Handle_GetWalletMeta(p0)
-SKY_api_Handle_GetWalletMeta = _skycoin.SKY_api_Handle_GetWalletMeta
+def SKY_coin_BlockHeader_Hash(p0, p1):
+    return _skycoin.SKY_coin_BlockHeader_Hash(p0, p1)
+SKY_coin_BlockHeader_Hash = _skycoin.SKY_coin_BlockHeader_Hash
 
-def SKY_api_Handle_GetWalletEntriesCount(p0):
-    return _skycoin.SKY_api_Handle_GetWalletEntriesCount(p0)
-SKY_api_Handle_GetWalletEntriesCount = _skycoin.SKY_api_Handle_GetWalletEntriesCount
+def SKY_coin_BlockHeader_Bytes(p0):
+    return _skycoin.SKY_coin_BlockHeader_Bytes(p0)
+SKY_coin_BlockHeader_Bytes = _skycoin.SKY_coin_BlockHeader_Bytes
 
-def SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0):
-    return _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount(p0)
-SKY_api_Handle_Client_GetWalletResponseEntriesCount = _skycoin.SKY_api_Handle_Client_GetWalletResponseEntriesCount
+def SKY_coin_BlockHeader_String(p0):
+    return _skycoin.SKY_coin_BlockHeader_String(p0)
+SKY_coin_BlockHeader_String = _skycoin.SKY_coin_BlockHeader_String
 
-def SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3):
-    return _skycoin.SKY_api_Handle_WalletGetEntry(p0, p1, p2, p3)
-SKY_api_Handle_WalletGetEntry = _skycoin.SKY_api_Handle_WalletGetEntry
+def SKY_coin_BlockBody_Hash(p0, p1):
+    return _skycoin.SKY_coin_BlockBody_Hash(p0, p1)
+SKY_coin_BlockBody_Hash = _skycoin.SKY_coin_BlockBody_Hash
 
-def SKY_api_Handle_WalletResponseGetEntry(p0, p1):
-    return _skycoin.SKY_api_Handle_WalletResponseGetEntry(p0, p1)
-SKY_api_Handle_WalletResponseGetEntry = _skycoin.SKY_api_Handle_WalletResponseGetEntry
+def SKY_coin_BlockBody_Size():
+    return _skycoin.SKY_coin_BlockBody_Size()
+SKY_coin_BlockBody_Size = _skycoin.SKY_coin_BlockBody_Size
 
-def SKY_api_Handle_WalletResponseIsEncrypted(p0):
-    return _skycoin.SKY_api_Handle_WalletResponseIsEncrypted(p0)
-SKY_api_Handle_WalletResponseIsEncrypted = _skycoin.SKY_api_Handle_WalletResponseIsEncrypted
+def SKY_coin_BlockBody_Bytes(p0):
+    return _skycoin.SKY_coin_BlockBody_Bytes(p0)
+SKY_coin_BlockBody_Bytes = _skycoin.SKY_coin_BlockBody_Bytes
 
-def SKY_api_Handle_WalletResponseGetCryptoType(p0):
-    return _skycoin.SKY_api_Handle_WalletResponseGetCryptoType(p0)
-SKY_api_Handle_WalletResponseGetCryptoType = _skycoin.SKY_api_Handle_WalletResponseGetCryptoType
+def SKY_coin_CreateUnspents(*args):
+    return _skycoin.SKY_coin_CreateUnspents(*args)
+SKY_coin_CreateUnspents = _skycoin.SKY_coin_CreateUnspents
 
-def SKY_api_Handle_WalletsResponseGetCount(p0):
-    return _skycoin.SKY_api_Handle_WalletsResponseGetCount(p0)
-SKY_api_Handle_WalletsResponseGetCount = _skycoin.SKY_api_Handle_WalletsResponseGetCount
+def SKY_coin_CreateUnspent(p0, p1, p2, p3):
+    return _skycoin.SKY_coin_CreateUnspent(p0, p1, p2, p3)
+SKY_coin_CreateUnspent = _skycoin.SKY_coin_CreateUnspent
+
+def SKY_coin_GetBlockObject(p0):
+    return _skycoin.SKY_coin_GetBlockObject(p0)
+SKY_coin_GetBlockObject = _skycoin.SKY_coin_GetBlockObject
 
-def SKY_api_Handle_WalletsResponseGetAt(p0, p1):
-    return _skycoin.SKY_api_Handle_WalletsResponseGetAt(p0, p1)
-SKY_api_Handle_WalletsResponseGetAt = _skycoin.SKY_api_Handle_WalletsResponseGetAt
+def SKY_coin_GetBlockBody(p0):
+    return _skycoin.SKY_coin_GetBlockBody(p0)
+SKY_coin_GetBlockBody = _skycoin.SKY_coin_GetBlockBody
 
-def SKY_api_Handle_GetWalletFolderAddress(p0):
-    return _skycoin.SKY_api_Handle_GetWalletFolderAddress(p0)
-SKY_api_Handle_GetWalletFolderAddress = _skycoin.SKY_api_Handle_GetWalletFolderAddress
+def SKY_coin_NewEmptyBlock(p0):
+    return _skycoin.SKY_coin_NewEmptyBlock(p0)
+SKY_coin_NewEmptyBlock = _skycoin.SKY_coin_NewEmptyBlock
 
-def SKY_api_Handle_GetWalletSeed(p0):
-    return _skycoin.SKY_api_Handle_GetWalletSeed(p0)
-SKY_api_Handle_GetWalletSeed = _skycoin.SKY_api_Handle_GetWalletSeed
+def SKY_cli_App_Run(p0, p1):
+    return _skycoin.SKY_cli_App_Run(p0, p1)
+SKY_cli_App_Run = _skycoin.SKY_cli_App_Run
 
-def SKY_api_Handle_GetWalletLastSeed(p0):
-    return _skycoin.SKY_api_Handle_GetWalletLastSeed(p0)
-SKY_api_Handle_GetWalletLastSeed = _skycoin.SKY_api_Handle_GetWalletLastSeed
+def SKY_cli_Config_GetCoin(p0):
+    return _skycoin.SKY_cli_Config_GetCoin(p0)
+SKY_cli_Config_GetCoin = _skycoin.SKY_cli_Config_GetCoin
 
-def SKY_api_Handle_GetBuildInfoData(p0):
-    return _skycoin.SKY_api_Handle_GetBuildInfoData(p0)
-SKY_api_Handle_GetBuildInfoData = _skycoin.SKY_api_Handle_GetBuildInfoData
+def SKY_cli_Config_GetRPCAddress(p0):
+    return _skycoin.SKY_cli_Config_GetRPCAddress(p0)
+SKY_cli_Config_GetRPCAddress = _skycoin.SKY_cli_Config_GetRPCAddress
 
-def SKY_coin_UxOut_Hash(p0, p1):
-    return _skycoin.SKY_coin_UxOut_Hash(p0, p1)
-SKY_coin_UxOut_Hash = _skycoin.SKY_coin_UxOut_Hash
+def SKY_cli_RPCClientFromApp(p0):
+    return _skycoin.SKY_cli_RPCClientFromApp(p0)
+SKY_cli_RPCClientFromApp = _skycoin.SKY_cli_RPCClientFromApp
 
-def SKY_coin_UxOut_SnapshotHash(p0, p1):
-    return _skycoin.SKY_coin_UxOut_SnapshotHash(p0, p1)
-SKY_coin_UxOut_SnapshotHash = _skycoin.SKY_coin_UxOut_SnapshotHash
+def SKY_cli_Getenv(p0):
+    return _skycoin.SKY_cli_Getenv(p0)
+SKY_cli_Getenv = _skycoin.SKY_cli_Getenv
 
-def SKY_coin_UxBody_Hash(p0, p1):
-    return _skycoin.SKY_coin_UxBody_Hash(p0, p1)
-SKY_coin_UxBody_Hash = _skycoin.SKY_coin_UxBody_Hash
+def SKY_cli_Setenv(p0, p1):
+    return _skycoin.SKY_cli_Setenv(p0, p1)
+SKY_cli_Setenv = _skycoin.SKY_cli_Setenv
 
-def SKY_coin_UxOut_CoinHours(p0, p1):
-    return _skycoin.SKY_coin_UxOut_CoinHours(p0, p1)
-SKY_coin_UxOut_CoinHours = _skycoin.SKY_coin_UxOut_CoinHours
+def SKY_cipher_Ripemd160_Set(p0, p1):
+    return _skycoin.SKY_cipher_Ripemd160_Set(p0, p1)
+SKY_cipher_Ripemd160_Set = _skycoin.SKY_cipher_Ripemd160_Set
 
-def SKY_coin_UxArray_Hashes(*args):
-    return _skycoin.SKY_coin_UxArray_Hashes(*args)
-SKY_coin_UxArray_Hashes = _skycoin.SKY_coin_UxArray_Hashes
+def SKY_cipher_HashRipemd160(p0, p1):
+    return _skycoin.SKY_cipher_HashRipemd160(p0, p1)
+SKY_cipher_HashRipemd160 = _skycoin.SKY_cipher_HashRipemd160
 
-def SKY_coin_UxArray_HasDupes(*args):
-    return _skycoin.SKY_coin_UxArray_HasDupes(*args)
-SKY_coin_UxArray_HasDupes = _skycoin.SKY_coin_UxArray_HasDupes
+def SKY_cipher_SHA256_Set(p0, p1):
+    return _skycoin.SKY_cipher_SHA256_Set(p0, p1)
+SKY_cipher_SHA256_Set = _skycoin.SKY_cipher_SHA256_Set
 
-def SKY_coin_UxArray_Sort():
-    return _skycoin.SKY_coin_UxArray_Sort()
-SKY_coin_UxArray_Sort = _skycoin.SKY_coin_UxArray_Sort
+def SKY_cipher_SHA256_Hex(p0):
+    return _skycoin.SKY_cipher_SHA256_Hex(p0)
+SKY_cipher_SHA256_Hex = _skycoin.SKY_cipher_SHA256_Hex
 
-def SKY_coin_UxArray_Len():
-    return _skycoin.SKY_coin_UxArray_Len()
-SKY_coin_UxArray_Len = _skycoin.SKY_coin_UxArray_Len
+def SKY_cipher_SHA256_Xor(p0, p1, p2):
+    return _skycoin.SKY_cipher_SHA256_Xor(p0, p1, p2)
+SKY_cipher_SHA256_Xor = _skycoin.SKY_cipher_SHA256_Xor
 
-def SKY_coin_UxArray_Less(*args):
-    return _skycoin.SKY_coin_UxArray_Less(*args)
-SKY_coin_UxArray_Less = _skycoin.SKY_coin_UxArray_Less
+def SKY_cipher_SumSHA256(p0, p1):
+    return _skycoin.SKY_cipher_SumSHA256(p0, p1)
+SKY_cipher_SumSHA256 = _skycoin.SKY_cipher_SumSHA256
 
-def SKY_coin_UxArray_Swap(*args):
-    return _skycoin.SKY_coin_UxArray_Swap(*args)
-SKY_coin_UxArray_Swap = _skycoin.SKY_coin_UxArray_Swap
+def SKY_cipher_SHA256FromHex(p0, p1):
+    return _skycoin.SKY_cipher_SHA256FromHex(p0, p1)
+SKY_cipher_SHA256FromHex = _skycoin.SKY_cipher_SHA256FromHex
 
-def SKY_coin_UxArray_Coins(*args):
-    return _skycoin.SKY_coin_UxArray_Coins(*args)
-SKY_coin_UxArray_Coins = _skycoin.SKY_coin_UxArray_Coins
+def SKY_cipher_DoubleSHA256(p0, p1):
+    return _skycoin.SKY_cipher_DoubleSHA256(p0, p1)
+SKY_cipher_DoubleSHA256 = _skycoin.SKY_cipher_DoubleSHA256
 
-def SKY_coin_UxArray_CoinHours(*args):
-    return _skycoin.SKY_coin_UxArray_CoinHours(*args)
-SKY_coin_UxArray_CoinHours = _skycoin.SKY_coin_UxArray_CoinHours
+def SKY_cipher_AddSHA256(p0, p1, p2):
+    return _skycoin.SKY_cipher_AddSHA256(p0, p1, p2)
+SKY_cipher_AddSHA256 = _skycoin.SKY_cipher_AddSHA256
 
-def SKY_coin_UxArray_Sub(*args):
-    return _skycoin.SKY_coin_UxArray_Sub(*args)
-SKY_coin_UxArray_Sub = _skycoin.SKY_coin_UxArray_Sub
+def SKY_cipher_Merkle(p0, p1):
+    return _skycoin.SKY_cipher_Merkle(p0, p1)
+SKY_cipher_Merkle = _skycoin.SKY_cipher_Merkle
 
-def SKY_coin_UxArray_Add(*args):
-    return _skycoin.SKY_coin_UxArray_Add(*args)
-SKY_coin_UxArray_Add = _skycoin.SKY_coin_UxArray_Add
+def SKY_cipher_SHA256_Null(p0):
+    return _skycoin.SKY_cipher_SHA256_Null(p0)
+SKY_cipher_SHA256_Null = _skycoin.SKY_cipher_SHA256_Null
 
-def SKY_coin_NewAddressUxOuts(*args):
-    return _skycoin.SKY_coin_NewAddressUxOuts(*args)
-SKY_coin_NewAddressUxOuts = _skycoin.SKY_coin_NewAddressUxOuts
+def SKY_cipher_DecodeBase58Address(p0, p1):
+    return _skycoin.SKY_cipher_DecodeBase58Address(p0, p1)
+SKY_cipher_DecodeBase58Address = _skycoin.SKY_cipher_DecodeBase58Address
 
-def SKY_coin_AddressUxOuts_Keys(*args):
-    return _skycoin.SKY_coin_AddressUxOuts_Keys(*args)
-SKY_coin_AddressUxOuts_Keys = _skycoin.SKY_coin_AddressUxOuts_Keys
+def SKY_cipher_AddressFromBytes(p0, p1):
+    return _skycoin.SKY_cipher_AddressFromBytes(p0, p1)
+SKY_cipher_AddressFromBytes = _skycoin.SKY_cipher_AddressFromBytes
 
-def SKY_coin_AddressUxOuts_Flatten(*args):
-    return _skycoin.SKY_coin_AddressUxOuts_Flatten(*args)
-SKY_coin_AddressUxOuts_Flatten = _skycoin.SKY_coin_AddressUxOuts_Flatten
+def SKY_cipher_AddressFromPubKey(p0, p1):
+    return _skycoin.SKY_cipher_AddressFromPubKey(p0, p1)
+SKY_cipher_AddressFromPubKey = _skycoin.SKY_cipher_AddressFromPubKey
 
-def SKY_coin_AddressUxOuts_Sub(p0, p1):
-    return _skycoin.SKY_coin_AddressUxOuts_Sub(p0, p1)
-SKY_coin_AddressUxOuts_Sub = _skycoin.SKY_coin_AddressUxOuts_Sub
+def SKY_cipher_AddressFromSecKey(p0, p1):
+    return _skycoin.SKY_cipher_AddressFromSecKey(p0, p1)
+SKY_cipher_AddressFromSecKey = _skycoin.SKY_cipher_AddressFromSecKey
 
-def SKY_coin_AddressUxOuts_Add(p0, p1):
-    return _skycoin.SKY_coin_AddressUxOuts_Add(p0, p1)
-SKY_coin_AddressUxOuts_Add = _skycoin.SKY_coin_AddressUxOuts_Add
+def SKY_cipher_Address_Null(p0):
+    return _skycoin.SKY_cipher_Address_Null(p0)
+SKY_cipher_Address_Null = _skycoin.SKY_cipher_Address_Null
 
-def SKY_coin_AddressUxOuts_Get(*args):
-    return _skycoin.SKY_coin_AddressUxOuts_Get(*args)
-SKY_coin_AddressUxOuts_Get = _skycoin.SKY_coin_AddressUxOuts_Get
+def SKY_cipher_Address_Bytes(p0):
+    return _skycoin.SKY_cipher_Address_Bytes(p0)
+SKY_cipher_Address_Bytes = _skycoin.SKY_cipher_Address_Bytes
 
-def SKY_coin_AddressUxOuts_HasKey(p0, p1):
-    return _skycoin.SKY_coin_AddressUxOuts_HasKey(p0, p1)
-SKY_coin_AddressUxOuts_HasKey = _skycoin.SKY_coin_AddressUxOuts_HasKey
+def SKY_cipher_Address_Verify(p0, p1):
+    return _skycoin.SKY_cipher_Address_Verify(p0, p1)
+SKY_cipher_Address_Verify = _skycoin.SKY_cipher_Address_Verify
 
-def SKY_coin_AddressUxOuts_GetOutputLength(p0, p1):
-    return _skycoin.SKY_coin_AddressUxOuts_GetOutputLength(p0, p1)
-SKY_coin_AddressUxOuts_GetOutputLength = _skycoin.SKY_coin_AddressUxOuts_GetOutputLength
+def SKY_cipher_Address_String(p0):
+    return _skycoin.SKY_cipher_Address_String(p0)
+SKY_cipher_Address_String = _skycoin.SKY_cipher_Address_String
 
-def SKY_coin_AddressUxOuts_Length(p0):
-    return _skycoin.SKY_coin_AddressUxOuts_Length(p0)
-SKY_coin_AddressUxOuts_Length = _skycoin.SKY_coin_AddressUxOuts_Length
+def SKY_cipher_Address_Checksum(p0, p1):
+    return _skycoin.SKY_cipher_Address_Checksum(p0, p1)
+SKY_cipher_Address_Checksum = _skycoin.SKY_cipher_Address_Checksum
 
-def SKY_coin_AddressUxOuts_Set(*args):
-    return _skycoin.SKY_coin_AddressUxOuts_Set(*args)
-SKY_coin_AddressUxOuts_Set = _skycoin.SKY_coin_AddressUxOuts_Set
+def SKY_wallet_NewBalance(p0, p1, p2):
+    return _skycoin.SKY_wallet_NewBalance(p0, p1, p2)
+SKY_wallet_NewBalance = _skycoin.SKY_wallet_NewBalance
 
-def SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2):
-    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2)
-SKY_encrypt_ScryptChacha20poly1305_Encrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt
+def SKY_wallet_NewBalanceFromUxOut(p0, p1, p2):
+    return _skycoin.SKY_wallet_NewBalanceFromUxOut(p0, p1, p2)
+SKY_wallet_NewBalanceFromUxOut = _skycoin.SKY_wallet_NewBalanceFromUxOut
 
-def SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2):
-    return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2)
-SKY_encrypt_ScryptChacha20poly1305_Decrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt
+def SKY_wallet_Balance_Add(p0, p1, p2):
+    return _skycoin.SKY_wallet_Balance_Add(p0, p1, p2)
+SKY_wallet_Balance_Add = _skycoin.SKY_wallet_Balance_Add
 
-def SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6):
-    return _skycoin.SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6)
-SKY_wallet_CreateOptionsHandle = _skycoin.SKY_wallet_CreateOptionsHandle
+def SKY_wallet_Balance_Sub(p0, p1, p2):
+    return _skycoin.SKY_wallet_Balance_Sub(p0, p1, p2)
+SKY_wallet_Balance_Sub = _skycoin.SKY_wallet_Balance_Sub
 
-def SKY_cli_AddPrivateKey(p0, p1):
-    return _skycoin.SKY_cli_AddPrivateKey(p0, p1)
-SKY_cli_AddPrivateKey = _skycoin.SKY_cli_AddPrivateKey
+def SKY_wallet_Balance_Equals(p0, p1):
+    return _skycoin.SKY_wallet_Balance_Equals(p0, p1)
+SKY_wallet_Balance_Equals = _skycoin.SKY_wallet_Balance_Equals
 
-def SKY_cli_AddPrivateKeyToFile(p0, p1, p2):
-    return _skycoin.SKY_cli_AddPrivateKeyToFile(p0, p1, p2)
-SKY_cli_AddPrivateKeyToFile = _skycoin.SKY_cli_AddPrivateKeyToFile
+def SKY_wallet_Balance_IsZero(p0):
+    return _skycoin.SKY_wallet_Balance_IsZero(p0)
+SKY_wallet_Balance_IsZero = _skycoin.SKY_wallet_Balance_IsZero
 
 def SKY_apputil_CatchInterruptPanic():
     return _skycoin.SKY_apputil_CatchInterruptPanic()
@@ -1729,389 +1761,357 @@ def SKY_apputil_PrintProgramStatus():
     return _skycoin.SKY_apputil_PrintProgramStatus()
 SKY_apputil_PrintProgramStatus = _skycoin.SKY_apputil_PrintProgramStatus
 
-def SKY_certutil_NewTLSCertPair(p0, p1, p2):
-    return _skycoin.SKY_certutil_NewTLSCertPair(p0, p1, p2)
-SKY_certutil_NewTLSCertPair = _skycoin.SKY_certutil_NewTLSCertPair
-
-def SKY_fee_VerifyTransactionFee(p0, p1, p2):
-    return _skycoin.SKY_fee_VerifyTransactionFee(p0, p1, p2)
-SKY_fee_VerifyTransactionFee = _skycoin.SKY_fee_VerifyTransactionFee
-
-def SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2):
-    return _skycoin.SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2)
-SKY_fee_VerifyTransactionFeeForHours = _skycoin.SKY_fee_VerifyTransactionFeeForHours
-
-def SKY_fee_RequiredFee(p0, p1):
-    return _skycoin.SKY_fee_RequiredFee(p0, p1)
-SKY_fee_RequiredFee = _skycoin.SKY_fee_RequiredFee
-
-def SKY_fee_RemainingHours(p0, p1):
-    return _skycoin.SKY_fee_RemainingHours(p0, p1)
-SKY_fee_RemainingHours = _skycoin.SKY_fee_RemainingHours
-
-def SKY_fee_TransactionFee(*args):
-    return _skycoin.SKY_fee_TransactionFee(*args)
-SKY_fee_TransactionFee = _skycoin.SKY_fee_TransactionFee
-
-def SKY_cli_LoadConfig():
-    return _skycoin.SKY_cli_LoadConfig()
-SKY_cli_LoadConfig = _skycoin.SKY_cli_LoadConfig
-
-def SKY_cli_Config_FullWalletPath(p0):
-    return _skycoin.SKY_cli_Config_FullWalletPath(p0)
-SKY_cli_Config_FullWalletPath = _skycoin.SKY_cli_Config_FullWalletPath
-
-def SKY_cli_Config_FullDBPath(p0):
-    return _skycoin.SKY_cli_Config_FullDBPath(p0)
-SKY_cli_Config_FullDBPath = _skycoin.SKY_cli_Config_FullDBPath
-
-def SKY_cli_NewApp(p0):
-    return _skycoin.SKY_cli_NewApp(p0)
-SKY_cli_NewApp = _skycoin.SKY_cli_NewApp
-
-def SKY_cli_RPCClientFromContext(p0):
-    return _skycoin.SKY_cli_RPCClientFromContext(p0)
-SKY_cli_RPCClientFromContext = _skycoin.SKY_cli_RPCClientFromContext
+def SKY_wallet_Entry_Verify(p0):
+    return _skycoin.SKY_wallet_Entry_Verify(p0)
+SKY_wallet_Entry_Verify = _skycoin.SKY_wallet_Entry_Verify
 
-def SKY_cli_ConfigFromContext(p0):
-    return _skycoin.SKY_cli_ConfigFromContext(p0)
-SKY_cli_ConfigFromContext = _skycoin.SKY_cli_ConfigFromContext
+def SKY_wallet_Entry_VerifyPublic(p0):
+    return _skycoin.SKY_wallet_Entry_VerifyPublic(p0)
+SKY_wallet_Entry_VerifyPublic = _skycoin.SKY_wallet_Entry_VerifyPublic
 
-def SKY_cli_PasswordFromBytes_Password():
-    return _skycoin.SKY_cli_PasswordFromBytes_Password()
-SKY_cli_PasswordFromBytes_Password = _skycoin.SKY_cli_PasswordFromBytes_Password
+def SKY_bip39_NewDefaultMnemomic():
+    return _skycoin.SKY_bip39_NewDefaultMnemomic()
+SKY_bip39_NewDefaultMnemomic = _skycoin.SKY_bip39_NewDefaultMnemomic
 
-def SKY_cli_PasswordFromTerm_Password():
-    return _skycoin.SKY_cli_PasswordFromTerm_Password()
-SKY_cli_PasswordFromTerm_Password = _skycoin.SKY_cli_PasswordFromTerm_Password
+def SKY_bip39_NewEntropy(p0):
+    return _skycoin.SKY_bip39_NewEntropy(p0)
+SKY_bip39_NewEntropy = _skycoin.SKY_bip39_NewEntropy
 
-def SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4):
-    return _skycoin.SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4)
-SKY_cli_CreateRawTxFromWallet = _skycoin.SKY_cli_CreateRawTxFromWallet
+def SKY_bip39_NewMnemonic(p0):
+    return _skycoin.SKY_bip39_NewMnemonic(p0)
+SKY_bip39_NewMnemonic = _skycoin.SKY_bip39_NewMnemonic
 
-def SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5):
-    return _skycoin.SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5)
-SKY_cli_CreateRawTxFromAddress = _skycoin.SKY_cli_CreateRawTxFromAddress
+def SKY_bip39_MnemonicToByteArray(p0):
+    return _skycoin.SKY_bip39_MnemonicToByteArray(p0)
+SKY_bip39_MnemonicToByteArray = _skycoin.SKY_bip39_MnemonicToByteArray
 
-def SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5):
-    return _skycoin.SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5)
-SKY_cli_CreateRawTx = _skycoin.SKY_cli_CreateRawTx
+def SKY_bip39_IsMnemonicValid(p0):
+    return _skycoin.SKY_bip39_IsMnemonicValid(p0)
+SKY_bip39_IsMnemonicValid = _skycoin.SKY_bip39_IsMnemonicValid
 
-def SKY_cli_NewTransaction(p0, p1, p2):
-    return _skycoin.SKY_cli_NewTransaction(p0, p1, p2)
-SKY_cli_NewTransaction = _skycoin.SKY_cli_NewTransaction
+def SKY_certutil_NewTLSCertPair(p0, p1, p2):
+    return _skycoin.SKY_certutil_NewTLSCertPair(p0, p1, p2)
+SKY_certutil_NewTLSCertPair = _skycoin.SKY_certutil_NewTLSCertPair
 
-def SKY_file_InitDataDir(p0):
-    return _skycoin.SKY_file_InitDataDir(p0)
-SKY_file_InitDataDir = _skycoin.SKY_file_InitDataDir
+def SKY_coin_UxOut_Hash(p0, p1):
+    return _skycoin.SKY_coin_UxOut_Hash(p0, p1)
+SKY_coin_UxOut_Hash = _skycoin.SKY_coin_UxOut_Hash
 
-def SKY_file_UserHome():
-    return _skycoin.SKY_file_UserHome()
-SKY_file_UserHome = _skycoin.SKY_file_UserHome
+def SKY_coin_UxOut_SnapshotHash(p0, p1):
+    return _skycoin.SKY_coin_UxOut_SnapshotHash(p0, p1)
+SKY_coin_UxOut_SnapshotHash = _skycoin.SKY_coin_UxOut_SnapshotHash
 
-def SKY_file_ResolveResourceDirectory(p0):
-    return _skycoin.SKY_file_ResolveResourceDirectory(p0)
-SKY_file_ResolveResourceDirectory = _skycoin.SKY_file_ResolveResourceDirectory
+def SKY_coin_UxBody_Hash(p0, p1):
+    return _skycoin.SKY_coin_UxBody_Hash(p0, p1)
+SKY_coin_UxBody_Hash = _skycoin.SKY_coin_UxBody_Hash
 
-def SKY_file_DetermineResourcePath(p0, p1, p2):
-    return _skycoin.SKY_file_DetermineResourcePath(p0, p1, p2)
-SKY_file_DetermineResourcePath = _skycoin.SKY_file_DetermineResourcePath
+def SKY_coin_UxOut_CoinHours(p0, p1):
+    return _skycoin.SKY_coin_UxOut_CoinHours(p0, p1)
+SKY_coin_UxOut_CoinHours = _skycoin.SKY_coin_UxOut_CoinHours
 
-def SKY_cipher_DecodeBase58BitcoinAddress(p0, p1):
-    return _skycoin.SKY_cipher_DecodeBase58BitcoinAddress(p0, p1)
-SKY_cipher_DecodeBase58BitcoinAddress = _skycoin.SKY_cipher_DecodeBase58BitcoinAddress
+def SKY_coin_UxArray_Hashes(*args):
+    return _skycoin.SKY_coin_UxArray_Hashes(*args)
+SKY_coin_UxArray_Hashes = _skycoin.SKY_coin_UxArray_Hashes
 
-def SKY_cipher_BitcoinAddressFromPubKey(p0, p1):
-    return _skycoin.SKY_cipher_BitcoinAddressFromPubKey(p0, p1)
-SKY_cipher_BitcoinAddressFromPubKey = _skycoin.SKY_cipher_BitcoinAddressFromPubKey
+def SKY_coin_UxArray_HasDupes(*args):
+    return _skycoin.SKY_coin_UxArray_HasDupes(*args)
+SKY_coin_UxArray_HasDupes = _skycoin.SKY_coin_UxArray_HasDupes
 
-def SKY_cipher_BitcoinAddressFromSecKey(p0, p1):
-    return _skycoin.SKY_cipher_BitcoinAddressFromSecKey(p0, p1)
-SKY_cipher_BitcoinAddressFromSecKey = _skycoin.SKY_cipher_BitcoinAddressFromSecKey
+def SKY_coin_UxArray_Sort():
+    return _skycoin.SKY_coin_UxArray_Sort()
+SKY_coin_UxArray_Sort = _skycoin.SKY_coin_UxArray_Sort
 
-def SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0):
-    return _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0)
-SKY_cipher_BitcoinWalletImportFormatFromSeckey = _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey
+def SKY_coin_UxArray_Len():
+    return _skycoin.SKY_coin_UxArray_Len()
+SKY_coin_UxArray_Len = _skycoin.SKY_coin_UxArray_Len
 
-def SKY_cipher_BitcoinAddressFromBytes(p0, p1):
-    return _skycoin.SKY_cipher_BitcoinAddressFromBytes(p0, p1)
-SKY_cipher_BitcoinAddressFromBytes = _skycoin.SKY_cipher_BitcoinAddressFromBytes
+def SKY_coin_UxArray_Less(*args):
+    return _skycoin.SKY_coin_UxArray_Less(*args)
+SKY_coin_UxArray_Less = _skycoin.SKY_coin_UxArray_Less
 
-def SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1):
-    return _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1)
-SKY_cipher_SecKeyFromBitcoinWalletImportFormat = _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat
+def SKY_coin_UxArray_Swap(*args):
+    return _skycoin.SKY_coin_UxArray_Swap(*args)
+SKY_coin_UxArray_Swap = _skycoin.SKY_coin_UxArray_Swap
 
-def SKY_cipher_BitcoinAddress_Null(p0):
-    return _skycoin.SKY_cipher_BitcoinAddress_Null(p0)
-SKY_cipher_BitcoinAddress_Null = _skycoin.SKY_cipher_BitcoinAddress_Null
+def SKY_coin_UxArray_Coins(*args):
+    return _skycoin.SKY_coin_UxArray_Coins(*args)
+SKY_coin_UxArray_Coins = _skycoin.SKY_coin_UxArray_Coins
 
-def SKY_cipher_BitcoinAddress_Bytes(p0):
-    return _skycoin.SKY_cipher_BitcoinAddress_Bytes(p0)
-SKY_cipher_BitcoinAddress_Bytes = _skycoin.SKY_cipher_BitcoinAddress_Bytes
+def SKY_coin_UxArray_CoinHours(*args):
+    return _skycoin.SKY_coin_UxArray_CoinHours(*args)
+SKY_coin_UxArray_CoinHours = _skycoin.SKY_coin_UxArray_CoinHours
 
-def SKY_cipher_BitcoinAddress_Verify(p0, p1):
-    return _skycoin.SKY_cipher_BitcoinAddress_Verify(p0, p1)
-SKY_cipher_BitcoinAddress_Verify = _skycoin.SKY_cipher_BitcoinAddress_Verify
+def SKY_coin_UxArray_Sub(*args):
+    return _skycoin.SKY_coin_UxArray_Sub(*args)
+SKY_coin_UxArray_Sub = _skycoin.SKY_coin_UxArray_Sub
 
-def SKY_cipher_BitcoinAddress_String(p0):
-    return _skycoin.SKY_cipher_BitcoinAddress_String(p0)
-SKY_cipher_BitcoinAddress_String = _skycoin.SKY_cipher_BitcoinAddress_String
+def SKY_coin_UxArray_Add(*args):
+    return _skycoin.SKY_coin_UxArray_Add(*args)
+SKY_coin_UxArray_Add = _skycoin.SKY_coin_UxArray_Add
 
-def SKY_cipher_BitcoinAddress_Checksum(p0, p1):
-    return _skycoin.SKY_cipher_BitcoinAddress_Checksum(p0, p1)
-SKY_cipher_BitcoinAddress_Checksum = _skycoin.SKY_cipher_BitcoinAddress_Checksum
+def SKY_coin_NewAddressUxOuts(*args):
+    return _skycoin.SKY_coin_NewAddressUxOuts(*args)
+SKY_coin_NewAddressUxOuts = _skycoin.SKY_coin_NewAddressUxOuts
 
-def SKY_cli_GetWalletOutputsFromFile(p0, p1, p2):
-    return _skycoin.SKY_cli_GetWalletOutputsFromFile(p0, p1, p2)
-SKY_cli_GetWalletOutputsFromFile = _skycoin.SKY_cli_GetWalletOutputsFromFile
+def SKY_coin_AddressUxOuts_Keys(*args):
+    return _skycoin.SKY_coin_AddressUxOuts_Keys(*args)
+SKY_coin_AddressUxOuts_Keys = _skycoin.SKY_coin_AddressUxOuts_Keys
 
-def SKY_cli_GetWalletOutputs(p0, p2):
-    return _skycoin.SKY_cli_GetWalletOutputs(p0, p2)
-SKY_cli_GetWalletOutputs = _skycoin.SKY_cli_GetWalletOutputs
+def SKY_coin_AddressUxOuts_Flatten(*args):
+    return _skycoin.SKY_coin_AddressUxOuts_Flatten(*args)
+SKY_coin_AddressUxOuts_Flatten = _skycoin.SKY_coin_AddressUxOuts_Flatten
 
-def SKY_testutil_MakeAddress(p0):
-    return _skycoin.SKY_testutil_MakeAddress(p0)
-SKY_testutil_MakeAddress = _skycoin.SKY_testutil_MakeAddress
+def SKY_coin_AddressUxOuts_Sub(p0, p1):
+    return _skycoin.SKY_coin_AddressUxOuts_Sub(p0, p1)
+SKY_coin_AddressUxOuts_Sub = _skycoin.SKY_coin_AddressUxOuts_Sub
 
-def SKY_cipher_Ripemd160_Set(p0, p1):
-    return _skycoin.SKY_cipher_Ripemd160_Set(p0, p1)
-SKY_cipher_Ripemd160_Set = _skycoin.SKY_cipher_Ripemd160_Set
+def SKY_coin_AddressUxOuts_Add(p0, p1):
+    return _skycoin.SKY_coin_AddressUxOuts_Add(p0, p1)
+SKY_coin_AddressUxOuts_Add = _skycoin.SKY_coin_AddressUxOuts_Add
 
-def SKY_cipher_HashRipemd160(p0, p1):
-    return _skycoin.SKY_cipher_HashRipemd160(p0, p1)
-SKY_cipher_HashRipemd160 = _skycoin.SKY_cipher_HashRipemd160
+def SKY_coin_AddressUxOuts_Get(*args):
+    return _skycoin.SKY_coin_AddressUxOuts_Get(*args)
+SKY_coin_AddressUxOuts_Get = _skycoin.SKY_coin_AddressUxOuts_Get
 
-def SKY_cipher_SHA256_Set(p0, p1):
-    return _skycoin.SKY_cipher_SHA256_Set(p0, p1)
-SKY_cipher_SHA256_Set = _skycoin.SKY_cipher_SHA256_Set
+def SKY_coin_AddressUxOuts_HasKey(p0, p1):
+    return _skycoin.SKY_coin_AddressUxOuts_HasKey(p0, p1)
+SKY_coin_AddressUxOuts_HasKey = _skycoin.SKY_coin_AddressUxOuts_HasKey
 
-def SKY_cipher_SHA256_Hex(p0):
-    return _skycoin.SKY_cipher_SHA256_Hex(p0)
-SKY_cipher_SHA256_Hex = _skycoin.SKY_cipher_SHA256_Hex
+def SKY_coin_AddressUxOuts_GetOutputLength(p0, p1):
+    return _skycoin.SKY_coin_AddressUxOuts_GetOutputLength(p0, p1)
+SKY_coin_AddressUxOuts_GetOutputLength = _skycoin.SKY_coin_AddressUxOuts_GetOutputLength
 
-def SKY_cipher_SHA256_Xor(p0, p1, p2):
-    return _skycoin.SKY_cipher_SHA256_Xor(p0, p1, p2)
-SKY_cipher_SHA256_Xor = _skycoin.SKY_cipher_SHA256_Xor
+def SKY_coin_AddressUxOuts_Length(p0):
+    return _skycoin.SKY_coin_AddressUxOuts_Length(p0)
+SKY_coin_AddressUxOuts_Length = _skycoin.SKY_coin_AddressUxOuts_Length
 
-def SKY_cipher_SumSHA256(p0, p1):
-    return _skycoin.SKY_cipher_SumSHA256(p0, p1)
-SKY_cipher_SumSHA256 = _skycoin.SKY_cipher_SumSHA256
+def SKY_coin_AddressUxOuts_Set(*args):
+    return _skycoin.SKY_coin_AddressUxOuts_Set(*args)
+SKY_coin_AddressUxOuts_Set = _skycoin.SKY_coin_AddressUxOuts_Set
 
-def SKY_cipher_SHA256FromHex(p0, p1):
-    return _skycoin.SKY_cipher_SHA256FromHex(p0, p1)
-SKY_cipher_SHA256FromHex = _skycoin.SKY_cipher_SHA256FromHex
+def SKY_api_NewClient(p0):
+    return _skycoin.SKY_api_NewClient(p0)
+SKY_api_NewClient = _skycoin.SKY_api_NewClient
 
-def SKY_cipher_DoubleSHA256(p0, p1):
-    return _skycoin.SKY_cipher_DoubleSHA256(p0, p1)
-SKY_cipher_DoubleSHA256 = _skycoin.SKY_cipher_DoubleSHA256
+def SKY_api_Client_CSRF(p0):
+    return _skycoin.SKY_api_Client_CSRF(p0)
+SKY_api_Client_CSRF = _skycoin.SKY_api_Client_CSRF
 
-def SKY_cipher_AddSHA256(p0, p1, p2):
-    return _skycoin.SKY_cipher_AddSHA256(p0, p1, p2)
-SKY_cipher_AddSHA256 = _skycoin.SKY_cipher_AddSHA256
+def SKY_api_Client_Version(p0):
+    return _skycoin.SKY_api_Client_Version(p0)
+SKY_api_Client_Version = _skycoin.SKY_api_Client_Version
 
-def SKY_cipher_Merkle(p0, p1):
-    return _skycoin.SKY_cipher_Merkle(p0, p1)
-SKY_cipher_Merkle = _skycoin.SKY_cipher_Merkle
+def SKY_api_Client_Outputs(p0):
+    return _skycoin.SKY_api_Client_Outputs(p0)
+SKY_api_Client_Outputs = _skycoin.SKY_api_Client_Outputs
 
-def SKY_cipher_SHA256_Null(p0):
-    return _skycoin.SKY_cipher_SHA256_Null(p0)
-SKY_cipher_SHA256_Null = _skycoin.SKY_cipher_SHA256_Null
+def SKY_api_Client_OutputsForAddresses(p0, p1):
+    return _skycoin.SKY_api_Client_OutputsForAddresses(p0, p1)
+SKY_api_Client_OutputsForAddresses = _skycoin.SKY_api_Client_OutputsForAddresses
 
-def SKY_coin_Create_Transaction():
-    return _skycoin.SKY_coin_Create_Transaction()
-SKY_coin_Create_Transaction = _skycoin.SKY_coin_Create_Transaction
+def SKY_api_Client_OutputsForHashes(p0, p1):
+    return _skycoin.SKY_api_Client_OutputsForHashes(p0, p1)
+SKY_api_Client_OutputsForHashes = _skycoin.SKY_api_Client_OutputsForHashes
 
-def SKY_coin_Transaction_Copy(p0):
-    return _skycoin.SKY_coin_Transaction_Copy(p0)
-SKY_coin_Transaction_Copy = _skycoin.SKY_coin_Transaction_Copy
+def SKY_api_Client_CoinSupply(p0):
+    return _skycoin.SKY_api_Client_CoinSupply(p0)
+SKY_api_Client_CoinSupply = _skycoin.SKY_api_Client_CoinSupply
 
-def SKY_coin_GetTransactionObject(p0):
-    return _skycoin.SKY_coin_GetTransactionObject(p0)
-SKY_coin_GetTransactionObject = _skycoin.SKY_coin_GetTransactionObject
+def SKY_api_Client_BlockByHash(p0, p1):
+    return _skycoin.SKY_api_Client_BlockByHash(p0, p1)
+SKY_api_Client_BlockByHash = _skycoin.SKY_api_Client_BlockByHash
 
-def SKY_coin_Transaction_ResetInputs(p0, p1):
-    return _skycoin.SKY_coin_Transaction_ResetInputs(p0, p1)
-SKY_coin_Transaction_ResetInputs = _skycoin.SKY_coin_Transaction_ResetInputs
+def SKY_api_Client_BlockBySeq(p0, p1):
+    return _skycoin.SKY_api_Client_BlockBySeq(p0, p1)
+SKY_api_Client_BlockBySeq = _skycoin.SKY_api_Client_BlockBySeq
 
-def SKY_coin_Transaction_GetInputsCount(p0):
-    return _skycoin.SKY_coin_Transaction_GetInputsCount(p0)
-SKY_coin_Transaction_GetInputsCount = _skycoin.SKY_coin_Transaction_GetInputsCount
+def SKY_api_Client_Blocks(p0, p1):
+    return _skycoin.SKY_api_Client_Blocks(p0, p1)
+SKY_api_Client_Blocks = _skycoin.SKY_api_Client_Blocks
 
-def SKY_coin_Transaction_GetInputAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_GetInputAt(p0, p1, p2)
-SKY_coin_Transaction_GetInputAt = _skycoin.SKY_coin_Transaction_GetInputAt
+def SKY_api_Client_LastBlocks(p0, p1):
+    return _skycoin.SKY_api_Client_LastBlocks(p0, p1)
+SKY_api_Client_LastBlocks = _skycoin.SKY_api_Client_LastBlocks
 
-def SKY_coin_Transaction_SetInputAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_SetInputAt(p0, p1, p2)
-SKY_coin_Transaction_SetInputAt = _skycoin.SKY_coin_Transaction_SetInputAt
+def SKY_api_Client_BlockchainMetadata(p0):
+    return _skycoin.SKY_api_Client_BlockchainMetadata(p0)
+SKY_api_Client_BlockchainMetadata = _skycoin.SKY_api_Client_BlockchainMetadata
+
+def SKY_api_Client_BlockchainProgress(p0):
+    return _skycoin.SKY_api_Client_BlockchainProgress(p0)
+SKY_api_Client_BlockchainProgress = _skycoin.SKY_api_Client_BlockchainProgress
 
-def SKY_coin_Transaction_GetOutputsCount(p0):
-    return _skycoin.SKY_coin_Transaction_GetOutputsCount(p0)
-SKY_coin_Transaction_GetOutputsCount = _skycoin.SKY_coin_Transaction_GetOutputsCount
+def SKY_api_Client_Balance(p0, p1, p2):
+    return _skycoin.SKY_api_Client_Balance(p0, p1, p2)
+SKY_api_Client_Balance = _skycoin.SKY_api_Client_Balance
 
-def SKY_coin_Transaction_GetOutputAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_GetOutputAt(p0, p1, p2)
-SKY_coin_Transaction_GetOutputAt = _skycoin.SKY_coin_Transaction_GetOutputAt
+def SKY_api_Client_UxOut(p0, p1):
+    return _skycoin.SKY_api_Client_UxOut(p0, p1)
+SKY_api_Client_UxOut = _skycoin.SKY_api_Client_UxOut
 
-def SKY_coin_Transaction_SetOutputAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_SetOutputAt(p0, p1, p2)
-SKY_coin_Transaction_SetOutputAt = _skycoin.SKY_coin_Transaction_SetOutputAt
+def SKY_api_Client_AddressUxOuts(p0, p1):
+    return _skycoin.SKY_api_Client_AddressUxOuts(p0, p1)
+SKY_api_Client_AddressUxOuts = _skycoin.SKY_api_Client_AddressUxOuts
 
-def SKY_coin_Transaction_GetSignaturesCount(p0):
-    return _skycoin.SKY_coin_Transaction_GetSignaturesCount(p0)
-SKY_coin_Transaction_GetSignaturesCount = _skycoin.SKY_coin_Transaction_GetSignaturesCount
+def SKY_api_Client_Wallet(p0, p1):
+    return _skycoin.SKY_api_Client_Wallet(p0, p1)
+SKY_api_Client_Wallet = _skycoin.SKY_api_Client_Wallet
 
-def SKY_coin_Transaction_GetSignatureAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_GetSignatureAt(p0, p1, p2)
-SKY_coin_Transaction_GetSignatureAt = _skycoin.SKY_coin_Transaction_GetSignatureAt
+def SKY_api_Client_Wallets(p0):
+    return _skycoin.SKY_api_Client_Wallets(p0)
+SKY_api_Client_Wallets = _skycoin.SKY_api_Client_Wallets
 
-def SKY_coin_Transaction_SetSignatureAt(p0, p1, p2):
-    return _skycoin.SKY_coin_Transaction_SetSignatureAt(p0, p1, p2)
-SKY_coin_Transaction_SetSignatureAt = _skycoin.SKY_coin_Transaction_SetSignatureAt
+def SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3):
+    return _skycoin.SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3)
+SKY_api_Client_CreateUnencryptedWallet = _skycoin.SKY_api_Client_CreateUnencryptedWallet
 
-def SKY_coin_Transaction_PushSignature(p0, p1):
-    return _skycoin.SKY_coin_Transaction_PushSignature(p0, p1)
-SKY_coin_Transaction_PushSignature = _skycoin.SKY_coin_Transaction_PushSignature
+def SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4):
+    return _skycoin.SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4)
+SKY_api_Client_CreateEncryptedWallet = _skycoin.SKY_api_Client_CreateEncryptedWallet
 
-def SKY_coin_Transaction_ResetOutputs(p0, p1):
-    return _skycoin.SKY_coin_Transaction_ResetOutputs(p0, p1)
-SKY_coin_Transaction_ResetOutputs = _skycoin.SKY_coin_Transaction_ResetOutputs
+def SKY_api_Client_NewWalletAddress(p0, p1, p2, p3):
+    return _skycoin.SKY_api_Client_NewWalletAddress(p0, p1, p2, p3)
+SKY_api_Client_NewWalletAddress = _skycoin.SKY_api_Client_NewWalletAddress
 
-def SKY_coin_Transaction_ResetSignatures(p0, p1):
-    return _skycoin.SKY_coin_Transaction_ResetSignatures(p0, p1)
-SKY_coin_Transaction_ResetSignatures = _skycoin.SKY_coin_Transaction_ResetSignatures
+def SKY_api_Client_WalletBalance(p0, p1, p2):
+    return _skycoin.SKY_api_Client_WalletBalance(p0, p1, p2)
+SKY_api_Client_WalletBalance = _skycoin.SKY_api_Client_WalletBalance
 
-def SKY_coin_Transaction_Verify(p0):
-    return _skycoin.SKY_coin_Transaction_Verify(p0)
-SKY_coin_Transaction_Verify = _skycoin.SKY_coin_Transaction_Verify
+def SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5):
+    return _skycoin.SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5)
+SKY_api_Client_Spend = _skycoin.SKY_api_Client_Spend
 
-def SKY_coin_Transaction_VerifyInput(*args):
-    return _skycoin.SKY_coin_Transaction_VerifyInput(*args)
-SKY_coin_Transaction_VerifyInput = _skycoin.SKY_coin_Transaction_VerifyInput
+def SKY_api_Client_CreateTransaction(p0):
+    return _skycoin.SKY_api_Client_CreateTransaction(p0)
+SKY_api_Client_CreateTransaction = _skycoin.SKY_api_Client_CreateTransaction
 
-def SKY_coin_Transaction_PushInput(p0, p1):
-    return _skycoin.SKY_coin_Transaction_PushInput(p0, p1)
-SKY_coin_Transaction_PushInput = _skycoin.SKY_coin_Transaction_PushInput
+def SKY_api_Client_UpdateWallet(p0, p1, p2):
+    return _skycoin.SKY_api_Client_UpdateWallet(p0, p1, p2)
+SKY_api_Client_UpdateWallet = _skycoin.SKY_api_Client_UpdateWallet
 
-def SKY_coin_TransactionOutput_UxID(p0, p1, p2):
-    return _skycoin.SKY_coin_TransactionOutput_UxID(p0, p1, p2)
-SKY_coin_TransactionOutput_UxID = _skycoin.SKY_coin_TransactionOutput_UxID
+def SKY_api_Client_WalletFolderName(p0):
+    return _skycoin.SKY_api_Client_WalletFolderName(p0)
+SKY_api_Client_WalletFolderName = _skycoin.SKY_api_Client_WalletFolderName
 
-def SKY_coin_Transaction_PushOutput(p0, p1, p2, p3):
-    return _skycoin.SKY_coin_Transaction_PushOutput(p0, p1, p2, p3)
-SKY_coin_Transaction_PushOutput = _skycoin.SKY_coin_Transaction_PushOutput
+def SKY_api_Client_NewSeed(p0, p1):
+    return _skycoin.SKY_api_Client_NewSeed(p0, p1)
+SKY_api_Client_NewSeed = _skycoin.SKY_api_Client_NewSeed
 
-def SKY_coin_Transaction_SignInputs(*args):
-    return _skycoin.SKY_coin_Transaction_SignInputs(*args)
-SKY_coin_Transaction_SignInputs = _skycoin.SKY_coin_Transaction_SignInputs
+def SKY_api_Client_WalletSeed(p0, p1, p2):
+    return _skycoin.SKY_api_Client_WalletSeed(p0, p1, p2)
+SKY_api_Client_WalletSeed = _skycoin.SKY_api_Client_WalletSeed
 
-def SKY_coin_Transaction_Size(p0):
-    return _skycoin.SKY_coin_Transaction_Size(p0)
-SKY_coin_Transaction_Size = _skycoin.SKY_coin_Transaction_Size
+def SKY_api_Client_NetworkConnection(p0, p1):
+    return _skycoin.SKY_api_Client_NetworkConnection(p0, p1)
+SKY_api_Client_NetworkConnection = _skycoin.SKY_api_Client_NetworkConnection
 
-def SKY_coin_Transaction_Hash(p0, p1):
-    return _skycoin.SKY_coin_Transaction_Hash(p0, p1)
-SKY_coin_Transaction_Hash = _skycoin.SKY_coin_Transaction_Hash
+def SKY_api_Client_NetworkConnections(p0, p1):
+    return _skycoin.SKY_api_Client_NetworkConnections(p0, p1)
+SKY_api_Client_NetworkConnections = _skycoin.SKY_api_Client_NetworkConnections
 
-def SKY_coin_Transaction_SizeHash(p0, p2):
-    return _skycoin.SKY_coin_Transaction_SizeHash(p0, p2)
-SKY_coin_Transaction_SizeHash = _skycoin.SKY_coin_Transaction_SizeHash
+def SKY_api_Client_NetworkDefaultPeers(p0):
+    return _skycoin.SKY_api_Client_NetworkDefaultPeers(p0)
+SKY_api_Client_NetworkDefaultPeers = _skycoin.SKY_api_Client_NetworkDefaultPeers
 
-def SKY_coin_Transaction_TxID(p0):
-    return _skycoin.SKY_coin_Transaction_TxID(p0)
-SKY_coin_Transaction_TxID = _skycoin.SKY_coin_Transaction_TxID
+def SKY_api_Client_NetworkTrustedPeers(p0):
+    return _skycoin.SKY_api_Client_NetworkTrustedPeers(p0)
+SKY_api_Client_NetworkTrustedPeers = _skycoin.SKY_api_Client_NetworkTrustedPeers
 
-def SKY_coin_Transaction_TxIDHex(p0):
-    return _skycoin.SKY_coin_Transaction_TxIDHex(p0)
-SKY_coin_Transaction_TxIDHex = _skycoin.SKY_coin_Transaction_TxIDHex
+def SKY_api_Client_NetworkExchangedPeers(p0):
+    return _skycoin.SKY_api_Client_NetworkExchangedPeers(p0)
+SKY_api_Client_NetworkExchangedPeers = _skycoin.SKY_api_Client_NetworkExchangedPeers
 
-def SKY_coin_Transaction_UpdateHeader(p0):
-    return _skycoin.SKY_coin_Transaction_UpdateHeader(p0)
-SKY_coin_Transaction_UpdateHeader = _skycoin.SKY_coin_Transaction_UpdateHeader
+def SKY_api_Client_PendingTransactions(p0):
+    return _skycoin.SKY_api_Client_PendingTransactions(p0)
+SKY_api_Client_PendingTransactions = _skycoin.SKY_api_Client_PendingTransactions
 
-def SKY_coin_Transaction_HashInner(p0, p1):
-    return _skycoin.SKY_coin_Transaction_HashInner(p0, p1)
-SKY_coin_Transaction_HashInner = _skycoin.SKY_coin_Transaction_HashInner
+def SKY_api_Client_Transaction(p0, p1):
+    return _skycoin.SKY_api_Client_Transaction(p0, p1)
+SKY_api_Client_Transaction = _skycoin.SKY_api_Client_Transaction
 
-def SKY_coin_Transaction_Serialize(p0):
-    return _skycoin.SKY_coin_Transaction_Serialize(p0)
-SKY_coin_Transaction_Serialize = _skycoin.SKY_coin_Transaction_Serialize
+def SKY_api_Client_Transactions(p0, p1):
+    return _skycoin.SKY_api_Client_Transactions(p0, p1)
+SKY_api_Client_Transactions = _skycoin.SKY_api_Client_Transactions
 
-def SKY_coin_TransactionDeserialize(p0):
-    return _skycoin.SKY_coin_TransactionDeserialize(p0)
-SKY_coin_TransactionDeserialize = _skycoin.SKY_coin_TransactionDeserialize
+def SKY_api_Client_ConfirmedTransactions(p0, p1):
+    return _skycoin.SKY_api_Client_ConfirmedTransactions(p0, p1)
+SKY_api_Client_ConfirmedTransactions = _skycoin.SKY_api_Client_ConfirmedTransactions
 
-def SKY_coin_Transaction_OutputHours(p0):
-    return _skycoin.SKY_coin_Transaction_OutputHours(p0)
-SKY_coin_Transaction_OutputHours = _skycoin.SKY_coin_Transaction_OutputHours
+def SKY_api_Client_UnconfirmedTransactions(p0, p1):
+    return _skycoin.SKY_api_Client_UnconfirmedTransactions(p0, p1)
+SKY_api_Client_UnconfirmedTransactions = _skycoin.SKY_api_Client_UnconfirmedTransactions
 
-def SKY_coin_Create_Transactions():
-    return _skycoin.SKY_coin_Create_Transactions()
-SKY_coin_Create_Transactions = _skycoin.SKY_coin_Create_Transactions
+def SKY_api_Client_InjectTransaction(p0, p1):
+    return _skycoin.SKY_api_Client_InjectTransaction(p0, p1)
+SKY_api_Client_InjectTransaction = _skycoin.SKY_api_Client_InjectTransaction
 
-def SKY_coin_GetTransactionsObject(p0, p1):
-    return _skycoin.SKY_coin_GetTransactionsObject(p0, p1)
-SKY_coin_GetTransactionsObject = _skycoin.SKY_coin_GetTransactionsObject
+def SKY_api_Client_ResendUnconfirmedTransactions(p0):
+    return _skycoin.SKY_api_Client_ResendUnconfirmedTransactions(p0)
+SKY_api_Client_ResendUnconfirmedTransactions = _skycoin.SKY_api_Client_ResendUnconfirmedTransactions
 
-def SKY_coin_Transactions_Length(p0):
-    return _skycoin.SKY_coin_Transactions_Length(p0)
-SKY_coin_Transactions_Length = _skycoin.SKY_coin_Transactions_Length
+def SKY_api_Client_RawTransaction(p0, p1):
+    return _skycoin.SKY_api_Client_RawTransaction(p0, p1)
+SKY_api_Client_RawTransaction = _skycoin.SKY_api_Client_RawTransaction
 
-def SKY_coin_Transactions_Add(p0, p1):
-    return _skycoin.SKY_coin_Transactions_Add(p0, p1)
-SKY_coin_Transactions_Add = _skycoin.SKY_coin_Transactions_Add
+def SKY_api_Client_AddressTransactions(p0, p1):
+    return _skycoin.SKY_api_Client_AddressTransactions(p0, p1)
+SKY_api_Client_AddressTransactions = _skycoin.SKY_api_Client_AddressTransactions
 
-def SKY_coin_Transactions_Fees(p0, p1):
-    return _skycoin.SKY_coin_Transactions_Fees(p0, p1)
-SKY_coin_Transactions_Fees = _skycoin.SKY_coin_Transactions_Fees
+def SKY_api_Client_Richlist(p0, p1):
+    return _skycoin.SKY_api_Client_Richlist(p0, p1)
+SKY_api_Client_Richlist = _skycoin.SKY_api_Client_Richlist
 
-def SKY_coin_Transactions_GetAt(p0, p1):
-    return _skycoin.SKY_coin_Transactions_GetAt(p0, p1)
-SKY_coin_Transactions_GetAt = _skycoin.SKY_coin_Transactions_GetAt
+def SKY_api_Client_AddressCount(p0):
+    return _skycoin.SKY_api_Client_AddressCount(p0)
+SKY_api_Client_AddressCount = _skycoin.SKY_api_Client_AddressCount
 
-def SKY_coin_Transactions_Hashes(*args):
-    return _skycoin.SKY_coin_Transactions_Hashes(*args)
-SKY_coin_Transactions_Hashes = _skycoin.SKY_coin_Transactions_Hashes
+def SKY_api_Client_UnloadWallet(p0, p1):
+    return _skycoin.SKY_api_Client_UnloadWallet(p0, p1)
+SKY_api_Client_UnloadWallet = _skycoin.SKY_api_Client_UnloadWallet
 
-def SKY_coin_Transactions_Size(p0):
-    return _skycoin.SKY_coin_Transactions_Size(p0)
-SKY_coin_Transactions_Size = _skycoin.SKY_coin_Transactions_Size
+def SKY_api_Client_Health(p0):
+    return _skycoin.SKY_api_Client_Health(p0)
+SKY_api_Client_Health = _skycoin.SKY_api_Client_Health
 
-def SKY_coin_Transactions_TruncateBytesTo(p0, p1):
-    return _skycoin.SKY_coin_Transactions_TruncateBytesTo(p0, p1)
-SKY_coin_Transactions_TruncateBytesTo = _skycoin.SKY_coin_Transactions_TruncateBytesTo
+def SKY_api_Client_EncryptWallet(p0, p1, p2):
+    return _skycoin.SKY_api_Client_EncryptWallet(p0, p1, p2)
+SKY_api_Client_EncryptWallet = _skycoin.SKY_api_Client_EncryptWallet
 
-def SKY_coin_SortTransactions(p0, p1):
-    return _skycoin.SKY_coin_SortTransactions(p0, p1)
-SKY_coin_SortTransactions = _skycoin.SKY_coin_SortTransactions
+def SKY_api_Client_DecryptWallet(p0, p1, p2):
+    return _skycoin.SKY_api_Client_DecryptWallet(p0, p1, p2)
+SKY_api_Client_DecryptWallet = _skycoin.SKY_api_Client_DecryptWallet
 
-def SKY_coin_NewSortableTransactions(p0, p1, p2):
-    return _skycoin.SKY_coin_NewSortableTransactions(p0, p1, p2)
-SKY_coin_NewSortableTransactions = _skycoin.SKY_coin_NewSortableTransactions
+def SKY_httphelper_Address_UnmarshalJSON(p0, p1):
+    return _skycoin.SKY_httphelper_Address_UnmarshalJSON(p0, p1)
+SKY_httphelper_Address_UnmarshalJSON = _skycoin.SKY_httphelper_Address_UnmarshalJSON
 
-def SKY_coin_SortableTransactions_Sort(p0):
-    return _skycoin.SKY_coin_SortableTransactions_Sort(p0)
-SKY_coin_SortableTransactions_Sort = _skycoin.SKY_coin_SortableTransactions_Sort
+def SKY_httphelper_Address_MarshalJSON(p0):
+    return _skycoin.SKY_httphelper_Address_MarshalJSON(p0)
+SKY_httphelper_Address_MarshalJSON = _skycoin.SKY_httphelper_Address_MarshalJSON
 
-def SKY_coin_SortableTransactions_Len(p0):
-    return _skycoin.SKY_coin_SortableTransactions_Len(p0)
-SKY_coin_SortableTransactions_Len = _skycoin.SKY_coin_SortableTransactions_Len
+def SKY_httphelper_Coins_UnmarshalJSON(p1):
+    return _skycoin.SKY_httphelper_Coins_UnmarshalJSON(p1)
+SKY_httphelper_Coins_UnmarshalJSON = _skycoin.SKY_httphelper_Coins_UnmarshalJSON
 
-def SKY_coin_SortableTransactions_Less(p0, p1, p2):
-    return _skycoin.SKY_coin_SortableTransactions_Less(p0, p1, p2)
-SKY_coin_SortableTransactions_Less = _skycoin.SKY_coin_SortableTransactions_Less
+def SKY_httphelper_Coins_MarshalJSON():
+    return _skycoin.SKY_httphelper_Coins_MarshalJSON()
+SKY_httphelper_Coins_MarshalJSON = _skycoin.SKY_httphelper_Coins_MarshalJSON
 
-def SKY_coin_SortableTransactions_Swap(p0, p1, p2):
-    return _skycoin.SKY_coin_SortableTransactions_Swap(p0, p1, p2)
-SKY_coin_SortableTransactions_Swap = _skycoin.SKY_coin_SortableTransactions_Swap
+def SKY_httphelper_Coins_Value():
+    return _skycoin.SKY_httphelper_Coins_Value()
+SKY_httphelper_Coins_Value = _skycoin.SKY_httphelper_Coins_Value
 
-def SKY_coin_VerifyTransactionCoinsSpending(*args):
-    return _skycoin.SKY_coin_VerifyTransactionCoinsSpending(*args)
-SKY_coin_VerifyTransactionCoinsSpending = _skycoin.SKY_coin_VerifyTransactionCoinsSpending
+def SKY_httphelper_Hours_UnmarshalJSON(p1):
+    return _skycoin.SKY_httphelper_Hours_UnmarshalJSON(p1)
+SKY_httphelper_Hours_UnmarshalJSON = _skycoin.SKY_httphelper_Hours_UnmarshalJSON
 
-def SKY_coin_VerifyTransactionHoursSpending(*args):
-    return _skycoin.SKY_coin_VerifyTransactionHoursSpending(*args)
-SKY_coin_VerifyTransactionHoursSpending = _skycoin.SKY_coin_VerifyTransactionHoursSpending
+def SKY_httphelper_Hours_MarshalJSON():
+    return _skycoin.SKY_httphelper_Hours_MarshalJSON()
+SKY_httphelper_Hours_MarshalJSON = _skycoin.SKY_httphelper_Hours_MarshalJSON
+
+def SKY_httphelper_Hours_Value():
+    return _skycoin.SKY_httphelper_Hours_Value()
+SKY_httphelper_Hours_Value = _skycoin.SKY_httphelper_Hours_Value
 class api__RichlistParams(_object):
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, api__RichlistParams, name, value)
diff --git a/skycoin/skyerror.py b/skycoin/skyerror.py
deleted file mode 100644
index ff2406d5..00000000
--- a/skycoin/skyerror.py
+++ /dev/null
@@ -1,158 +0,0 @@
-SKY_ERROR = 0x7FFFFFFF
-SKY_BAD_HANDLE = 0x7F000001
-SKY_API_LOCKED = 0x7F000002
-SKY_OK = 0
-SKY_PKG_API = 0x01000000
-SKY_PKG_CIPHER = 0x02000000
-SKY_PKG_CLI = 0x03000000
-SKY_PKG_COIN = 0x04000000
-SKY_PKG_CONSENSUS = 0x05000000
-SKY_PKG_DAEMON = 0x06000000
-SKY_PKG_GUI = 0x07000000
-SKY_PKG_SKYCOIN = 0x08000000
-SKY_PKG_UTIL = 0x09000000
-SKY_PKG_VISOR = 0x0A000000
-SKY_PKG_WALLET = 0x0B000000
-SKY_ErrAddressInvalidLength = 0x02000000
-SKY_ErrAddressInvalidChecksum = 0x02000001
-SKY_ErrAddressInvalidVersion = 0x02000002
-SKY_ErrAddressInvalidPubKey = 0x02000003
-SKY_ErrAddressInvalidFirstByte = 0x02000004
-SKY_ErrAddressInvalidLastByte = 0x02000005
-SKY_ErrBufferUnderflow = 0x02000006
-SKY_ErrInvalidOmitEmpty = 0x02000007
-SKY_ErrInvalidLengthPubKey = 0x02000008
-SKY_ErrPubKeyFromNullSecKey = 0x02000009
-SKY_ErrPubKeyFromBadSecKey = 0x0200000A
-SKY_ErrInvalidLengthSecKey = 0x0200000B
-SKY_ErrECHDInvalidPubKey = 0x0200000C
-SKY_ErrECHDInvalidSecKey = 0x0200000D
-SKY_ErrInvalidLengthSig = 0x0200000E
-SKY_ErrInvalidLengthRipemd160 = 0x0200000F
-SKY_ErrInvalidLengthSHA256 = 0x02000010
-SKY_ErrInvalidBase58Char = 0x02000011
-SKY_ErrInvalidBase58String = 0x02000012
-SKY_ErrInvalidBase58Length = 0x02000013
-SKY_ErrInvalidHexLength = 0x02000014
-SKY_ErrInvalidBytesLength = 0x02000015
-SKY_ErrInvalidPubKey = 0x02000016
-SKY_ErrInvalidSecKey = 0x02000017
-SKY_ErrInvalidSigForPubKey = 0x02000018
-SKY_ErrInvalidSecKeyHex = 0x02000019
-SKY_ErrInvalidAddressForSig = 0x0200001A
-SKY_ErrInvalidHashForSig = 0x0200001B
-SKY_ErrPubKeyRecoverMismatch = 0x0200001C
-SKY_ErrInvalidSigInvalidPubKey = 0x0200001D
-SKY_ErrInvalidSigValidity = 0x0200001E
-SKY_ErrInvalidSigForMessage = 0x0200001F
-SKY_ErrInvalidSecKyVerification = 0x02000020
-SKY_ErrNullPubKeyFromSecKey = 0x02000021
-SKY_ErrInvalidDerivedPubKeyFromSecKey = 0x02000022
-SKY_ErrInvalidPubKeyFromHash = 0x02000023
-SKY_ErrPubKeyFromSecKeyMissmatch = 0x02000024
-SKY_ErrTemporaryInsufficientBalance = 0x03000000
-SKY_ErrAddress = 0x03000001
-SKY_ErrWalletName = 0x03000002
-SKY_ErrJSONMarshal = 0x03000003
-SKY_WalletLoadError = 0x03000004
-SKY_WalletSaveError = 0x03000005
-SKY_ErrAddEarnedCoinHoursAdditionOverflow = 0x04000000
-SKY_ErrUint64MultOverflow = 0x04000001
-SKY_ErrUint64AddOverflow = 0x04000002
-SKY_ErrUint32AddOverflow = 0x04000003
-SKY_ErrUint64OverflowsInt64 = 0x04000004
-SKY_ErrInt64UnderflowsUint64 = 0x04000005
-SKY_ErrPeerlistFull = 0x06000000
-SKY_ErrInvalidAddress = 0x06000001
-SKY_ErrNoLocalhost = 0x06000002
-SKY_ErrNotExternalIP = 0x06000003
-SKY_ErrPortTooLow = 0x06000004
-SKY_ErrBlacklistedAddress = 0x06000005
-SKY_ErrDisconnectReadFailed = 0x06000006
-SKY_ErrDisconnectWriteFailed = 0x06000007
-SKY_ErrDisconnectSetReadDeadlineFailed = 0x06000008
-SKY_ErrDisconnectInvalidMessageLength = 0x06000009
-SKY_ErrDisconnectMalformedMessage = 0x0600000A
-SKY_ErrDisconnectUnknownMessage = 0x0600000B
-SKY_ErrDisconnectUnexpectedError = 0x0600000C
-SKY_ErrConnectionPoolClosed = 0x0600000D
-SKY_ErrWriteQueueFull = 0x0600000E
-SKY_ErrNoReachableConnections = 0x0600000F
-SKY_ErrMaxDefaultConnectionsReached = 0x06000010
-SKY_ErrDisconnectInvalidVersion = 0x06000011
-SKY_ErrDisconnectIntroductionTimeout = 0x06000012
-SKY_ErrDisconnectVersionSendFailed = 0x06000013
-SKY_ErrDisconnectIsBlacklisted = 0x06000014
-SKY_ErrDisconnectSelf = 0x06000015
-SKY_ErrDisconnectConnectedTwice = 0x06000016
-SKY_ErrDisconnectIdle = 0x06000017
-SKY_ErrDisconnectNoIntroduction = 0x06000018
-SKY_ErrDisconnectIPLimitReached = 0x06000019
-SKY_ErrDisconnectOtherError = 0x0600001A
-SKY_ErrDisconnectMaxDefaultConnectionReached = 0x0600001B
-SKY_ErrDisconnectMaxOutgoingConnectionsReached = 0x0600001C
-SKY_ConnectionError = 0x0600001D
-SKY_ErrTxnNoFee = 0x09000000
-SKY_ErrTxnInsufficientFee = 0x09000001
-SKY_ErrTxnInsufficientCoinHours = 0x09000002
-SKY_ErrNegativeValue = 0x09000003
-SKY_ErrTooManyDecimals = 0x09000004
-SKY_ErrTooLarge = 0x09000005
-SKY_ErrEmptyDirectoryName = 0x09000006
-SKY_ErrDotDirectoryName = 0x09000007
-SKY_ErrHistoryDBCorrupted = 0x0A000000
-SKY_ErrUxOutNotExist = 0x0A000001
-SKY_ErrNoHeadBlock = 0x0A000002
-SKY_ErrMissingSignature = 0x0A000003
-SKY_ErrUnspentNotExist = 0x0A000004
-SKY_ErrVerifyStopped = 0x0A000005
-SKY_ErrCreateBucketFailed = 0x0A000000
-SKY_ErrBucketNotExist = 0x0A000006
-SKY_ErrTxnViolatesHardConstraint = 0x0A000007
-SKY_ErrTxnViolatesSoftConstraint = 0x0A000008
-SKY_ErrTxnViolatesUserConstraint = 0x0A000009
-SKY_ErrInsufficientBalance = 0x0B000000
-SKY_ErrInsufficientHours = 0x0B000001
-SKY_ErrZeroSpend = 0x0B000002
-SKY_ErrSpendingUnconfirmed = 0x0B000003
-SKY_ErrInvalidEncryptedField = 0x0B000004
-SKY_ErrWalletEncrypted = 0x0B000005
-SKY_ErrWalletNotEncrypted = 0x0B000006
-SKY_ErrMissingPassword = 0x0B000007
-SKY_ErrMissingEncrypt = 0x0B000008
-SKY_ErrInvalidPassword = 0x0B000009
-SKY_ErrMissingSeed = 0x0B00000A
-SKY_ErrMissingAuthenticated = 0x0B00000B
-SKY_ErrWrongCryptoType = 0x0B00000C
-SKY_ErrWalletNotExist = 0x0B00000D
-SKY_ErrSeedUsed = 0x0B00000E
-SKY_ErrWalletAPIDisabled = 0x0B00000F
-SKY_ErrSeedAPIDisabled = 0x0B000010
-SKY_ErrWalletNameConflict = 0x0B000011
-SKY_ErrInvalidHoursSelectionMode = 0x0B000012
-SKY_ErrInvalidHoursSelectionType = 0x0B000013
-SKY_ErrUnknownAddress = 0x0B000014
-SKY_ErrUnknownUxOut = 0x0B000015
-SKY_ErrNoUnspents = 0x0B000016
-SKY_ErrNullChangeAddress = 0x0B000017
-SKY_ErrMissingTo = 0x0B000018
-SKY_ErrZeroCoinsTo = 0x0B000019
-SKY_ErrNullAddressTo = 0x0B00001A
-SKY_ErrDuplicateTo = 0x0B00001B
-SKY_ErrMissingWalletID = 0x0B00001C
-SKY_ErrIncludesNullAddress = 0x0B00001D
-SKY_ErrDuplicateAddresses = 0x0B00001E
-SKY_ErrZeroToHoursAuto = 0x0B00001F
-SKY_ErrMissingModeAuto = 0x0B000020
-SKY_ErrInvalidHoursSelMode = 0x0B000021
-SKY_ErrInvalidModeManual = 0x0B000022
-SKY_ErrInvalidHoursSelType = 0x0B000023
-SKY_ErrMissingShareFactor = 0x0B000024
-SKY_ErrInvalidShareFactor = 0x0B000025
-SKY_ErrShareFactorOutOfRange = 0x0B000026
-SKY_ErrWalletConstraint = 0x0B000027
-SKY_ErrDuplicateUxOuts = 0x0B000028
-SKY_ErrUnknownWalletID = 0x0B000029
-SKY_ErrSHA256orMissingPassword = 0x0B00002A
-SKY_ErrSHA256LenghtDataOverflowMaxUint32 = 0x0B00002B
-SKY_ErrVerifySignatureInvalidPubkeysLength = 0x0b000036
diff --git a/swig/pyskycoin_wrap.c b/swig/pyskycoin_wrap.c
index e0447994..55a0174e 100644
--- a/swig/pyskycoin_wrap.c
+++ b/swig/pyskycoin_wrap.c
@@ -4167,6 +4167,22 @@ SWIG_From_long_SS_long  (long long value)
 #endif
 
 
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = (unsigned int)(v);
+    }
+  }  
+  return res;
+}
+
+
 SWIGINTERN int
 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
 {
@@ -4197,22 +4213,6 @@ SWIG_From_unsigned_SS_char  (unsigned char value)
   return SWIG_From_unsigned_SS_long  (value);
 }
 
-
-SWIGINTERN int
-SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
-{
-  unsigned long v;
-  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
-  if (SWIG_IsOK(res)) {
-    if ((v > UINT_MAX)) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = (unsigned int)(v);
-    }
-  }  
-  return res;
-}
-
 SWIGINTERN int cipher__Address___eq__(cipher__Address *self,cipher__Address *a){
 		if( self->Version == a->Version ){
 			return memcmp(self->Key, a->Key, sizeof(a->Key)) == 0;
@@ -9066,138 +9066,86 @@ SWIGINTERN PyObject *GoSlice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObje
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewWalletResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  GoUint64 arg2 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  Transactions__Handle arg4 ;
-  FeeCalculator *arg5 = (FeeCalculator *) 0 ;
-  Block__Handle *arg6 = (Block__Handle *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  FeeCalculator temp5 ;
-  Handle temp6 ;
+  Wallet__Handle arg1 ;
+  WalletResponse__Handle *arg2 = (WalletResponse__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
   GoUint32 result;
   
   {
-    arg6 = &temp6;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_coin_NewBlock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewWalletResponse",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewBlock" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
-  }
-  {
-    SWIG_AsVal_long(obj3, (long*)&arg4);
-  }
-  {
-    if (!PyCallable_Check(obj4)) SWIG_fail;
-    temp5.callback = _WrapperFeeCalculator;
-    temp5.context = obj4;
-    arg5 = &temp5;
-  }
-  result = (GoUint32)SKY_coin_NewBlock(arg1,arg2,(unsigned char (*)[32])arg3,arg4,arg5,arg6);
+  result = (GoUint32)SKY_api_NewWalletResponse(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
-  }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_SignedBlock_VerifySignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  coin__SignedBlock *arg1 = (coin__SignedBlock *) 0 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SignedBlock_VerifySignature",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__SignedBlock, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SignedBlock_VerifySignature" "', argument " "1"" of type '" "coin__SignedBlock *""'"); 
-  }
-  arg1 = (coin__SignedBlock *)(argp1);
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
-  result = (GoUint32)SKY_coin_SignedBlock_VerifySignature(arg1,(unsigned char (*)[33])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewGenesisBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_GenerateAddressesInFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoString arg1 ;
   GoUint64 arg2 ;
-  GoUint64 arg3 ;
-  Block__Handle *arg4 = (Block__Handle *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  PasswordReader__Handle arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
   unsigned long long val2 ;
   int ecode2 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  Handle temp4 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    arg4 = &temp4;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewGenesisBlock",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GenerateAddressesInFile",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateAddressesInFile', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  arg1 = (cipher__Address *)(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "2"" of type '" "GoUint64""'");
   } 
   arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  result = (GoUint32)SKY_coin_NewGenesisBlock(arg1,arg2,arg3,arg4);
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle,  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'");
+    } else {
+      arg3 = *((PasswordReader__Handle *)(argp3));
+    }
+  }
+  result = (GoUint32)SKY_cli_GenerateAddressesInFile(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -9205,82 +9153,111 @@ SWIGINTERN PyObject *_wrap_SKY_coin_NewGenesisBlock(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoSlice arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashHeader",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJSON",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJSON', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_coin_Block_HashHeader(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_cli_FormatAddressesAsJSON(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_PreHashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJoinedArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoSlice arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_PreHashHeader",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJoinedArray",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJoinedArray', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_coin_Block_PreHashHeader(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_cli_FormatAddressesAsJoinedArray(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_AddressesToStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  GoSlice arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Time",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_AddressesToStrings",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddressesToStrings', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_coin_Block_Time(arg1,arg2);
+  result = (GoUint32)SKY_cli_AddressesToStrings(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -9288,26 +9265,41 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Block_Time(PyObject *SWIGUNUSEDPARM(self), P
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_Seq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  GoString arg1 ;
+  wallet__Entry *arg2 = (wallet__Entry *) 0 ;
+  ReadableEntry__Handle *arg3 = (ReadableEntry__Handle *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Seq",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewReadableEntry",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewReadableEntry', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Block_Seq(arg1,arg2);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewReadableEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); 
+  }
+  arg2 = (wallet__Entry *)(argp2);
+  result = (GoUint32)SKY_wallet_NewReadableEntry(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -9315,194 +9307,123 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Block_Seq(PyObject *SWIGUNUSEDPARM(self), Py
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoString arg1 ;
+  ReadableWallet__Handle *arg2 = (ReadableWallet__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashBody",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_LoadReadableWallet",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_LoadReadableWallet', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Block_HashBody(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_wallet_LoadReadableWallet(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  ReadableWallet__Handle arg1 ;
+  GoString arg2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Size",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Save",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Block_Size(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Save', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  result = (GoUint32)SKY_wallet_ReadableWallet_Save(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  ReadableWallet__Handle arg1 ;
+  GoString arg2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_String",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Load",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Block_String(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Load', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  result = (GoUint32)SKY_wallet_ReadableWallet_Load(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Block_GetTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  Transaction__Handle *arg3 = (Transaction__Handle *) 0 ;
-  GoUint8 *arg4 = (GoUint8 *) 0 ;
-  Handle temp3 ;
-  GoUint8 temp4 ;
-  int res4 = SWIG_TMPOBJ ;
+  ReadableWallet__Handle arg1 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_GetTransaction",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_ReadableWallet_Erase",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
-  }
-  result = (GoUint32)SKY_coin_Block_GetTransaction(arg1,(unsigned char (*)[32])arg2,arg3,arg4);
+  result = (GoUint32)SKY_wallet_ReadableWallet_Erase(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
-  if (SWIG_IsTmpObj(res4)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewBlockHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_logging_EnableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  GoUint64 arg3 ;
-  GoUint64 arg4 ;
-  BlockBody__Handle arg5 ;
-  coin__BlockHeader *arg6 = (coin__BlockHeader *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  unsigned long long val4 ;
-  int ecode4 = 0 ;
-  void *argp6 = 0 ;
-  int res6 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_coin_NewBlockHeader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewBlockHeader" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
-  }
-  arg1 = (coin__BlockHeader *)(argp1);
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
-  }
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewBlockHeader" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_NewBlockHeader" "', argument " "4"" of type '" "GoUint64""'");
-  } 
-  arg4 = (GoUint64)(val4);
-  {
-    SWIG_AsVal_long(obj4, (long*)&arg5);
-  }
-  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_coin_NewBlockHeader" "', argument " "6"" of type '" "coin__BlockHeader *""'"); 
-  }
-  arg6 = (coin__BlockHeader *)(argp6);
-  result = (GoUint32)SKY_coin_NewBlockHeader(arg1,(unsigned char (*)[32])arg2,arg3,arg4,arg5,arg6);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_EnableColors")) SWIG_fail;
+  result = (GoUint32)SKY_logging_EnableColors();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -9510,31 +9431,12 @@ SWIGINTERN PyObject *_wrap_SKY_coin_NewBlockHeader(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_logging_DisableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockHeader_Hash",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Hash" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
-  }
-  arg1 = (coin__BlockHeader *)(argp1);
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
-  }
-  result = (GoUint32)SKY_coin_BlockHeader_Hash(arg1,(unsigned char (*)[32])arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_DisableColors")) SWIG_fail;
+  result = (GoUint32)SKY_logging_DisableColors();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -9542,94 +9444,88 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_logging_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoSlice_ temp2 ;
-  PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_Bytes",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Bytes" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
-  }
-  arg1 = (coin__BlockHeader *)(argp1);
-  result = (GoUint32)SKY_coin_BlockHeader_Bytes(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_Disable")) SWIG_fail;
+  result = (GoUint32)SKY_logging_Disable();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoString temp2 ;
+  Transaction__Handle arg1 ;
+  GoUint64 arg2 ;
+  GoUint32 arg3 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFee",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_String",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_String" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg1 = (coin__BlockHeader *)(argp1);
-  result = (GoUint32)SKY_coin_BlockHeader_String(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "3"" of type '" "GoUint32""'");
+  } 
+  arg3 = (GoUint32)(val3);
+  result = (GoUint32)SKY_fee_VerifyTransactionFee(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFeeForHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  BlockBody__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoUint64 arg1 ;
+  GoUint64 arg2 ;
+  GoUint32 arg3 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockBody_Hash",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
-  }
-  result = (GoUint32)SKY_coin_BlockBody_Hash(arg1,(unsigned char (*)[32])arg2);
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFeeForHours",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "3"" of type '" "GoUint32""'");
+  } 
+  arg3 = (GoUint32)(val3);
+  result = (GoUint32)SKY_fee_VerifyTransactionFeeForHours(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -9637,30 +9533,39 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  BlockBody__Handle *arg1 = (BlockBody__Handle *) 0 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  Handle temp1 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  GoUint64 arg1 ;
+  GoUint32 arg2 ;
+  GoUint64 *arg3 = (GoUint64 *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  GoUint64 temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg1 = &temp1;
+    temp3 = 0;
+    arg3 = &temp3;
   }
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_BlockBody_Size")) SWIG_fail;
-  result = (GoUint32)SKY_coin_BlockBody_Size(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RequiredFee",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RequiredFee" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RequiredFee" "', argument " "2"" of type '" "GoUint32""'");
+  } 
+  arg2 = (GoUint32)(val2);
+  result = (GoUint32)SKY_fee_RequiredFee(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
-  }
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
   }
   return resultobj;
 fail:
@@ -9668,29 +9573,39 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Size(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_RemainingHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  BlockBody__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  GoUint64 arg1 ;
+  GoUint32 arg2 ;
+  GoUint64 *arg3 = (GoUint64 *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  GoUint64 temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockBody_Bytes",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp3 = 0;
+    arg3 = &temp3;
   }
-  result = (GoUint32)SKY_coin_BlockBody_Bytes(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RemainingHours",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RemainingHours" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RemainingHours" "', argument " "2"" of type '" "GoUint32""'");
+  } 
+  arg2 = (GoUint32)(val2);
+  result = (GoUint32)SKY_fee_RemainingHours(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
   }
   return resultobj;
 fail:
@@ -9698,14 +9613,16 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  Transaction__Handle arg2 ;
+  Transaction__Handle arg1 ;
+  GoUint64 arg2 ;
   coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  GoUint64 *arg4 = (GoUint64 *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
   GoSlice_ temp3 ;
+  GoUint64 temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
@@ -9716,142 +9633,140 @@ SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDP
     temp3.cap = 0;
     arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_CreateUnspents",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspents" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+  {
+    temp4 = 0;
+    arg4 = &temp4;
   }
-  arg1 = (coin__BlockHeader *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_TransactionFee",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_CreateUnspents(arg1,arg2,arg3);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_TransactionFee" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_fee_TransactionFee(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
     free( (void*)arg3->data );
   }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 ));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee(PyObject *self, PyObject *args) {
   Py_ssize_t argc;
-  PyObject *argv[3] = {
+  PyObject *argv[4] = {
     0
   };
   Py_ssize_t ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
   argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0);
-    _v = SWIG_CheckState(res);
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
     if (_v) {
       {
-        _v = PyInt_Check(argv[1]) ? 1 : 0;
+        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_SKY_coin_CreateUnspents__SWIG_0(self, args);
+        return _wrap_SKY_fee_TransactionFee__SWIG_1(self, args);
       }
     }
   }
-  if (argc == 2) {
+  if (argc == 3) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0);
-    _v = SWIG_CheckState(res);
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
     if (_v) {
       {
-        _v = PyInt_Check(argv[1]) ? 1 : 0;
+        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_SKY_coin_CreateUnspents__SWIG_1(self, args);
+        {
+          _v = PyList_Check(argv[2]) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_SKY_fee_TransactionFee__SWIG_0(self, args);
+        }
       }
     }
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_CreateUnspents'.\n"
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_fee_TransactionFee'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin_UxOutArray *)\n"
-    "    SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin__UxArray *)\n");
+    "    wrap_SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin_UxOutArray *,GoUint64 *)\n"
+    "    SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin__UxArray *,GoUint64 *)\n");
   return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
-  Transaction__Handle arg2 ;
-  GoInt arg3 ;
-  coin__UxOut *arg4 = (coin__UxOut *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
+  Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_CreateUnspent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspent" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
-  }
-  arg1 = (coin__BlockHeader *)(argp1);
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_CreateUnspent" "', argument " "3"" of type '" "GoInt""'");
-  } 
-  arg3 = (GoInt)(val3);
-  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SKY_coin_CreateUnspent" "', argument " "4"" of type '" "coin__UxOut *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_JsonEncode_Handle",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg4 = (coin__UxOut *)(argp4);
-  result = (GoUint32)SKY_coin_CreateUnspent(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_JsonEncode_Handle(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  coin__Block **arg2 = (coin__Block **) 0 ;
-  coin__Block *temp2 ;
+  Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = NULL;
+    temp2 = 0;
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockObject",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Progress_GetCurrent",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_GetBlockObject(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Progress_GetCurrent(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Block, 0 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -9859,25 +9774,26 @@ SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Block__Handle arg1 ;
-  BlockBody__Handle *arg2 = (BlockBody__Handle *) 0 ;
-  Handle temp2 ;
+  Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
+    temp2 = 0;
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockBody",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadSeq",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_GetBlockBody(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Block_GetHeadSeq(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -9885,25 +9801,28 @@ SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockBody(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewEmptyBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  Block__Handle *arg2 = (Block__Handle *) 0 ;
-  Handle temp2 ;
+  Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_NewEmptyBlock",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadHash",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_NewEmptyBlock(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Block_GetHeadHash(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -9911,23 +9830,28 @@ SWIGINTERN PyObject *_wrap_SKY_coin_NewEmptyBlock(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString_ *arg1 = (GoString_ *) 0 ;
-  GoString temp1 ;
+  Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.p = NULL;
-    temp1.n = 0;
-    arg1 = (GoString_ *)&temp1;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_bip39_NewDefaultMnemomic")) SWIG_fail;
-  result = (GoUint32)SKY_bip39_NewDefaultMnemomic(arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetPreviousBlockHash",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_Handle_Block_GetPreviousBlockHash(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
-    free( (void*)arg1->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -9935,33 +9859,34 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoInt arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  long long val1 ;
-  int ecode1 = 0 ;
-  GoSlice_ temp2 ;
+  Handle arg1 ;
+  GoUint64 arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewEntropy",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_bip39_NewEntropy" "', argument " "1"" of type '" "GoInt""'");
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Blocks_GetAt",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Blocks_GetAt" "', argument " "2"" of type '" "GoUint64""'");
   } 
-  arg1 = (GoInt)(val1);
-  result = (GoUint32)SKY_bip39_NewEntropy(arg1,arg2);
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_Handle_Blocks_GetAt(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -9969,36 +9894,26 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewMnemonic",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Blocks_GetCount",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_NewMnemonic', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_bip39_NewMnemonic(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Blocks_GetCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -10006,36 +9921,26 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_MnemonicToByteArray",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Connections_GetCount",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_MnemonicToByteArray', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_bip39_MnemonicToByteArray(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Connections_GetCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -10043,34 +9948,27 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoUint8 temp2 ;
+  Strings__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
   int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_IsMnemonicValid",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_GetCount",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_IsMnemonicValid', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_bip39_IsMnemonicValid(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Strings_GetCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
   } else {
     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -10078,61 +9976,55 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  Client__Handle *arg2 = (Client__Handle *) 0 ;
-  Handle temp2 ;
+  Strings__Handle arg1 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_Sort",&obj0)) SWIG_fail;
   {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewClient",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewClient', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_NewClient(arg1,arg2);
+  result = (GoUint32)SKY_Handle_Strings_Sort(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Strings__Handle arg1 ;
+  GoInt arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CSRF",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Strings_GetAt",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_CSRF(arg1,arg2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Strings_GetAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_Handle_Strings_GetAt(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
   return resultobj;
 fail:
@@ -10140,25 +10032,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), P
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Version",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletDir",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_Version(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_Client_GetWalletDir(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10166,25 +10061,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  WalletResponse__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Outputs",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletFileName",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_Outputs(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_Client_GetWalletFileName(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10192,38 +10090,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  WalletResponse__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForAddresses",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletLabel",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForAddresses', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_Client_OutputsForAddresses(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_Client_GetWalletLabel(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10231,38 +10119,33 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFullPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  WalletResponse__Handle arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForHashes",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_Client_GetWalletFullPath",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForHashes', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
-  result = (GoUint32)SKY_api_Client_OutputsForHashes(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_Client_GetWalletFullPath(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
   return resultobj;
 fail:
@@ -10270,10 +10153,10 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
+  Wallet__Handle arg1 ;
+  GoStringMap_ *arg2 = (GoStringMap_ *) 0 ;
   Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -10281,11 +10164,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(se
   {
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CoinSupply",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletMeta",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_CoinSupply(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_GetWalletMeta(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
@@ -10296,37 +10179,27 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Wallet__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockByHash",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletEntriesCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_BlockByHash', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_BlockByHash(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_GetWalletEntriesCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -10334,34 +10207,27 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoUint64 arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  Handle temp3 ;
+  WalletResponse__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockBySeq",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletResponseEntriesCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_BlockBySeq" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_api_Client_BlockBySeq(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_Client_GetWalletResponseEntriesCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -10369,73 +10235,94 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Blocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Wallet__Handle arg1 ;
+  GoUint32 arg2 ;
+  cipher__Address *arg3 = (cipher__Address *) 0 ;
+  cipher__PubKey *arg4 = (cipher__PubKey *) 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Handle_WalletGetEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   {
-    arg3 = &temp3;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Blocks",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "2"" of type '" "GoUint32""'");
+  } 
+  arg2 = (GoUint32)(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "3"" of type '" "cipher__Address *""'"); 
   }
+  arg3 = (cipher__Address *)(argp3);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Blocks', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj3, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg4 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_Blocks(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_WalletGetEntry(arg1,arg2,arg3,(unsigned char (*)[33])arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoUint64 arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  unsigned long long val2 ;
+  WalletResponse__Handle arg1 ;
+  GoUint32 arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString_ *arg4 = (GoString_ *) 0 ;
+  unsigned int val2 ;
   int ecode2 = 0 ;
-  Handle temp3 ;
+  GoString temp3 ;
+  GoString temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_LastBlocks",&obj0,&obj1)) SWIG_fail;
+  {
+    temp4.p = NULL;
+    temp4.n = 0;
+    arg4 = (GoString_ *)&temp4;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletResponseGetEntry",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_LastBlocks" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletResponseGetEntry" "', argument " "2"" of type '" "GoUint32""'");
   } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_api_Client_LastBlocks(arg1,arg2,arg3);
+  arg2 = (GoUint32)(val2);
+  result = (GoUint32)SKY_api_Handle_WalletResponseGetEntry(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
+    free( (void*)arg4->p );
   }
   return resultobj;
 fail:
@@ -10443,25 +10330,27 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseIsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  WalletResponse__Handle arg1 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainMetadata",&obj0)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseIsEncrypted",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_BlockchainMetadata(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_WalletResponseIsEncrypted(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -10469,25 +10358,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetCryptoType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  WalletResponse__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainProgress",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseGetCryptoType",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_BlockchainProgress(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_WalletResponseGetCryptoType(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10495,51 +10387,41 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Balance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  Wallets__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_Balance",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletsResponseGetCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Balance', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_Balance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); 
-  }
-  arg3 = (wallet__BalancePair *)(argp3);
-  result = (GoUint32)SKY_api_Client_Balance(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_WalletsResponseGetCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
+  Wallets__Handle arg1 ;
+  GoUint32 arg2 ;
+  WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
   Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
@@ -10548,21 +10430,16 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self),
   {
     arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UxOut",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletsResponseGetAt",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UxOut', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_UxOut(arg1,arg2,arg3);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletsResponseGetAt" "', argument " "2"" of type '" "GoUint32""'");
+  } 
+  arg2 = (GoUint32)(val2);
+  result = (GoUint32)SKY_api_Handle_WalletsResponseGetAt(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
@@ -10573,37 +10450,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressUxOuts",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletFolderAddress",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressUxOuts', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_AddressUxOuts(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_GetWalletFolderAddress(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10611,37 +10479,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ;
-  Handle temp3 ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Wallet",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletSeed",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Wallet', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_Wallet(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Handle_GetWalletSeed(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10649,25 +10508,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Wallets__Handle *arg2 = (Wallets__Handle *) 0 ;
-  Handle temp2 ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Wallets",&obj0)) SWIG_fail;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletLastSeed",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_Wallets(arg1,arg2);
+  result = (GoUint32)SKY_api_Handle_GetWalletLastSeed(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -10675,58 +10537,50 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateUnencryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoInt arg4 ;
-  WalletResponse__Handle *arg5 = (WalletResponse__Handle *) 0 ;
-  long long val4 ;
-  int ecode4 = 0 ;
-  Handle temp5 ;
+  BuildInfo_Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString_ *arg4 = (GoString_ *) 0 ;
+  GoString temp2 ;
+  GoString temp3 ;
+  GoString temp4 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   GoUint32 result;
   
   {
-    arg5 = &temp5;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_CreateUnencryptedWallet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    temp4.p = NULL;
+    temp4.n = 0;
+    arg4 = (GoString_ *)&temp4;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetBuildInfoData",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode4 = SWIG_AsVal_long_SS_long(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_CreateUnencryptedWallet" "', argument " "4"" of type '" "GoInt""'");
-  } 
-  arg4 = (GoInt)(val4);
-  result = (GoUint32)SKY_api_Client_CreateUnencryptedWallet(arg1,arg2,arg3,arg4,arg5);
+  result = (GoUint32)SKY_api_Handle_GetBuildInfoData(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
+    free( (void*)arg4->p );
   }
   return resultobj;
 fail:
@@ -10734,28 +10588,15 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateUnencryptedWallet(PyObject *SWIG
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
+  Wallet__Handle arg1 ;
   GoString arg2 ;
-  GoString arg3 ;
-  GoString arg4 ;
-  GoInt arg5 ;
-  WalletResponse__Handle *arg6 = (WalletResponse__Handle *) 0 ;
-  long long val5 ;
-  int ecode5 = 0 ;
-  Handle temp6 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
   GoUint32 result;
   
-  {
-    arg6 = &temp6;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_api_Client_CreateEncryptedWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_AddPrivateKey",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -10764,244 +10605,138 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUN
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKey', expecting string");
     }
     (&arg2)->p = buffer;
     (&arg2)->n = size - 1;
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
-    }
-    (&arg4)->p = buffer;
-    (&arg4)->n = size - 1;
-  }
-  ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SKY_api_Client_CreateEncryptedWallet" "', argument " "5"" of type '" "GoInt""'");
-  } 
-  arg5 = (GoInt)(val5);
-  result = (GoUint32)SKY_api_Client_CreateEncryptedWallet(arg1,arg2,arg3,arg4,arg5,arg6);
+  result = (GoUint32)SKY_cli_AddPrivateKey(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NewWalletAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKeyToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
+  GoString arg1 ;
   GoString arg2 ;
-  GoInt arg3 ;
-  GoString arg4 ;
-  Strings__Handle *arg5 = (Strings__Handle *) 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
-  Handle temp5 ;
+  PasswordReader__Handle arg3 ;
+  void *argp3 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_AddPrivateKeyToFile",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    arg5 = &temp5;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_NewWalletAddress",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string");
     }
     (&arg2)->p = buffer;
     (&arg2)->n = size - 1;
   }
-  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_api_Client_NewWalletAddress" "', argument " "3"" of type '" "GoInt""'");
-  } 
-  arg3 = (GoInt)(val3);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string");
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle,  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'");
+    } else {
+      arg3 = *((PasswordReader__Handle *)(argp3));
     }
-    (&arg4)->p = buffer;
-    (&arg4)->n = size - 1;
   }
-  result = (GoUint32)SKY_api_Client_NewWalletAddress(arg1,arg2,arg3,arg4,arg5);
+  result = (GoUint32)SKY_cli_AddPrivateKeyToFile(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
+  Transaction__Handle *arg1 = (Transaction__Handle *) 0 ;
+  Handle temp1 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletBalance",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg1 = &temp1;
   }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transaction")) SWIG_fail;
+  result = (GoUint32)SKY_coin_Create_Transaction(arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletBalance', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_WalletBalance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); 
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
-  arg3 = (wallet__BalancePair *)(argp3);
-  result = (GoUint32)SKY_api_Client_WalletBalance(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Spend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoUint64 arg4 ;
-  GoString arg5 ;
-  SpendResult_Handle *arg6 = (SpendResult_Handle *) 0 ;
-  unsigned long long val4 ;
-  int ecode4 = 0 ;
-  void *argp6 = 0 ;
-  int res6 = 0 ;
+  Transaction__Handle arg1 ;
+  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_api_Client_Spend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Copy",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
+  result = (GoUint32)SKY_coin_Transaction_Copy(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
-  }
-  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_Spend" "', argument " "4"" of type '" "GoUint64""'");
-  } 
-  arg4 = (GoUint64)(val4);
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
-    }
-    (&arg5)->p = buffer;
-    (&arg5)->n = size - 1;
-  }
-  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_SpendResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_api_Client_Spend" "', argument " "6"" of type '" "SpendResult_Handle *""'"); 
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
-  arg6 = (SpendResult_Handle *)(argp6);
-  result = (GoUint32)SKY_api_Client_Spend(arg1,arg2,arg3,arg4,arg5,arg6);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ;
-  Handle temp2 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  coin__Transaction **arg2 = (coin__Transaction **) 0 ;
+  coin__Transaction *temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
+    temp2 = NULL;
     arg2 = &temp2;
   }
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CreateTransaction",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetTransactionObject",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_CreateTransaction(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_GetTransactionObject(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Transaction, 0 ));
   }
   return resultobj;
 fail:
@@ -11009,41 +10744,26 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetInputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_UpdateWallet",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetInputs",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_UpdateWallet(arg1,arg2,arg3);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetInputs" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_coin_Transaction_ResetInputs(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -11051,25 +10771,27 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  Transaction__Handle arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_WalletFolderName",&obj0)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetInputsCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_WalletFolderName(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transaction_GetInputsCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
   }
   return resultobj;
 fail:
@@ -11077,128 +10799,101 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NewSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
+  Transaction__Handle arg1 ;
   GoInt arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
   long long val2 ;
   int ecode2 = 0 ;
-  GoString temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NewSeed",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetInputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_NewSeed" "', argument " "2"" of type '" "GoInt""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetInputAt" "', argument " "2"" of type '" "GoInt""'");
   } 
   arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_api_Client_NewSeed(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Transaction_GetInputAt(arg1,arg2,(unsigned char (*)[32])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoString_ *arg4 = (GoString_ *) 0 ;
-  GoString temp4 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp4.p = NULL;
-    temp4.n = 0;
-    arg4 = (GoString_ *)&temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletSeed",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetInputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetInputAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_WalletSeed(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_coin_Transaction_SetInputAt(arg1,arg2,(unsigned char (*)[32])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
-    free( (void*)arg4->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnection",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetOutputsCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NetworkConnection', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_api_Client_NetworkConnection(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_GetOutputsCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
   }
   return resultobj;
 fail:
@@ -11206,94 +10901,99 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  api__NetworkConnectionsFilter *arg2 = (api__NetworkConnectionsFilter *) 0 ;
-  Handle *arg3 = (Handle *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnections",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_NetworkConnections" "', argument " "2"" of type '" "api__NetworkConnectionsFilter *""'"); 
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); 
   }
-  arg2 = (api__NetworkConnectionsFilter *)(argp2);
-  result = (GoUint32)SKY_api_Client_NetworkConnections(arg1,arg2,arg3);
+  arg3 = (coin__TransactionOutput *)(argp3);
+  result = (GoUint32)SKY_coin_Transaction_GetOutputAt(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkDefaultPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkDefaultPeers",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_NetworkDefaultPeers(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); 
   }
+  arg3 = (coin__TransactionOutput *)(argp3);
+  result = (GoUint32)SKY_coin_Transaction_SetOutputAt(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Transaction__Handle arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkTrustedPeers",&obj0)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetSignaturesCount",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_NetworkTrustedPeers(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transaction_GetSignaturesCount(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
   }
   return resultobj;
 fail:
@@ -11301,244 +11001,203 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkExchangedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkExchangedPeers",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_NetworkExchangedPeers(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetSignatureAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Transaction_GetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_PendingTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_PendingTransactions",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_PendingTransactions(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetSignatureAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Transaction_SetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushSignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transaction",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushSignature",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transaction', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_Transaction(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_PushSignature(arg1,(unsigned char (*)[65])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transactions",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetOutputs",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transactions', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_Client_Transactions(arg1,arg2,arg3);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetOutputs" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_coin_Transaction_ResetOutputs(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_ConfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetSignatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  GoInt arg2 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_ConfirmedTransactions",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetSignatures",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_ConfirmedTransactions', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_Client_ConfirmedTransactions(arg1,arg2,arg3);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetSignatures" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_coin_Transaction_ResetSignatures(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_UnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoSlice arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnconfirmedTransactions",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Verify",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnconfirmedTransactions', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_Client_UnconfirmedTransactions(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_Verify(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Transaction__Handle arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString temp3 ;
+  Transaction__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_VerifyInput",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
-  }
-  result = (GoUint32)SKY_api_Client_InjectTransaction(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_VerifyInput(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -11546,66 +11205,82 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_ResendUnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    arg2 = &temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_ResendUnconfirmedTransactions",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(self, args);
+    }
   }
-  result = (GoUint32)SKY_api_Client_ResendUnconfirmedTransactions(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_0(self, args);
+      }
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_VerifyInput'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin_UxOutArray *)\n"
+    "    SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString temp3 ;
+  Transaction__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoUint16 *arg3 = (GoUint16 *) 0 ;
+  GoUint16 temp3 ;
+  int res3 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_RawTransaction",&obj0,&obj1)) SWIG_fail;
+  arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushInput",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_RawTransaction', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_RawTransaction(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_PushInput(arg1,(unsigned char (*)[32])arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+  if (SWIG_IsTmpObj(res3)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags));
   }
   return resultobj;
 fail:
@@ -11613,155 +11288,198 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_TransactionOutput_UxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
-  Handle temp3 ;
+  coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_TransactionOutput_UxID",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_TransactionOutput_UxID" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); 
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressTransactions",&obj0,&obj1)) SWIG_fail;
+  arg1 = (coin__TransactionOutput *)(argp1);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressTransactions', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_AddressTransactions(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_TransactionOutput_UxID(arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Richlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  api__RichlistParams *arg2 = (api__RichlistParams *) 0 ;
-  Handle *arg3 = (Handle *) 0 ;
+  Transaction__Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  GoUint64 arg3 ;
+  GoUint64 arg4 ;
   void *argp2 = 0 ;
   int res2 = 0 ;
-  Handle temp3 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  unsigned long long val4 ;
+  int ecode4 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Richlist",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_Transaction_PushOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_Richlist" "', argument " "2"" of type '" "api__RichlistParams *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
-  arg2 = (api__RichlistParams *)(argp2);
-  result = (GoUint32)SKY_api_Client_Richlist(arg1,arg2,arg3);
+  arg2 = (cipher__Address *)(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "4"" of type '" "GoUint64""'");
+  } 
+  arg4 = (GoUint64)(val4);
+  result = (GoUint32)SKY_coin_Transaction_PushOutput(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  Transaction__Handle arg1 ;
+  GoSlice arg2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SignInputs",&obj0,&obj1)) SWIG_fail;
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_AddressCount",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_Transaction_SignInputs', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_api_Client_AddressCount(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transaction_SignInputs(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_UnloadWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnloadWallet",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnloadWallet', expecting string");
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        char* buffer = 0;
+        size_t size = 0;
+        int res = SWIG_AsCharPtrAndSize( argv[1], &buffer, &size, 0 );
+        _v = SWIG_IsOK(res) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_Transaction_SignInputs__SWIG_1(self, args);
+      }
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_api_Client_UnloadWallet(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_Transaction_SignInputs__SWIG_0(self, args);
+      }
+    }
+  }
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_SignInputs'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_Transaction_SignInputs(Transaction__Handle,cipher_SecKeys *)\n"
+    "    SKY_coin_Transaction_SignInputs(Transaction__Handle,GoSlice)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_Health(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
-  Handle temp2 ;
+  Transaction__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Health",&obj0)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Size",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Client_Health(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transaction_Size(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -11769,99 +11487,65 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Health(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_EncryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ;
-  Handle temp4 ;
+  Transaction__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_EncryptWallet",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_Hash",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_EncryptWallet(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_coin_Transaction_Hash(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SizeHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ;
-  Handle temp4 ;
+  Transaction__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_DecryptWallet",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SizeHash",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
-  result = (GoUint32)SKY_api_Client_DecryptWallet(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_coin_Transaction_SizeHash(arg1,arg2,(unsigned char (*)[32])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -11869,25 +11553,29 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewWalletResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  WalletResponse__Handle *arg2 = (WalletResponse__Handle *) 0 ;
-  Handle temp2 ;
+  Transaction__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewWalletResponse",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxID",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_NewWalletResponse(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transaction_TxID(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -11895,38 +11583,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewWalletResponse(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxIDHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Transaction__Handle arg1 ;
-  GoSlice arg2 ;
-  CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ;
-  Handle temp3 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreateTransactionResponse",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxIDHex",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreateTransactionResponse', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_NewCreateTransactionResponse(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_TxIDHex(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -11934,104 +11612,75 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUN
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_UpdateHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   Transaction__Handle arg1 ;
-  GoSlice arg2 ;
-  CreatedTransaction__Handle *arg3 = (CreatedTransaction__Handle *) 0 ;
-  Handle temp3 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransaction",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_UpdateHeader",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreatedTransaction', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_api_NewCreatedTransaction(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_UpdateHeader(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_CreatedTransaction_ToTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_HashInner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  CreatedTransaction__Handle arg1 ;
-  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
-  Handle temp2 ;
+  Transaction__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_CreatedTransaction_ToTransaction",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_HashInner",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_CreatedTransaction_ToTransaction(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Transaction_HashInner(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  CreatedTransactionOutput__Handle *arg3 = (CreatedTransactionOutput__Handle *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  Handle temp3 ;
+  Transaction__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransactionOutput",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionOutput" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); 
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  arg1 = (coin__TransactionOutput *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Serialize",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_NewCreatedTransactionOutput(arg1,(unsigned char (*)[32])arg2,arg3);
+  result = (GoUint32)SKY_coin_Transaction_Serialize(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -12039,12 +11688,10 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_TransactionDeserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  wallet__UxBalance *arg1 = (wallet__UxBalance *) 0 ;
-  CreatedTransactionInput__Handle *arg2 = (CreatedTransactionInput__Handle *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  GoSlice arg1 ;
+  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
   Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -12052,13 +11699,19 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUS
   {
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewCreatedTransactionInput",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__UxBalance, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionInput" "', argument " "1"" of type '" "wallet__UxBalance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_TransactionDeserialize",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_TransactionDeserialize', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  arg1 = (wallet__UxBalance *)(argp1);
-  result = (GoUint32)SKY_api_NewCreatedTransactionInput(arg1,arg2);
+  result = (GoUint32)SKY_coin_TransactionDeserialize(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
@@ -12069,65 +11722,47 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_OutputHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoInterface arg1 ;
-  void *argp1 ;
-  int res1 = 0 ;
+  Transaction__Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewError",&obj0)) SWIG_fail;
   {
-    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_GoInterface,  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); 
-    }  
-    if (!argp1) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'");
-    } else {
-      arg1 = *((GoInterface *)(argp1));
-    }
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  result = (GoUint32)SKY_wallet_NewError(arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_OutputHours",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_coin_Transaction_OutputHours(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  Options__Handle arg2 ;
-  Wallet__Handle *arg3 = (Wallet__Handle *) 0 ;
-  Handle temp3 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  Transactions__Handle *arg1 = (Transactions__Handle *) 0 ;
+  Handle temp1 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewWallet",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewWallet', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    arg1 = &temp1;
   }
-  result = (GoUint32)SKY_wallet_NewWallet(arg1,arg2,arg3);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transactions")) SWIG_fail;
+  result = (GoUint32)SKY_coin_Create_Transactions(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
   return resultobj;
 fail:
@@ -12135,42 +11770,26 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionsObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoSlice arg2 ;
-  GoString arg3 ;
+  Transactions__Handle arg1 ;
+  coin__UxArray **arg2 = (coin__UxArray **) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_Lock",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_GetTransactionsObject",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GoSlice_, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_GetTransactionsObject" "', argument " "2"" of type '" "coin__UxArray **""'"); 
   }
-  result = (GoUint32)SKY_wallet_Wallet_Lock(arg1,arg2,arg3);
+  arg2 = (coin__UxArray **)(argp2);
+  result = (GoUint32)SKY_coin_GetTransactionsObject(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -12178,38 +11797,27 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Lock(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoSlice arg2 ;
-  Wallet__Handle *arg3 = (Wallet__Handle *) 0 ;
-  Handle temp3 ;
+  Transactions__Handle arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Unlock",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Length",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Unlock', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
-  }
-  result = (GoUint32)SKY_wallet_Wallet_Unlock(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_Transactions_Length(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
   }
   return resultobj;
 fail:
@@ -12217,109 +11825,58 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  Wallet__Handle *arg2 = (Wallet__Handle *) 0 ;
-  Handle temp2 ;
+  Transactions__Handle arg1 ;
+  Transaction__Handle arg2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Add",&obj0,&obj1)) SWIG_fail;
   {
-    arg2 = &temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Load",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Load', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
-  result = (GoUint32)SKY_wallet_Load(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transactions_Add(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString arg2 ;
+  Transactions__Handle arg1 ;
+  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
+  GoUint64 *arg3 = (GoUint64 *) 0 ;
+  FeeCalculator temp2 ;
+  GoUint64 temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Save",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Save', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    temp3 = 0;
+    arg3 = &temp3;
   }
-  result = (GoUint32)SKY_wallet_Wallet_Save(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Validate",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Fees",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_Wallet_Validate(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Type",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    if (!PyCallable_Check(obj1)) SWIG_fail;
+    temp2.callback = _WrapperFeeCalculator;
+    temp2.context = obj1;
+    arg2 = &temp2;
   }
-  result = (GoUint32)SKY_wallet_Wallet_Type(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transactions_Fees(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
   }
   return resultobj;
 fail:
@@ -12327,28 +11884,34 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Transactions__Handle arg1 ;
+  GoInt arg2 ;
+  Transaction__Handle *arg3 = (Transaction__Handle *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Version",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_GetAt",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_Wallet_Version(arg1,arg2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_GetAt" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_coin_Transactions_GetAt(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -12356,28 +11919,29 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Transactions__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Filename",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Hashes",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_Wallet_Filename(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transactions_Hashes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -12385,56 +11949,67 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Label",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_Transactions_Hashes__SWIG_0(self, args);
+    }
   }
-  result = (GoUint32)SKY_wallet_Wallet_Label(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_Transactions_Hashes__SWIG_1(self, args);
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transactions_Hashes'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_Transactions_Hashes(Transactions__Handle,cipher_SHA256s *)\n"
+    "    SKY_coin_Transactions_Hashes(Transactions__Handle,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_IsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoUint8 temp2 ;
+  Transactions__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
   int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_IsEncrypted",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Size",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_Wallet_IsEncrypted(arg1,arg2);
+  result = (GoUint32)SKY_coin_Transactions_Size(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
   } else {
     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -12442,38 +12017,34 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_IsEncrypted(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_TruncateBytesTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoUint64 arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
+  Transactions__Handle arg1 ;
+  GoUint32 arg2 ;
+  Transactions__Handle *arg3 = (Transactions__Handle *) 0 ;
+  unsigned int val2 ;
   int ecode2 = 0 ;
-  GoSlice_ temp3 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_GenerateAddresses",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_TruncateBytesTo",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_Wallet_GenerateAddresses" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_TruncateBytesTo" "', argument " "2"" of type '" "GoUint32""'");
   } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_wallet_Wallet_GenerateAddresses(arg1,arg2,arg3);
+  arg2 = (GoUint32)(val2);
+  result = (GoUint32)SKY_coin_Transactions_TruncateBytesTo(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -12481,172 +12052,192 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Transactions__Handle arg1 ;
+  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
+  Transactions__Handle *arg3 = (Transactions__Handle *) 0 ;
+  FeeCalculator temp2 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_GetAddresses",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SortTransactions",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_Wallet_GetAddresses(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
+    if (!PyCallable_Check(obj1)) SWIG_fail;
+    temp2.callback = _WrapperFeeCalculator;
+    temp2.context = obj1;
+    arg2 = &temp2;
+  }
+  result = (GoUint32)SKY_coin_SortTransactions(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewSortableTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  wallet__Entry *arg3 = (wallet__Entry *) 0 ;
-  GoUint8 *arg4 = (GoUint8 *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  Transactions__Handle arg1 ;
+  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
+  SortableTransactionResult_Handle *arg3 = (SortableTransactionResult_Handle *) 0 ;
+  FeeCalculator temp2 ;
   void *argp3 = 0 ;
   int res3 = 0 ;
-  GoUint8 temp4 ;
-  int res4 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_GetEntry",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewSortableTransactions",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  {
+    if (!PyCallable_Check(obj1)) SWIG_fail;
+    temp2.callback = _WrapperFeeCalculator;
+    temp2.context = obj1;
+    arg2 = &temp2;
   }
-  arg2 = (cipher__Address *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_SortableTransactionResult_Handle, 0 |  0 );
   if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "3"" of type '" "wallet__Entry *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_NewSortableTransactions" "', argument " "3"" of type '" "SortableTransactionResult_Handle *""'"); 
   }
-  arg3 = (wallet__Entry *)(argp3);
-  result = (GoUint32)SKY_wallet_Wallet_GetEntry(arg1,arg2,arg3,arg4);
+  arg3 = (SortableTransactionResult_Handle *)(argp3);
+  result = (GoUint32)SKY_coin_NewSortableTransactions(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res4)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_AddEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  wallet__Entry *arg2 = (wallet__Entry *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  SortableTransactionResult_Handle arg1 ;
+  void *argp1 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_AddEntry",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Sort",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
+    } else {
+      arg1 = *((SortableTransactionResult_Handle *)(argp1));
+    }
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_AddEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); 
+  result = (GoUint32)SKY_coin_SortableTransactions_Sort(arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SortableTransactionResult_Handle arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Len",&obj0)) SWIG_fail;
+  {
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
+    } else {
+      arg1 = *((SortableTransactionResult_Handle *)(argp1));
+    }
   }
-  arg2 = (wallet__Entry *)(argp2);
-  result = (GoUint32)SKY_wallet_Wallet_AddEntry(arg1,arg2);
+  result = (GoUint32)SKY_coin_SortableTransactions_Len(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Less(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoUint64 arg2 ;
-  GoUint8 arg3 ;
-  GoUint64 *arg4 = (GoUint64 *) 0 ;
-  coin__UxArray *arg5 = (coin__UxArray *) 0 ;
-  GoUint64 *arg6 = (GoUint64 *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  unsigned long long val2 ;
+  SortableTransactionResult_Handle arg1 ;
+  GoInt arg2 ;
+  GoInt arg3 ;
+  GoUint8 *arg4 = (GoUint8 *) 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  long long val2 ;
   int ecode2 = 0 ;
-  unsigned char val3 ;
+  long long val3 ;
   int ecode3 = 0 ;
-  GoUint64 temp4 ;
-  GoSlice_ temp5 ;
-  GoUint64 temp6 ;
+  GoUint8 temp4 ;
+  int res4 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Less",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp4 = 0;
-    arg4 = &temp4;
-  }
-  {
-    temp5.data = NULL;
-    temp5.len = 0;
-    temp5.cap = 0;
-    arg5 = (coin__UxArray *)&temp5;
-  }
-  {
-    temp6 = 0;
-    arg6 = &temp6;
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
+    } else {
+      arg1 = *((SortableTransactionResult_Handle *)(argp1));
+    }
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_DistributeSpendHours",&obj0,&obj1,&obj2)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "2"" of type '" "GoInt""'");
   } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
+  arg2 = (GoInt)(val2);
+  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "3"" of type '" "GoUint8""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "3"" of type '" "GoInt""'");
   } 
-  arg3 = (GoUint8)(val3);
-  result = (GoUint32)SKY_wallet_DistributeSpendHours(arg1,arg2,arg3,arg4,arg5,arg6);
+  arg3 = (GoInt)(val3);
+  result = (GoUint32)SKY_coin_SortableTransactions_Less(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 ));
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len  ));
-    free( (void*)arg5->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg6 ));
+  if (SWIG_IsTmpObj(res4)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -12654,54 +12245,129 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeCoinHoursProportional(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoUint64 arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
+  SortableTransactionResult_Handle arg1 ;
+  GoInt arg2 ;
+  GoInt arg3 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  long long val2 ;
   int ecode2 = 0 ;
-  GoSlice_ temp3 ;
+  long long val3 ;
+  int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Swap",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_DistributeCoinHoursProportional",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_DistributeCoinHoursProportional', expecting string");
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
+    } else {
+      arg1 = *((SortableTransactionResult_Handle *)(argp1));
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeCoinHoursProportional" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "2"" of type '" "GoInt""'");
   } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_wallet_DistributeCoinHoursProportional(arg1,arg2,arg3);
+  arg2 = (GoInt)(val2);
+  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "3"" of type '" "GoInt""'");
+  } 
+  arg3 = (GoInt)(val3);
+  result = (GoUint32)SKY_coin_SortableTransactions_Swap(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoSlice_ temp2 ;
+  GoUint32 result;
+  
+  {
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
+  }
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_VerifyTransactionCoinsSpending")) SWIG_fail;
+  result = (GoUint32)SKY_coin_VerifyTransactionCoinsSpending(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionCoinsSpending'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_VerifyTransactionCoinsSpending(coin_UxOutArray *,coin_UxOutArray *)\n"
+    "    SKY_coin_VerifyTransactionCoinsSpending(coin__UxArray *,coin__UxArray *)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoUint64 arg1 ;
   coin__UxArray *arg2 = (coin__UxArray *) 0 ;
@@ -12725,13 +12391,13 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(sel
     temp3.cap = 0;
     arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewUxBalances",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_VerifyTransactionHoursSpending",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalances" "', argument " "1"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_VerifyTransactionHoursSpending" "', argument " "1"" of type '" "GoUint64""'");
   } 
   arg1 = (GoUint64)(val1);
-  result = (GoUint32)SKY_wallet_NewUxBalances(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_VerifyTransactionHoursSpending(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
@@ -12747,39 +12413,73 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  Py_ssize_t ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(self, args);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = PyList_Check(argv[2]) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionHoursSpending'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin_UxOutArray *,coin_UxOutArray *)\n"
+    "    SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin__UxArray *,coin__UxArray *)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_testutil_MakeAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  coin__UxOut *arg2 = (coin__UxOut *) 0 ;
-  wallet__UxBalance *arg3 = (wallet__UxBalance *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewUxBalance",&obj0,&obj1,&obj2)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalance" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewUxBalance" "', argument " "2"" of type '" "coin__UxOut *""'"); 
-  }
-  arg2 = (coin__UxOut *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__UxBalance, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewUxBalance" "', argument " "3"" of type '" "wallet__UxBalance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_testutil_MakeAddress",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_testutil_MakeAddress" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg3 = (wallet__UxBalance *)(argp3);
-  result = (GoUint32)SKY_wallet_NewUxBalance(arg1,arg2,arg3);
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint32)SKY_testutil_MakeAddress(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -12787,170 +12487,83 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalance(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoUint64 arg2 ;
-  GoUint64 arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  GoSlice_ temp4 ;
+  GoInterface arg1 ;
+  void *argp1 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewError",&obj0)) SWIG_fail;
   {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMinimizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMinimizeUxOuts', expecting string");
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_GoInterface,  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'");
+    } else {
+      arg1 = *((GoInterface *)(argp1));
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  result = (GoUint32)SKY_wallet_ChooseSpendsMinimizeUxOuts(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_wallet_NewError(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoUint64 arg2 ;
-  GoUint64 arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  GoSlice_ temp4 ;
+  GoString arg1 ;
+  Options__Handle arg2 ;
+  Wallet__Handle *arg3 = (Wallet__Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMaximizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewWallet",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMaximizeUxOuts', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewWallet', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
-  }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  result = (GoUint32)SKY_wallet_ChooseSpendsMaximizeUxOuts(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cli_CheckWalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  GoString arg2 ;
-  BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_CheckWalletBalance",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
+  result = (GoUint32)SKY_wallet_NewWallet(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CheckWalletBalance', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_CheckWalletBalance" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); 
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
-  arg3 = (BalanceResult_Handle *)(argp3);
-  result = (GoUint32)SKY_cli_CheckWalletBalance(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
+  Wallet__Handle arg1 ;
   GoSlice arg2 ;
-  BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  GoString arg3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetBalanceOfAddresses",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_Lock",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -12959,18 +12572,23 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPAR
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetBalanceOfAddresses', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string");
     }
     (&arg2)->data = buffer;
     (&arg2)->len = size - 1;
     (&arg2)->cap = size;
   }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetBalanceOfAddresses" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
   }
-  arg3 = (BalanceResult_Handle *)(argp3);
-  result = (GoUint32)SKY_cli_GetBalanceOfAddresses(arg1,arg2,arg3);
+  result = (GoUint32)SKY_wallet_Wallet_Lock(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -12978,13 +12596,11 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  wallet__Entry *arg2 = (wallet__Entry *) 0 ;
-  ReadableEntry__Handle *arg3 = (ReadableEntry__Handle *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  Wallet__Handle arg1 ;
+  GoSlice arg2 ;
+  Wallet__Handle *arg3 = (Wallet__Handle *) 0 ;
   Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
@@ -12993,23 +12609,22 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(
   {
     arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewReadableEntry",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Unlock",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewReadableEntry', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Unlock', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewReadableEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); 
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  arg2 = (wallet__Entry *)(argp2);
-  result = (GoUint32)SKY_wallet_NewReadableEntry(arg1,arg2,arg3);
+  result = (GoUint32)SKY_wallet_Wallet_Unlock(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
@@ -13020,10 +12635,10 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  ReadableWallet__Handle *arg2 = (ReadableWallet__Handle *) 0 ;
+  Wallet__Handle *arg2 = (Wallet__Handle *) 0 ;
   Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -13031,18 +12646,18 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPAR
   {
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_LoadReadableWallet",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Load",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_LoadReadableWallet', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Load', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_wallet_LoadReadableWallet(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Load(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
@@ -13053,15 +12668,15 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  ReadableWallet__Handle arg1 ;
+  Wallet__Handle arg1 ;
   GoString arg2 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Save",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Save",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -13070,12 +12685,12 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPA
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Save', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Save', expecting string");
     }
     (&arg2)->p = buffer;
     (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_wallet_ReadableWallet_Save(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_Save(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -13083,29 +12698,17 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  ReadableWallet__Handle arg1 ;
-  GoString arg2 ;
+  Wallet__Handle arg1 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Load",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Validate",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Load', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  result = (GoUint32)SKY_wallet_ReadableWallet_Load(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_Validate(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -13113,54 +12716,57 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Load(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  ReadableWallet__Handle arg1 ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_ReadableWallet_Erase",&obj0)) SWIG_fail;
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Type",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_wallet_ReadableWallet_Erase(arg1);
+  result = (GoUint32)SKY_wallet_Wallet_Type(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_String2Hex",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Version",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_String2Hex', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_base58_String2Hex(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_Version(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -13168,34 +12774,28 @@ SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToInt",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToInt', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  result = (GoUint32)SKY_base58_Base58_ToInt(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Filename",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_wallet_Wallet_Filename(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -13203,36 +12803,28 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToInt(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Wallet__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToHex",&obj0)) SWIG_fail;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Label",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToHex', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_base58_Base58_ToHex(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_Label(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -13240,34 +12832,27 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToHex(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_IsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
+  Wallet__Handle arg1 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoUint8 temp2 ;
   int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_Base582Int",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_IsEncrypted",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_Base582Int', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_base58_Base58_Base582Int(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_IsEncrypted(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
   } else {
     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -13275,36 +12860,38 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Base582Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Wallet__Handle arg1 ;
+  GoUint64 arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base582Hex",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_GenerateAddresses",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base582Hex', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_base58_Base582Hex(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_Wallet_GenerateAddresses" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_wallet_Wallet_GenerateAddresses(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -13312,9 +12899,9 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base582Hex(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
+  Wallet__Handle arg1 ;
   coin__UxArray *arg2 = (coin__UxArray *) 0 ;
   GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
@@ -13326,18 +12913,11 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(sel
     temp2.cap = 0;
     arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_BitHex",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_GetAddresses",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_BitHex', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_base58_Base58_BitHex(arg1,arg2);
+  result = (GoUint32)SKY_wallet_Wallet_GetAddresses(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
@@ -13349,32 +12929,45 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Int2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoInt arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  long long val1 ;
-  int ecode1 = 0 ;
-  GoString temp2 ;
+  Wallet__Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  wallet__Entry *arg3 = (wallet__Entry *) 0 ;
+  GoUint8 *arg4 = (GoUint8 *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  GoUint8 temp4 ;
+  int res4 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_GetEntry",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Int2Base58",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_base58_Int2Base58" "', argument " "1"" of type '" "GoInt""'");
-  } 
-  arg1 = (GoInt)(val1);
-  result = (GoUint32)SKY_base58_Int2Base58(arg1,arg2);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  }
+  arg2 = (cipher__Address *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "3"" of type '" "wallet__Entry *""'"); 
+  }
+  arg3 = (wallet__Entry *)(argp3);
+  result = (GoUint32)SKY_wallet_Wallet_GetEntry(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (SWIG_IsTmpObj(res4)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -13382,110 +12975,143 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Int2Base58(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_AddEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Wallet__Handle arg1 ;
+  wallet__Entry *arg2 = (wallet__Entry *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_AddEntry",&obj0,&obj1)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_AddEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); 
   }
-  result = (GoUint32)SKY_base58_Hex2Base58(arg1,arg2);
+  arg2 = (wallet__Entry *)(argp2);
+  result = (GoUint32)SKY_wallet_Wallet_AddEntry(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  GoUint64 arg1 ;
+  GoUint64 arg2 ;
+  GoUint8 arg3 ;
+  GoUint64 *arg4 = (GoUint64 *) 0 ;
+  coin__UxArray *arg5 = (coin__UxArray *) 0 ;
+  GoUint64 *arg6 = (GoUint64 *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  unsigned char val3 ;
+  int ecode3 = 0 ;
+  GoUint64 temp4 ;
+  GoSlice_ temp5 ;
+  GoUint64 temp6 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp4 = 0;
+    arg4 = &temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58String",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58String', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    temp5.data = NULL;
+    temp5.len = 0;
+    temp5.cap = 0;
+    arg5 = (coin__UxArray *)&temp5;
   }
-  result = (GoUint32)SKY_base58_Hex2Base58String(arg1,arg2);
+  {
+    temp6 = 0;
+    arg6 = &temp6;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_DistributeSpendHours",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "3"" of type '" "GoUint8""'");
+  } 
+  arg3 = (GoUint8)(val3);
+  result = (GoUint32)SKY_wallet_DistributeSpendHours(arg1,arg2,arg3,arg4,arg5,arg6);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 ));
   }
-  return resultobj;
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len  ));
+    free( (void*)arg5->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg6 ));
+  }
+  return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58Str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeCoinHoursProportional(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  GoUint64 arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58Str",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_DistributeCoinHoursProportional",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58Str', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_DistributeCoinHoursProportional', expecting string");
     }
     (&arg1)->data = buffer;
     (&arg1)->len = size - 1;
     (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_base58_Hex2Base58Str(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeCoinHoursProportional" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_wallet_DistributeCoinHoursProportional(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -13493,49 +13119,45 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58Str(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_GenerateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  Options__Handle *arg2 = (Options__Handle *) 0 ;
-  GoUint64 arg3 ;
-  Wallet__Handle *arg4 = (Wallet__Handle *) 0 ;
-  Handle temp2 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  Handle temp4 ;
+  GoUint64 arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  GoSlice_ temp2 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
-  }
-  {
-    arg4 = &temp4;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GenerateWallet",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateWallet', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_cli_GenerateWallet" "', argument " "3"" of type '" "GoUint64""'");
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewUxBalances",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalances" "', argument " "1"" of type '" "GoUint64""'");
   } 
-  arg3 = (GoUint64)(val3);
-  result = (GoUint32)SKY_cli_GenerateWallet(arg1,arg2,arg3,arg4);
+  arg1 = (GoUint64)(val1);
+  result = (GoUint32)SKY_wallet_NewUxBalances(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -13543,56 +13165,95 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GenerateWallet(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_MakeAlphanumericSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString_ *arg1 = (GoString_ *) 0 ;
-  GoString temp1 ;
+  GoUint64 arg1 ;
+  coin__UxOut *arg2 = (coin__UxOut *) 0 ;
+  wallet__UxBalance *arg3 = (wallet__UxBalance *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp1.p = NULL;
-    temp1.n = 0;
-    arg1 = (GoString_ *)&temp1;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewUxBalance",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalance" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewUxBalance" "', argument " "2"" of type '" "coin__UxOut *""'"); 
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_MakeAlphanumericSeed")) SWIG_fail;
-  result = (GoUint32)SKY_cli_MakeAlphanumericSeed(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
-    free( (void*)arg1->p );
+  arg2 = (coin__UxOut *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__UxBalance, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewUxBalance" "', argument " "3"" of type '" "wallet__UxBalance *""'"); 
   }
+  arg3 = (wallet__UxBalance *)(argp3);
+  result = (GoUint32)SKY_wallet_NewUxBalance(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
-  Handle temp2 ;
+  GoSlice arg1 ;
+  GoUint64 arg2 ;
+  GoUint64 arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_NewClient",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMinimizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_NewClient', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMinimizeUxOuts', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_webrpc_NewClient(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  result = (GoUint32)SKY_wallet_ChooseSpendsMinimizeUxOuts(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -13600,28 +13261,55 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  GoSlice arg1 ;
+  GoUint64 arg2 ;
+  GoUint64 arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_Client_CSRF",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMaximizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMaximizeUxOuts', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_webrpc_Client_CSRF(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  result = (GoUint32)SKY_wallet_ChooseSpendsMaximizeUxOuts(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -13629,80 +13317,127 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_CreateOptionsHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  Transaction__Handle arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString temp3 ;
+  GoString arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoUint8 arg4 ;
+  GoString arg5 ;
+  GoString arg6 ;
+  GoUint64 arg7 ;
+  Options__Handle *arg8 = (Options__Handle *) 0 ;
+  unsigned char val4 ;
+  int ecode4 = 0 ;
+  unsigned long long val7 ;
+  int ecode7 = 0 ;
+  Handle temp8 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  GoUint32 result;
+  
+  {
+    arg8 = &temp8;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SKY_wallet_CreateOptionsHandle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_webrpc_Client_InjectTransaction(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  StatusResult_Handle *arg2 = (StatusResult_Handle *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetStatus",&obj0,&obj1)) SWIG_fail;
+  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "4"" of type '" "GoUint8""'");
+  } 
+  arg4 = (GoUint8)(val4);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
+    }
+    (&arg5)->p = buffer;
+    (&arg5)->n = size - 1;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StatusResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_webrpc_Client_GetStatus" "', argument " "2"" of type '" "StatusResult_Handle *""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
+    }
+    (&arg6)->p = buffer;
+    (&arg6)->n = size - 1;
   }
-  arg2 = (StatusResult_Handle *)(argp2);
-  result = (GoUint32)SKY_webrpc_Client_GetStatus(arg1,arg2);
+  ecode7 = SWIG_AsVal_unsigned_SS_long_SS_long(obj6, &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "7"" of type '" "GoUint64""'");
+  } 
+  arg7 = (GoUint64)(val7);
+  result = (GoUint32)SKY_wallet_CreateOptionsHandle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg8));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetTransactionByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   WebRpcClient__Handle arg1 ;
   GoString arg2 ;
-  TransactionResult_Handle *arg3 = (TransactionResult_Handle *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  GoString arg3 ;
+  GoSlice arg4 ;
+  PasswordReader__Handle arg5 ;
+  Transaction__Handle *arg6 = (Transaction__Handle *) 0 ;
+  void *argp5 ;
+  int res5 = 0 ;
+  Handle temp6 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetTransactionByID",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    arg6 = &temp6;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_cli_CreateRawTxFromWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -13711,41 +13446,78 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetTransactionByID(PyObject *SWIGUN
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetTransactionByID', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
     }
     (&arg2)->p = buffer;
     (&arg2)->n = size - 1;
   }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_TransactionResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_webrpc_Client_GetTransactionByID" "', argument " "3"" of type '" "TransactionResult_Handle *""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
   }
-  arg3 = (TransactionResult_Handle *)(argp3);
-  result = (GoUint32)SKY_webrpc_Client_GetTransactionByID(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
+    }
+    (&arg4)->data = buffer;
+    (&arg4)->len = size - 1;
+    (&arg4)->cap = size;
+  }
+  {
+    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_PasswordReader__Handle,  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); 
+    }  
+    if (!argp5) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'");
+    } else {
+      arg5 = *((PasswordReader__Handle *)(argp5));
+    }
+  }
+  result = (GoUint32)SKY_cli_CreateRawTxFromWallet(arg1,arg2,arg3,arg4,arg5,arg6);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   WebRpcClient__Handle arg1 ;
-  GoSlice arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoSlice_ temp3 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoString arg4 ;
+  GoSlice arg5 ;
+  PasswordReader__Handle arg6 ;
+  Transaction__Handle *arg7 = (Transaction__Handle *) 0 ;
+  void *argp6 ;
+  int res6 = 0 ;
+  Handle temp7 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    arg7 = &temp7;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetAddressUxOuts",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTxFromAddress",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -13754,17 +13526,57 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUS
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetAddressUxOuts', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
     }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_webrpc_Client_GetAddressUxOuts(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
+    }
+    (&arg4)->p = buffer;
+    (&arg4)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
+    }
+    (&arg5)->data = buffer;
+    (&arg5)->len = size - 1;
+    (&arg5)->cap = size;
+  }
+  {
+    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_PasswordReader__Handle,  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); 
+    }  
+    if (!argp6) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'");
+    } else {
+      arg6 = *((PasswordReader__Handle *)(argp6));
+    }
+  }
+  result = (GoUint32)SKY_cli_CreateRawTxFromAddress(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7));
   }
   return resultobj;
 fail:
@@ -13772,47 +13584,81 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   WebRpcClient__Handle arg1 ;
-  GoUint64 arg2 ;
-  GoUint64 arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  GoSlice_ temp4 ;
+  Wallet__Handle arg2 ;
+  GoSlice arg3 ;
+  GoString arg4 ;
+  GoSlice arg5 ;
+  GoSlice arg6 ;
+  Transaction__Handle *arg7 = (Transaction__Handle *) 0 ;
+  Handle temp7 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  GoUint32 result;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  GoUint32 result;
   
   {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
+    arg7 = &temp7;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetBlocksInRange",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  result = (GoUint32)SKY_webrpc_Client_GetBlocksInRange(arg1,arg2,arg3,arg4);
+  {
+    SWIG_AsVal_long(obj1, (long*)&arg2);
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
+    }
+    (&arg3)->data = buffer;
+    (&arg3)->len = size - 1;
+    (&arg3)->cap = size;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
+    }
+    (&arg4)->p = buffer;
+    (&arg4)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
+    }
+    (&arg5)->data = buffer;
+    (&arg5)->len = size - 1;
+    (&arg5)->cap = size;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
+    }
+    (&arg6)->data = buffer;
+    (&arg6)->len = size - 1;
+    (&arg6)->cap = size;
+  }
+  result = (GoUint32)SKY_cli_CreateRawTx(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7));
   }
   return resultobj;
 fail:
@@ -13820,42 +13666,59 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_NewTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
+  GoSlice arg1 ;
   GoSlice arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoSlice_ temp3 ;
+  GoSlice arg3 ;
+  Transaction__Handle *arg4 = (Transaction__Handle *) 0 ;
+  Handle temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    arg4 = &temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetBlocksBySeq",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_NewTransaction",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetBlocksBySeq', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
     }
     (&arg2)->data = buffer;
     (&arg2)->len = size - 1;
     (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_webrpc_Client_GetBlocksBySeq(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
+    }
+    (&arg3)->data = buffer;
+    (&arg3)->len = size - 1;
+    (&arg3)->cap = size;
+  }
+  result = (GoUint32)SKY_cli_NewTransaction(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
   }
   return resultobj;
 fail:
@@ -13863,38 +13726,59 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  GoUint64 arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  GoSlice_ temp3 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoSlice arg2 ;
+  GoSlice arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetLastBlocks",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Encrypt",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Encrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+  }
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetLastBlocks" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_webrpc_Client_GetLastBlocks(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string");
+    }
+    (&arg3)->data = buffer;
+    (&arg3)->len = size - 1;
+    (&arg3)->cap = size;
+  }
+  result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Encrypt(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -13902,23 +13786,59 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString_ *arg1 = (GoString_ *) 0 ;
-  GoString temp1 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoSlice arg2 ;
+  GoSlice arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp4 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp1.p = NULL;
-    temp1.n = 0;
-    arg1 = (GoString_ *)&temp1;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_iputil_LocalhostIP")) SWIG_fail;
-  result = (GoUint32)SKY_iputil_LocalhostIP(arg1);
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Decrypt",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Decrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+  }
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string");
+    }
+    (&arg3)->data = buffer;
+    (&arg3)->len = size - 1;
+    (&arg3)->cap = size;
+  }
+  result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Decrypt(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
-    free( (void*)arg1->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -13926,253 +13846,152 @@ SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_iputil_IsLocalhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_CheckWalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoUint8 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  WebRpcClient__Handle arg1 ;
+  GoString arg2 ;
+  BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_IsLocalhost",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_CheckWalletBalance",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_IsLocalhost', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CheckWalletBalance', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  result = (GoUint32)SKY_iputil_IsLocalhost(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
-  }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_iputil_SplitAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoUint16 *arg3 = (GoUint16 *) 0 ;
-  GoString temp2 ;
-  GoUint16 temp3 ;
-  int res3 = SWIG_TMPOBJ ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  arg3 = &temp3;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_SplitAddr",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_SplitAddr', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_CheckWalletBalance" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); 
   }
-  result = (GoUint32)SKY_iputil_SplitAddr(arg1,arg2,arg3);
+  arg3 = (BalanceResult_Handle *)(argp3);
+  result = (GoUint32)SKY_cli_CheckWalletBalance(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
-  if (SWIG_IsTmpObj(res3)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_GenerateAddressesInFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoUint64 arg2 ;
-  PasswordReader__Handle arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  void *argp3 ;
+  WebRpcClient__Handle arg1 ;
+  GoSlice arg2 ;
+  BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ;
+  void *argp3 = 0 ;
   int res3 = 0 ;
-  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetBalanceOfAddresses",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GenerateAddressesInFile",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateAddressesInFile', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetBalanceOfAddresses', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  {
-    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle,  0 );
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); 
-    }  
-    if (!argp3) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'");
-    } else {
-      arg3 = *((PasswordReader__Handle *)(argp3));
-    }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetBalanceOfAddresses" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); 
   }
-  result = (GoUint32)SKY_cli_GenerateAddressesInFile(arg1,arg2,arg3,arg4);
+  arg3 = (BalanceResult_Handle *)(argp3);
+  result = (GoUint32)SKY_cli_GetBalanceOfAddresses(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  WebRpcClient__Handle arg1 ;
+  GoString arg2 ;
+  ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetWalletOutputsFromFile",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJSON",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJSON', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetWalletOutputsFromFile', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
-  }
-  result = (GoUint32)SKY_cli_FormatAddressesAsJSON(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJoinedArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJoinedArray",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJoinedArray', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputsFromFile" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); 
   }
-  result = (GoUint32)SKY_cli_FormatAddressesAsJoinedArray(arg1,arg2);
+  arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3);
+  result = (GoUint32)SKY_cli_GetWalletOutputsFromFile(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_AddressesToStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  WebRpcClient__Handle arg1 ;
+  Wallet__Handle *arg2 = (Wallet__Handle *) 0 ;
+  ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ;
+  Handle temp2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_AddressesToStrings",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GetWalletOutputs",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddressesToStrings', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_cli_AddressesToStrings(arg1,arg2);
+  res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputs" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); 
+  }
+  arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3);
+  result = (GoUint32)SKY_cli_GetWalletOutputs(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -14314,237 +14133,198 @@ SWIGINTERN PyObject *_wrap_SKY_coin_IntToUint32(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_RandByte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_handle_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoInt arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  long long val1 ;
-  int ecode1 = 0 ;
-  GoSlice_ temp2 ;
+  Handle arg1 ;
   PyObject * obj0 = 0 ;
-  GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_close",&obj0)) SWIG_fail;
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_RandByte",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_cipher_RandByte" "', argument " "1"" of type '" "GoInt""'");
-  } 
-  arg1 = (GoInt)(val1);
-  result = (GoUint32)SKY_cipher_RandByte(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
+  SKY_handle_close(arg1);
+  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_NewPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
+  Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewPubKey",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewPubKey', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_copy",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_cipher_NewPubKey(arg1,(unsigned char (*)[33])arg2);
+  result = (GoUint32)SKY_handle_copy(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromHex",&obj0,&obj1)) SWIG_fail;
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_InitDataDir",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_PubKeyFromHex', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_InitDataDir', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
+  result = (GoUint32)SKY_file_InitDataDir(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
-  result = (GoUint32)SKY_cipher_PubKeyFromHex(arg1,(unsigned char (*)[33])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  GoString_ *arg1 = (GoString_ *) 0 ;
+  GoString temp1 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
+    temp1.p = NULL;
+    temp1.n = 0;
+    arg1 = (GoString_ *)&temp1;
   }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_file_UserHome")) SWIG_fail;
+  result = (GoUint32)SKY_file_UserHome(arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
+    free( (void*)arg1->p );
   }
-  result = (GoUint32)SKY_cipher_PubKeyFromSecKey((unsigned char (*)[32])arg1,(unsigned char (*)[33])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_file_ResolveResourceDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  cipher__PubKey *arg3 = (cipher__PubKey *) 0 ;
+  GoString arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_PubKeyFromSig",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg1 = &p->data;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_ResolveResourceDirectory",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_ResolveResourceDirectory', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
+  result = (GoUint32)SKY_file_ResolveResourceDirectory(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg3 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
-  result = (GoUint32)SKY_cipher_PubKeyFromSig((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[33])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_file_DetermineResourcePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  GoString arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoString_ *arg4 = (GoString_ *) 0 ;
+  GoString temp4 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Verify",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    temp4.p = NULL;
+    temp4.n = 0;
+    arg4 = (GoString_ *)&temp4;
   }
-  result = (GoUint32)SKY_cipher_PubKey_Verify((unsigned char (*)[33])arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_file_DetermineResourcePath",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Hex",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_cipher_PubKey_Hex((unsigned char (*)[33])arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  result = (GoUint32)SKY_file_DetermineResourcePath(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
+    free( (void*)arg4->p );
   }
   return resultobj;
 fail:
@@ -14552,103 +14332,138 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  GoString_ *arg1 = (GoString_ *) 0 ;
+  GoString temp1 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyRipemd160",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    temp1.p = NULL;
+    temp1.n = 0;
+    arg1 = (GoString_ *)&temp1;
   }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_iputil_LocalhostIP")) SWIG_fail;
+  result = (GoUint32)SKY_iputil_LocalhostIP(arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
-    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
+    free( (void*)arg1->p );
   }
-  result = (GoUint32)SKY_cipher_PubKeyRipemd160((unsigned char (*)[33])arg1,(unsigned char (*)[20])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_NewSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_iputil_IsLocalhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  GoString arg1 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSecKey",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_IsLocalhost",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSecKey', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_IsLocalhost', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
+  }
+  result = (GoUint32)SKY_iputil_IsLocalhost(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_iputil_SplitAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoString arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoUint16 *arg3 = (GoUint16 *) 0 ;
+  GoString temp2 ;
+  GoUint16 temp3 ;
+  int res3 = SWIG_TMPOBJ ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_SplitAddr",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_SplitAddr', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_cipher_NewSecKey(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_iputil_SplitAddr(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
+  if (SWIG_IsTmpObj(res3)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromHex",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58BitcoinAddress",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromHex', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58BitcoinAddress', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58BitcoinAddress" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  result = (GoUint32)SKY_cipher_SecKeyFromHex(arg1,(unsigned char (*)[32])arg2);
+  arg2 = (cipher__BitcoinAddress *)(argp2);
+  result = (GoUint32)SKY_cipher_DecodeBase58BitcoinAddress(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -14656,43 +14471,48 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromHex(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint32 result;
+  PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Verify",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromPubKey",&obj0,&obj1)) SWIG_fail;
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
     if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
     arg1 = &p->data;
   }
-  result = (GoUint32)SKY_cipher_SecKey_Verify((unsigned char (*)[32])arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromPubKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  }
+  arg2 = (cipher__BitcoinAddress *)(argp2);
+  SKY_cipher_BitcoinAddressFromPubKey((unsigned char (*)[33])arg1,arg2);
+  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Hex",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
     void *argp = 0;
     int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
@@ -14701,56 +14521,45 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self),
     cipher_SecKey* p = (cipher_SecKey*)argp;
     arg1 = &p->data;
   }
-  result = (GoUint32)SKY_cipher_SecKey_Hex((unsigned char (*)[32])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromSecKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
   }
+  arg2 = (cipher__BitcoinAddress *)(argp2);
+  result = (GoUint32)SKY_cipher_BitcoinAddressFromSecKey((unsigned char (*)[32])arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_ECDH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoSlice_ temp3 ;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_ECDH",&obj0,&obj1)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinWalletImportFormatFromSeckey",&obj0)) SWIG_fail;
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
     if (!SWIG_IsOK(res))
     SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
     cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+    arg1 = &p->data;
   }
-  result = (GoUint32)SKY_cipher_ECDH((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  SKY_cipher_BitcoinWalletImportFormatFromSeckey((unsigned char (*)[32])arg1,arg2);
+  resultobj = SWIG_Py_Void();
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -14758,35 +14567,34 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_ECDH(PyObject *SWIGUNUSEDPARM(self), PyObj
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoSlice arg1 ;
-  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
+  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSig",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromBytes",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSig', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_BitcoinAddressFromBytes', expecting string");
     }
     (&arg1)->data = buffer;
     (&arg1)->len = size - 1;
     (&arg1)->cap = size;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg2 = &p->data;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromBytes" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  result = (GoUint32)SKY_cipher_NewSig(arg1,(unsigned char (*)[65])arg2);
+  arg2 = (cipher__BitcoinAddress *)(argp2);
+  result = (GoUint32)SKY_cipher_BitcoinAddressFromBytes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -14794,34 +14602,34 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyO
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SigFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SigFromHex",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromBitcoinWalletImportFormat",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SigFromHex', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromBitcoinWalletImportFormat', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
     if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
     arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cipher_SigFromHex(arg1,(unsigned char (*)[65])arg2);
+  result = (GoUint32)SKY_cipher_SecKeyFromBitcoinWalletImportFormat(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -14829,118 +14637,86 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SigFromHex(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Sig_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint32 result;
+  GoUint8 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Sig_Hex",&obj0)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg1 = &p->data;
-  }
-  result = (GoUint32)SKY_cipher_Sig_Hex((unsigned char (*)[65])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Null",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Null" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  result = (GoUint8)SKY_cipher_BitcoinAddress_Null(arg1);
+  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SignHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
-  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SignHash",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Bytes",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Bytes" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  SKY_cipher_BitcoinAddress_Bytes(arg1,arg2);
+  resultobj = SWIG_Py_Void();
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg3 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  result = (GoUint32)SKY_cipher_SignHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[65])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyAddressSignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyAddressSignedHash",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Verify",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_VerifyAddressSignedHash" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Verify" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
+  arg1 = (cipher__BitcoinAddress *)(argp1);
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
     if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
     arg2 = &p->data;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
-  }
-  result = (GoUint32)SKY_cipher_VerifyAddressSignedHash(arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3);
+  result = (GoUint32)SKY_cipher_BitcoinAddress_Verify(arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -14948,212 +14724,160 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyAddressSignedHash(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_VerifySignedHash",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg1 = &p->data;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_String",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_String" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  SKY_cipher_BitcoinAddress_String(arg1,arg2);
+  resultobj = SWIG_Py_Void();
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
-  result = (GoUint32)SKY_cipher_VerifySignedHash((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyPubKeySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  cipher__Checksum *arg2 = (cipher__Checksum *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyPubKeySignedHash",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Checksum",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Checksum" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0);
     if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum");
+    cipher_Checksum* p = (cipher_Checksum*)argp;
     arg2 = &p->data;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
-  }
-  result = (GoUint32)SKY_cipher_VerifyPubKeySignedHash((unsigned char (*)[33])arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  SKY_cipher_BitcoinAddress_Checksum(arg1,(unsigned char (*)[4])arg2);
+  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
+  GoString arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  Handle temp1 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateKeyPair",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    arg1 = &temp1;
   }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  result = (GoUint32)SKY_cipher_GenerateKeyPair((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
-  cipher__SecKey *arg3 = (cipher__SecKey *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_GenerateDeterministicKeyPair",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_Get",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPair', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_Get', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  result = (GoUint32)SKY_map_Get(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg3 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
-  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPair(arg1,(unsigned char (*)[33])arg2,(unsigned char (*)[32])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_DeterministicKeyPairIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  cipher__PubKey *arg3 = (cipher__PubKey *) 0 ;
-  cipher__SecKey *arg4 = (cipher__SecKey *) 0 ;
-  GoSlice_ temp2 ;
+  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
+  GoString arg2 ;
+  Handle temp1 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
+  GoUint8 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg1 = &temp1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_DeterministicKeyPairIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_HasKey",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DeterministicKeyPairIterator', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_HasKey', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  result = (GoUint8)SKY_map_HasKey(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg3 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_map_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
+  Handle temp1 ;
+  GoUint32 result;
+  
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg4 = &p->data;
+    arg1 = &temp1;
   }
-  result = (GoUint32)SKY_cipher_DeterministicKeyPairIterator(arg1,arg2,(unsigned char (*)[33])arg3,(unsigned char (*)[32])arg4);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_map_Close")) SWIG_fail;
+  result = (GoUint32)SKY_map_Close(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
   return resultobj;
 fail:
@@ -15161,46 +14885,33 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_DeterministicKeyPairIterator(PyObject *SWI
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoInt arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  GoSlice_ temp3 ;
+  GoString arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairs",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_FromString",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairs', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_droplet_FromString', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairs" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairs(arg1,arg2,arg3);
+  result = (GoUint32)SKY_droplet_FromString(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -15208,116 +14919,68 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyOb
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoUint64 arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      char* buffer = 0;
-      size_t size = 0;
-      int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 );
-      _v = SWIG_IsOK(res) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_0(self, args);
-      }
-    }
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (argc == 2) {
-    int _v;
-    {
-      char* buffer = 0;
-      size_t size = 0;
-      int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 );
-      _v = SWIG_IsOK(res) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(self, args);
-      }
-    }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_ToString",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_droplet_ToString" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  result = (GoUint32)SKY_droplet_ToString(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_cipher_GenerateDeterministicKeyPairs'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,cipher_SecKeys *)\n"
-    "    SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_CryptoTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoInt arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  GoSlice_ temp3 ;
-  GoSlice_ temp4 ;
+  GoString arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
-  }
-  {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairsSeed",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_CryptoTypeFromString",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairsSeed', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CryptoTypeFromString', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairsSeed" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairsSeed(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_wallet_CryptoTypeFromString(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -15325,55 +14988,69 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_RandByte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  GoInt arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  long long val1 ;
+  int ecode1 = 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_CheckSecKey",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  result = (GoUint32)SKY_cipher_CheckSecKey((unsigned char (*)[32])arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_RandByte",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_cipher_RandByte" "', argument " "1"" of type '" "GoInt""'");
+  } 
+  arg1 = (GoInt)(val1);
+  result = (GoUint32)SKY_cipher_RandByte(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_NewPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoSlice arg1 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_CheckSecKeyHash",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewPubKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewPubKey', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
   {
     void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
     if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
     arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cipher_CheckSecKeyHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_cipher_NewPubKey(arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15381,29 +15058,34 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  App__Handle arg1 ;
-  GoString arg2 ;
+  GoString arg1 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_App_Run",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromHex",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_App_Run', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_PubKeyFromHex', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_cli_App_Run(arg1,arg2);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg2 = &p->data;
+  }
+  result = (GoUint32)SKY_cipher_PubKeyFromHex(arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15411,38 +15093,108 @@ SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObj
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetCoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetCoin",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_Config_GetCoin(arg1,arg2);
+  result = (GoUint32)SKY_cipher_PubKeyFromSecKey((unsigned char (*)[32])arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  cipher__PubKey *arg3 = (cipher__PubKey *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_PubKeyFromSig",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg1 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_PubKeyFromSig((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[33])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle arg1 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Verify",&obj0)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
+  }
+  result = (GoUint32)SKY_cipher_PubKey_Verify((unsigned char (*)[33])arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
   GoString_ *arg2 = (GoString_ *) 0 ;
   GoString temp2 ;
   PyObject * obj0 = 0 ;
@@ -15453,11 +15205,16 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM
     temp2.n = 0;
     arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetRPCAddress",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Hex",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
-  result = (GoUint32)SKY_cli_Config_GetRPCAddress(arg1,arg2);
+  result = (GoUint32)SKY_cipher_PubKey_Hex((unsigned char (*)[33])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
@@ -15469,98 +15226,103 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  App__Handle arg1 ;
-  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
-  Handle temp2 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyRipemd160",&obj0,&obj1)) SWIG_fail;
   {
-    arg2 = &temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromApp",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
+    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_RPCClientFromApp(arg1,arg2);
+  result = (GoUint32)SKY_cipher_PubKeyRipemd160((unsigned char (*)[33])arg1,(unsigned char (*)[20])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Getenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_NewSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  GoSlice arg1 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Getenv",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSecKey",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Getenv', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSecKey', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_cli_Getenv(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_NewSecKey(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  GoString arg2 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_Setenv",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromHex",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromHex', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_Setenv(arg1,arg2);
+  result = (GoUint32)SKY_cipher_SecKeyFromHex(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15568,39 +15330,22 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObje
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoUint64 arg2 ;
-  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalance",&obj0,&obj1,&obj2)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalance" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_NewBalance" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalance" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Verify",&obj0)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
   }
-  arg3 = (wallet__Balance *)(argp3);
-  result = (GoUint32)SKY_wallet_NewBalance(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SecKey_Verify((unsigned char (*)[32])arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15608,119 +15353,114 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalanceFromUxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  coin__UxOut *arg2 = (coin__UxOut *) 0 ;
-  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalanceFromUxOut",&obj0,&obj1,&obj2)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "2"" of type '" "coin__UxOut *""'"); 
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  arg2 = (coin__UxOut *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Hex",&obj0)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
   }
-  arg3 = (wallet__Balance *)(argp3);
-  result = (GoUint32)SKY_wallet_NewBalanceFromUxOut(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SecKey_Hex((unsigned char (*)[32])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_ECDH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
-  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
-  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Add",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Add" "', argument " "1"" of type '" "wallet__Balance *""'"); 
+  {
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  arg1 = (wallet__Balance *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Add" "', argument " "2"" of type '" "wallet__Balance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_ECDH",&obj0,&obj1)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
-  arg2 = (wallet__Balance *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Add" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg2 = &p->data;
   }
-  arg3 = (wallet__Balance *)(argp3);
-  result = (GoUint32)SKY_wallet_Balance_Add(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_ECDH((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
-  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
-  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  GoSlice arg1 ;
+  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Sub",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Sub" "', argument " "1"" of type '" "wallet__Balance *""'"); 
-  }
-  arg1 = (wallet__Balance *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Sub" "', argument " "2"" of type '" "wallet__Balance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSig",&obj0,&obj1)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSig', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  arg2 = (wallet__Balance *)(argp2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Sub" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg2 = &p->data;
   }
-  arg3 = (wallet__Balance *)(argp3);
-  result = (GoUint32)SKY_wallet_Balance_Sub(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_NewSig(arg1,(unsigned char (*)[65])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15728,107 +15468,111 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Sub(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SigFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
-  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
-  GoUint8 *arg3 = (GoUint8 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  GoUint8 temp3 ;
-  int res3 = SWIG_TMPOBJ ;
+  GoString arg1 ;
+  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg3 = &temp3;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Balance_Equals",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Equals" "', argument " "1"" of type '" "wallet__Balance *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SigFromHex",&obj0,&obj1)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SigFromHex', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  arg1 = (wallet__Balance *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Equals" "', argument " "2"" of type '" "wallet__Balance *""'"); 
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg2 = &p->data;
   }
-  arg2 = (wallet__Balance *)(argp2);
-  result = (GoUint32)SKY_wallet_Balance_Equals(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SigFromHex(arg1,(unsigned char (*)[65])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res3)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_IsZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Sig_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoUint8 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Balance_IsZero",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_IsZero" "', argument " "1"" of type '" "wallet__Balance *""'"); 
-  }
-  arg1 = (wallet__Balance *)(argp1);
-  result = (GoUint32)SKY_wallet_Balance_IsZero(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  return resultobj;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Sig_Hex",&obj0)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg1 = &p->data;
+  }
+  result = (GoUint32)SKY_cipher_Sig_Hex((unsigned char (*)[65])arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
+  return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SignHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Address *arg1 = (httphelper__Address *) 0 ;
-  GoSlice arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_httphelper_Address_UnmarshalJSON",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_UnmarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SignHash",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  arg1 = (httphelper__Address *)(argp1);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Address_UnmarshalJSON', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_httphelper_Address_UnmarshalJSON(arg1,arg2);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg3 = &p->data;
+  }
+  result = (GoUint32)SKY_cipher_SignHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[65])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -15836,199 +15580,251 @@ SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_UnmarshalJSON(PyObject *SWIGUN
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyAddressSignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Address *arg1 = (httphelper__Address *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Address_MarshalJSON",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyAddressSignedHash",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_MarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_VerifyAddressSignedHash" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (httphelper__Address *)(argp1);
-  result = (GoUint32)SKY_httphelper_Address_MarshalJSON(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  arg1 = (cipher__Address *)(argp1);
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg2 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_VerifyAddressSignedHash(arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
-  GoSlice arg2 ;
-  GoUint64 temp1 ;
+  cipher__Sig *arg1 = (cipher__Sig *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_VerifySignedHash",&obj0,&obj1)) SWIG_fail;
   {
-    temp1 = 0;
-    arg1 = &temp1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Coins_UnmarshalJSON",&obj0)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Coins_UnmarshalJSON', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_httphelper_Coins_UnmarshalJSON(arg1,arg2);
+  result = (GoUint32)SKY_cipher_VerifySignedHash((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyPubKeySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoUint64 temp1 ;
-  GoSlice_ temp2 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyPubKeySignedHash",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    temp1 = 0;
-    arg1 = &temp1;
-  }
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_MarshalJSON")) SWIG_fail;
-  result = (GoUint32)SKY_httphelper_Coins_MarshalJSON(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
+    cipher_Sig* p = (cipher_Sig*)argp;
+    arg2 = &p->data;
   }
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_VerifyPubKeySignedHash((unsigned char (*)[33])arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp1 ;
-  GoUint64 temp2 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateKeyPair",&obj0,&obj1)) SWIG_fail;
   {
-    temp1 = 0;
-    arg1 = &temp1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg2 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_Value")) SWIG_fail;
-  result = (GoUint32)SKY_httphelper_Coins_Value(arg1,arg2);
+  result = (GoUint32)SKY_cipher_GenerateKeyPair((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
-  GoSlice arg2 ;
-  GoUint64 temp1 ;
+  GoSlice arg1 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
+  cipher__SecKey *arg3 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp1 = 0;
-    arg1 = &temp1;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Hours_UnmarshalJSON",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_GenerateDeterministicKeyPair",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Hours_UnmarshalJSON', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPair', expecting string");
     }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_httphelper_Hours_UnmarshalJSON(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg2 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg3 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPair(arg1,(unsigned char (*)[33])arg2,(unsigned char (*)[32])arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_DeterministicKeyPairIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
+  GoSlice arg1 ;
   coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoUint64 temp1 ;
+  cipher__PubKey *arg3 = (cipher__PubKey *) 0 ;
+  cipher__SecKey *arg4 = (cipher__SecKey *) 0 ;
   GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp1 = 0;
-    arg1 = &temp1;
-  }
   {
     temp2.data = NULL;
     temp2.len = 0;
     temp2.cap = 0;
     arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_MarshalJSON")) SWIG_fail;
-  result = (GoUint32)SKY_httphelper_Hours_MarshalJSON(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_DeterministicKeyPairIterator",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DeterministicKeyPairIterator', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg3 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg4 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_DeterministicKeyPairIterator(arg1,arg2,(unsigned char (*)[33])arg3,(unsigned char (*)[32])arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
     free( (void*)arg2->data );
@@ -16039,30 +15835,46 @@ SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_MarshalJSON(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp1 ;
-  GoUint64 temp2 ;
+  GoSlice arg1 ;
+  GoInt arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  GoSlice_ temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp1 = 0;
-    arg1 = &temp1;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairs",&obj0,&obj1)) SWIG_fail;
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairs', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_Value")) SWIG_fail;
-  result = (GoUint32)SKY_httphelper_Hours_Value(arg1,arg2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairs" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairs(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -16070,77 +15882,116 @@ SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_Value(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  wallet__Entry *arg1 = (wallet__Entry *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_Verify",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_Verify" "', argument " "1"" of type '" "wallet__Entry *""'"); 
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  arg1 = (wallet__Entry *)(argp1);
-  result = (GoUint32)SKY_wallet_Entry_Verify(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_VerifyPublic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  wallet__Entry *arg1 = (wallet__Entry *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_VerifyPublic",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_VerifyPublic" "', argument " "1"" of type '" "wallet__Entry *""'"); 
+  if (argc == 2) {
+    int _v;
+    {
+      char* buffer = 0;
+      size_t size = 0;
+      int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 );
+      _v = SWIG_IsOK(res) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_0(self, args);
+      }
+    }
   }
-  arg1 = (wallet__Entry *)(argp1);
-  result = (GoUint32)SKY_wallet_Entry_VerifyPublic(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  if (argc == 2) {
+    int _v;
+    {
+      char* buffer = 0;
+      size_t size = 0;
+      int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 );
+      _v = SWIG_IsOK(res) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(self, args);
+      }
+    }
+  }
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_cipher_GenerateDeterministicKeyPairs'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,cipher_SecKeys *)\n"
+    "    SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  GoSlice arg1 ;
+  GoInt arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  GoSlice_ temp3 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_FromString",&obj0)) SWIG_fail;
+  {
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairsSeed",&obj0,&obj1)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_droplet_FromString', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairsSeed', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_droplet_FromString(arg1,arg2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairsSeed" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairsSeed(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
   return resultobj;
 fail:
@@ -16148,68 +15999,94 @@ SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  GoString temp2 ;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_CheckSecKey",&obj0)) SWIG_fail;
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_ToString",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_droplet_ToString" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  result = (GoUint32)SKY_droplet_ToString(arg1,arg2);
+  result = (GoUint32)SKY_cipher_CheckSecKey((unsigned char (*)[32])arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_CheckSecKeyHash",&obj0,&obj1)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_CheckSecKeyHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_CryptoTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Transaction__Handle arg1 ;
+  GoSlice arg2 ;
+  CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreateTransactionResponse",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_CryptoTypeFromString",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CryptoTypeFromString', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreateTransactionResponse', expecting string");
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_wallet_CryptoTypeFromString(arg1,arg2);
+  result = (GoUint32)SKY_api_NewCreateTransactionResponse(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -16217,27 +16094,49 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_CryptoTypeFromString(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_handle_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
+  Transaction__Handle arg1 ;
+  GoSlice arg2 ;
+  CreatedTransaction__Handle *arg3 = (CreatedTransaction__Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_close",&obj0)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransaction",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  SKY_handle_close(arg1);
-  resultobj = SWIG_Py_Void();
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreatedTransaction', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_api_NewCreatedTransaction(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_CreatedTransaction_ToTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  Handle *arg2 = (Handle *) 0 ;
+  CreatedTransaction__Handle arg1 ;
+  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
   Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -16245,11 +16144,11 @@ SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObj
   {
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_copy",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_CreatedTransaction_ToTransaction",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_handle_copy(arg1,arg2);
+  result = (GoUint32)SKY_api_CreatedTransaction_ToTransaction(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
@@ -16260,82 +16159,106 @@ SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObj
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_logging_EnableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_EnableColors")) SWIG_fail;
-  result = (GoUint32)SKY_logging_EnableColors();
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_logging_DisableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  CreatedTransactionOutput__Handle *arg3 = (CreatedTransactionOutput__Handle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Handle temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_DisableColors")) SWIG_fail;
-  result = (GoUint32)SKY_logging_DisableColors();
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransactionOutput",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionOutput" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); 
+  }
+  arg1 = (coin__TransactionOutput *)(argp1);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
+  }
+  result = (GoUint32)SKY_api_NewCreatedTransactionOutput(arg1,(unsigned char (*)[32])arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_logging_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  wallet__UxBalance *arg1 = (wallet__UxBalance *) 0 ;
+  CreatedTransactionInput__Handle *arg2 = (CreatedTransactionInput__Handle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Handle temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":SKY_logging_Disable")) SWIG_fail;
-  result = (GoUint32)SKY_logging_Disable();
+  {
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewCreatedTransactionInput",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__UxBalance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionInput" "', argument " "1"" of type '" "wallet__UxBalance *""'"); 
+  }
+  arg1 = (wallet__UxBalance *)(argp1);
+  result = (GoUint32)SKY_api_NewCreatedTransactionInput(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
-  GoString arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  Handle temp1 ;
-  GoString temp3 ;
+  GoString arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg1 = &temp1;
-  }
-  {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_Get",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_String2Hex",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_Get', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_String2Hex', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_map_Get(arg1,arg2,arg3);
+  result = (GoUint32)SKY_base58_String2Hex(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -16343,32 +16266,34 @@ SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
-  GoString arg2 ;
-  Handle temp1 ;
+  GoString arg1 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  GoUint8 result;
+  GoUint32 result;
   
-  {
-    arg1 = &temp1;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_HasKey",&obj0)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToInt",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_HasKey', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToInt', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint8)SKY_map_HasKey(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
+  result = (GoUint32)SKY_base58_Base58_ToInt(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
   }
   return resultobj;
 fail:
@@ -16376,20 +16301,36 @@ SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObje
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_map_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoStringMap_ *arg1 = (GoStringMap_ *) 0 ;
-  Handle temp1 ;
+  GoString arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg1 = &temp1;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_map_Close")) SWIG_fail;
-  result = (GoUint32)SKY_map_Close(arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToHex",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToHex', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
+  }
+  result = (GoUint32)SKY_base58_Base58_ToHex(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -16397,164 +16338,141 @@ SWIGINTERN PyObject *_wrap_SKY_map_Close(PyObject *SWIGUNUSEDPARM(self), PyObjec
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   GoString arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58Address",&obj0,&obj1)) SWIG_fail;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_Base582Int",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58Address', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_Base582Int', expecting string");
     }
     (&arg1)->p = buffer;
     (&arg1)->n = size - 1;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58Address" "', argument " "2"" of type '" "cipher__Address *""'"); 
-  }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_cipher_DecodeBase58Address(arg1,arg2);
+  result = (GoUint32)SKY_base58_Base58_Base582Int(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Base582Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  GoString arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromBytes",&obj0,&obj1)) SWIG_fail;
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base582Hex",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_AddressFromBytes', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base582Hex', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
-  }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromBytes" "', argument " "2"" of type '" "cipher__Address *""'"); 
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_cipher_AddressFromBytes(arg1,arg2);
+  result = (GoUint32)SKY_base58_Base582Hex(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromPubKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
-  }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromPubKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_cipher_AddressFromPubKey((unsigned char (*)[33])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  GoString arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromSecKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_BitHex",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_BitHex', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_cipher_AddressFromSecKey((unsigned char (*)[32])arg1,arg2);
+  result = (GoUint32)SKY_base58_Base58_BitHex(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Int2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoUint8 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  GoInt arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  long long val1 ;
+  int ecode1 = 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Null",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Null" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint32)SKY_cipher_Address_Null(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Int2Base58",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_base58_Int2Base58" "', argument " "1"" of type '" "GoInt""'");
+  } 
+  arg1 = (GoInt)(val1);
+  result = (GoUint32)SKY_base58_Int2Base58(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -16562,33 +16480,36 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoSlice_ temp2 ;
+  GoSlice arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Bytes",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Bytes" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint32)SKY_cipher_Address_Bytes(arg1,arg2);
+  result = (GoUint32)SKY_base58_Hex2Base58(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -16596,44 +16517,47 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Bytes(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  GoSlice arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Verify",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Verify" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  arg1 = (cipher__Address *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58String",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58String', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_cipher_Address_Verify(arg1,(unsigned char (*)[33])arg2);
+  result = (GoUint32)SKY_base58_Hex2Base58String(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58Str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoSlice arg1 ;
   GoString_ *arg2 = (GoString_ *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
   GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -16643,13 +16567,19 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(se
     temp2.n = 0;
     arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_String",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_String" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58Str",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58Str', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint32)SKY_cipher_Address_String(arg1,arg2);
+  result = (GoUint32)SKY_base58_Hex2Base58Str(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
@@ -16661,41 +16591,42 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  cipher__Checksum *arg2 = (cipher__Checksum *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  GoString arg1 ;
+  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Checksum",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Checksum" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    arg2 = &temp2;
   }
-  arg1 = (cipher__Address *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_NewClient",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum");
-    cipher_Checksum* p = (cipher_Checksum*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_NewClient', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  result = (GoUint32)SKY_cipher_Address_Checksum(arg1,(unsigned char (*)[4])arg2);
+  result = (GoUint32)SKY_webrpc_NewClient(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
+  WebRpcClient__Handle arg1 ;
   GoString_ *arg2 = (GoString_ *) 0 ;
   GoString temp2 ;
   PyObject * obj0 = 0 ;
@@ -16706,11 +16637,11 @@ SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self),
     temp2.n = 0;
     arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_JsonEncode_Handle",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_Client_CSRF",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_JsonEncode_Handle(arg1,arg2);
+  result = (GoUint32)SKY_webrpc_Client_CSRF(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
@@ -16722,26 +16653,33 @@ SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  WebRpcClient__Handle arg1 ;
+  Transaction__Handle arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Progress_GetCurrent",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Progress_GetCurrent(arg1,arg2);
+  {
+    SWIG_AsVal_long(obj1, (long*)&arg2);
+  }
+  result = (GoUint32)SKY_webrpc_Client_InjectTransaction(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
   return resultobj;
 fail:
@@ -16749,84 +16687,108 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  WebRpcClient__Handle arg1 ;
+  StatusResult_Handle *arg2 = (StatusResult_Handle *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2 = 0;
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadSeq",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetStatus",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Block_GetHeadSeq(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StatusResult_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_webrpc_Client_GetStatus" "', argument " "2"" of type '" "StatusResult_Handle *""'"); 
   }
+  arg2 = (StatusResult_Handle *)(argp2);
+  result = (GoUint32)SKY_webrpc_Client_GetStatus(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetTransactionByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  WebRpcClient__Handle arg1 ;
+  GoString arg2 ;
+  TransactionResult_Handle *arg3 = (TransactionResult_Handle *) 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadHash",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetTransactionByID",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Block_GetHeadHash(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetTransactionByID', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_TransactionResult_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_webrpc_Client_GetTransactionByID" "', argument " "3"" of type '" "TransactionResult_Handle *""'"); 
   }
+  arg3 = (TransactionResult_Handle *)(argp3);
+  result = (GoUint32)SKY_webrpc_Client_GetTransactionByID(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  WebRpcClient__Handle arg1 ;
+  GoSlice arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetPreviousBlockHash",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetAddressUxOuts",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Block_GetPreviousBlockHash(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetAddressUxOuts', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_webrpc_Client_GetAddressUxOuts(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -16834,88 +16796,90 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
+  WebRpcClient__Handle arg1 ;
   GoUint64 arg2 ;
-  Handle *arg3 = (Handle *) 0 ;
+  GoUint64 arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
   unsigned long long val2 ;
   int ecode2 = 0 ;
-  Handle temp3 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  GoSlice_ temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Blocks_GetAt",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetBlocksInRange",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Blocks_GetAt" "', argument " "2"" of type '" "GoUint64""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "2"" of type '" "GoUint64""'");
   } 
   arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_Handle_Blocks_GetAt(arg1,arg2,arg3);
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  result = (GoUint32)SKY_webrpc_Client_GetBlocksInRange(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  WebRpcClient__Handle arg1 ;
+  GoSlice arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Blocks_GetCount",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetBlocksBySeq",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Blocks_GetCount(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
-  }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp2 = 0;
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Connections_GetCount",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetBlocksBySeq', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_Handle_Connections_GetCount(arg1,arg2);
+  result = (GoUint32)SKY_webrpc_Client_GetBlocksBySeq(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -16923,83 +16887,59 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Strings__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  WebRpcClient__Handle arg1 ;
+  GoUint64 arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_GetCount",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  result = (GoUint32)SKY_Handle_Strings_GetCount(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Strings__Handle arg1 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_Sort",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetLastBlocks",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_Handle_Strings_Sort(arg1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetLastBlocks" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_webrpc_Client_GetLastBlocks(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_LoadConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Strings__Handle arg1 ;
-  GoInt arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  GoString temp3 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  Config__Handle *arg1 = (Config__Handle *) 0 ;
+  Handle temp1 ;
   GoUint32 result;
   
   {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Strings_GetAt",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg1 = &temp1;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Strings_GetAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_Handle_Strings_GetAt(arg1,arg2,arg3);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_LoadConfig")) SWIG_fail;
+  result = (GoUint32)SKY_cli_LoadConfig(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
   return resultobj;
 fail:
@@ -17007,9 +16947,9 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullWalletPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
+  Config__Handle arg1 ;
   GoString_ *arg2 = (GoString_ *) 0 ;
   GoString temp2 ;
   PyObject * obj0 = 0 ;
@@ -17020,11 +16960,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUS
     temp2.n = 0;
     arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletDir",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullWalletPath",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_Client_GetWalletDir(arg1,arg2);
+  result = (GoUint32)SKY_cli_Config_FullWalletPath(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
@@ -17036,9 +16976,9 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullDBPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
+  Config__Handle arg1 ;
   GoString_ *arg2 = (GoString_ *) 0 ;
   GoString temp2 ;
   PyObject * obj0 = 0 ;
@@ -17049,11 +16989,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWI
     temp2.n = 0;
     arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletFileName",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullDBPath",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_Client_GetWalletFileName(arg1,arg2);
+  result = (GoUint32)SKY_cli_Config_FullDBPath(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
@@ -17065,28 +17005,25 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWI
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Config__Handle arg1 ;
+  App__Handle *arg2 = (App__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletLabel",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_NewApp",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_Client_GetWalletLabel(arg1,arg2);
+  result = (GoUint32)SKY_cli_NewApp(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -17094,33 +17031,25 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletLabel(PyObject *SWIGUN
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFullPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Client__Handle arg1 ;
-  WalletResponse__Handle arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString temp3 ;
+  Context__Handle arg1 ;
+  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_Client_GetWalletFullPath",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromContext",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
-  }
-  result = (GoUint32)SKY_api_Handle_Client_GetWalletFullPath(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cli_RPCClientFromContext(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -17128,10 +17057,10 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFullPath(PyObject *SWI
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoStringMap_ *arg2 = (GoStringMap_ *) 0 ;
+  Context__Handle arg1 ;
+  Config__Handle *arg2 = (Config__Handle *) 0 ;
   Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
@@ -17139,11 +17068,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM
   {
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletMeta",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_ConfigFromContext",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_GetWalletMeta(arg1,arg2);
+  result = (GoUint32)SKY_cli_ConfigFromContext(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
@@ -17154,27 +17083,36 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromBytes_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
-  PyObject * obj0 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoSlice_ temp2 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletEntriesCount",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  result = (GoUint32)SKY_api_Handle_GetWalletEntriesCount(arg1,arg2);
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromBytes_Password")) SWIG_fail;
+  result = (GoUint32)SKY_cli_PasswordFromBytes_Password(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -17182,122 +17120,74 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUN
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
-  PyObject * obj0 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletResponseEntriesCount",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  result = (GoUint32)SKY_api_Handle_Client_GetWalletResponseEntriesCount(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromTerm_Password")) SWIG_fail;
+  result = (GoUint32)SKY_cli_PasswordFromTerm_Password(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
-  }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoUint32 arg2 ;
-  cipher__Address *arg3 = (cipher__Address *) 0 ;
-  cipher__PubKey *arg4 = (cipher__PubKey *) 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Handle_WalletGetEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "2"" of type '" "GoUint32""'");
-  } 
-  arg2 = (GoUint32)(val2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "3"" of type '" "cipher__Address *""'"); 
-  }
-  arg3 = (cipher__Address *)(argp3);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj3, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg4 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
   }
-  result = (GoUint32)SKY_api_Handle_WalletGetEntry(arg1,arg2,arg3,(unsigned char (*)[33])arg4);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_GenerateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
-  GoUint32 arg2 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString_ *arg4 = (GoString_ *) 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  GoString temp3 ;
-  GoString temp4 ;
+  GoString arg1 ;
+  Options__Handle *arg2 = (Options__Handle *) 0 ;
+  GoUint64 arg3 ;
+  Wallet__Handle *arg4 = (Wallet__Handle *) 0 ;
+  Handle temp2 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  Handle temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
+    arg2 = &temp2;
   }
   {
-    temp4.p = NULL;
-    temp4.n = 0;
-    arg4 = (GoString_ *)&temp4;
+    arg4 = &temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletResponseGetEntry",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GenerateWallet",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateWallet', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletResponseGetEntry" "', argument " "2"" of type '" "GoUint32""'");
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_cli_GenerateWallet" "', argument " "3"" of type '" "GoUint64""'");
   } 
-  arg2 = (GoUint32)(val2);
-  result = (GoUint32)SKY_api_Handle_WalletResponseGetEntry(arg1,arg2,arg3,arg4);
+  arg3 = (GoUint64)(val3);
+  result = (GoUint32)SKY_cli_GenerateWallet(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
-    free( (void*)arg4->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
   }
   return resultobj;
 fail:
@@ -17305,27 +17195,23 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetEntry(PyObject *SWIGU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseIsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_MakeAlphanumericSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoUint8 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
-  PyObject * obj0 = 0 ;
+  GoString_ *arg1 = (GoString_ *) 0 ;
+  GoString temp1 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseIsEncrypted",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp1.p = NULL;
+    temp1.n = 0;
+    arg1 = (GoString_ *)&temp1;
   }
-  result = (GoUint32)SKY_api_Handle_WalletResponseIsEncrypted(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_MakeAlphanumericSeed")) SWIG_fail;
+  result = (GoUint32)SKY_cli_MakeAlphanumericSeed(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
+    free( (void*)arg1->p );
   }
   return resultobj;
 fail:
@@ -17333,28 +17219,58 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseIsEncrypted(PyObject *SW
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetCryptoType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WalletResponse__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Block__Handle arg1 ;
+  GoUint64 arg2 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  Transactions__Handle arg4 ;
+  FeeCalculator *arg5 = (FeeCalculator *) 0 ;
+  Block__Handle *arg6 = (Block__Handle *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  FeeCalculator temp5 ;
+  Handle temp6 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    arg6 = &temp6;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseGetCryptoType",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_coin_NewBlock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_WalletResponseGetCryptoType(arg1,arg2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewBlock" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
+  }
+  {
+    SWIG_AsVal_long(obj3, (long*)&arg4);
+  }
+  {
+    if (!PyCallable_Check(obj4)) SWIG_fail;
+    temp5.callback = _WrapperFeeCalculator;
+    temp5.context = obj4;
+    arg5 = &temp5;
+  }
+  result = (GoUint32)SKY_coin_NewBlock(arg1,arg2,(unsigned char (*)[32])arg3,arg4,arg5,arg6);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
   }
   return resultobj;
 fail:
@@ -17362,62 +17278,79 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetCryptoType(PyObject *
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_SignedBlock_VerifySignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallets__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  coin__SignedBlock *arg1 = (coin__SignedBlock *) 0 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletsResponseGetCount",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SignedBlock_VerifySignature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__SignedBlock, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SignedBlock_VerifySignature" "', argument " "1"" of type '" "coin__SignedBlock *""'"); 
+  }
+  arg1 = (coin__SignedBlock *)(argp1);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_api_Handle_WalletsResponseGetCount(arg1,arg2);
+  result = (GoUint32)SKY_coin_SignedBlock_VerifySignature(arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewGenesisBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallets__Handle arg1 ;
-  GoUint32 arg2 ;
-  WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ;
-  unsigned int val2 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoUint64 arg2 ;
+  GoUint64 arg3 ;
+  Block__Handle *arg4 = (Block__Handle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned long long val2 ;
   int ecode2 = 0 ;
-  Handle temp3 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  Handle temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletsResponseGetAt",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg4 = &temp4;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewGenesisBlock",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  }
+  arg1 = (cipher__Address *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletsResponseGetAt" "', argument " "2"" of type '" "GoUint32""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "2"" of type '" "GoUint64""'");
   } 
-  arg2 = (GoUint32)(val2);
-  result = (GoUint32)SKY_api_Handle_WalletsResponseGetAt(arg1,arg2,arg3);
+  arg2 = (GoUint64)(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  result = (GoUint32)SKY_coin_NewGenesisBlock(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
   }
   return resultobj;
 fail:
@@ -17425,86 +17358,82 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Block__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletFolderAddress",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashHeader",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_GetWalletFolderAddress(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Block_HashHeader(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_PreHashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Block__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletSeed",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_PreHashHeader",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_GetWalletSeed(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_coin_Block_PreHashHeader(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Block__Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletLastSeed",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Time",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_GetWalletLastSeed(arg1,arg2);
+  result = (GoUint32)SKY_coin_Block_Time(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -17512,50 +17441,26 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSED
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_Seq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  BuildInfo_Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString_ *arg3 = (GoString_ *) 0 ;
-  GoString_ *arg4 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  GoString temp3 ;
-  GoString temp4 ;
+  Block__Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  {
-    temp3.p = NULL;
-    temp3.n = 0;
-    arg3 = (GoString_ *)&temp3;
-  }
-  {
-    temp4.p = NULL;
-    temp4.n = 0;
-    arg4 = (GoString_ *)&temp4;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetBuildInfoData",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Seq",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_api_Handle_GetBuildInfoData(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_coin_Block_Seq(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
-    free( (void*)arg3->p );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
-    free( (void*)arg4->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
   return resultobj;
 fail:
@@ -17563,22 +17468,18 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
+  Block__Handle arg1 ;
   cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_Hash",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_Hash" "', argument " "1"" of type '" "coin__UxOut *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashBody",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg1 = (coin__UxOut *)(argp1);
   {
     void *argp = 0;
     int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
@@ -17587,7 +17488,7 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), P
     cipher_SHA256* p = (cipher_SHA256*)argp;
     arg2 = &p->data;
   }
-  result = (GoUint32)SKY_coin_UxOut_Hash(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_coin_Block_HashBody(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -17595,137 +17496,229 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), P
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_SnapshotHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Block__Handle arg1 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  GoUint32 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_SnapshotHash",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_SnapshotHash" "', argument " "1"" of type '" "coin__UxOut *""'"); 
-  }
-  arg1 = (coin__UxOut *)(argp1);
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Size",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_UxOut_SnapshotHash(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_coin_Block_Size(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxBody *arg1 = (coin__UxBody *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Block__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxBody_Hash",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxBody, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxBody_Hash" "', argument " "1"" of type '" "coin__UxBody *""'"); 
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  arg1 = (coin__UxBody *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_String",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_UxBody_Hash(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_coin_Block_String(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_CoinHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_Block_GetTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
-  GoUint64 arg2 ;
-  GoUint64 *arg3 = (GoUint64 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  GoUint64 temp3 ;
+  Block__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  Transaction__Handle *arg3 = (Transaction__Handle *) 0 ;
+  GoUint8 *arg4 = (GoUint8 *) 0 ;
+  Handle temp3 ;
+  GoUint8 temp4 ;
+  int res4 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp3 = 0;
     arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_CoinHours",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "1"" of type '" "coin__UxOut *""'"); 
-  }
-  arg1 = (coin__UxOut *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_coin_UxOut_CoinHours(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_GetTransaction",&obj0,&obj1)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  return resultobj;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
+  }
+  result = (GoUint32)SKY_coin_Block_GetTransaction(arg1,(unsigned char (*)[32])arg2,arg3,arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
+  if (SWIG_IsTmpObj(res4)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
+  }
+  return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewBlockHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
-  GoSlice_ temp2 ;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  GoUint64 arg3 ;
+  GoUint64 arg4 ;
+  BlockBody__Handle arg5 ;
+  coin__BlockHeader *arg6 = (coin__BlockHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned long long val3 ;
+  int ecode3 = 0 ;
+  unsigned long long val4 ;
+  int ecode4 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_coin_NewBlockHeader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewBlockHeader" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+  }
+  arg1 = (coin__BlockHeader *)(argp1);
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
+  }
+  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewBlockHeader" "', argument " "3"" of type '" "GoUint64""'");
+  } 
+  arg3 = (GoUint64)(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_NewBlockHeader" "', argument " "4"" of type '" "GoUint64""'");
+  } 
+  arg4 = (GoUint64)(val4);
+  {
+    SWIG_AsVal_long(obj4, (long*)&arg5);
+  }
+  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_coin_NewBlockHeader" "', argument " "6"" of type '" "coin__BlockHeader *""'"); 
+  }
+  arg6 = (coin__BlockHeader *)(argp6);
+  result = (GoUint32)SKY_coin_NewBlockHeader(arg1,(unsigned char (*)[32])arg2,arg3,arg4,arg5,arg6);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockHeader_Hash",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Hash" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+  }
+  arg1 = (coin__BlockHeader *)(argp1);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_coin_BlockHeader_Hash(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
   {
     temp2.data = NULL;
     temp2.len = 0;
     temp2.cap = 0;
     arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Hashes")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Hashes(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_Bytes",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Bytes" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
   }
+  arg1 = (coin__BlockHeader *)(argp1);
+  result = (GoUint32)SKY_coin_BlockHeader_Bytes(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
     free( (void*)arg2->data );
@@ -17736,68 +17729,91 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (argc == 0) {
-    return _wrap_SKY_coin_UxArray_Hashes__SWIG_1(self, args);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_String",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_String" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
   }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_UxArray_Hashes__SWIG_0(self, args);
-    }
+  arg1 = (coin__BlockHeader *)(argp1);
+  result = (GoUint32)SKY_coin_BlockHeader_String(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BlockBody__Handle arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockBody_Hash",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
+  }
+  result = (GoUint32)SKY_coin_BlockBody_Hash(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Hashes'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Hashes(coin_UxOutArray *,cipher_SHA256s *)\n"
-    "    SKY_coin_UxArray_Hashes(coin__UxArray *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoSlice_ temp1 ;
-  GoUint8 temp2 ;
+  BlockBody__Handle *arg1 = (BlockBody__Handle *) 0 ;
+  GoUint32 *arg2 = (GoUint32 *) 0 ;
+  Handle temp1 ;
+  GoUint32 temp2 ;
   int res2 = SWIG_TMPOBJ ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    arg1 = &temp1;
   }
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_HasDupes")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_HasDupes(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_BlockBody_Size")) SWIG_fail;
+  result = (GoUint32)SKY_coin_BlockBody_Size(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
   }
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
   } else {
     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
   }
   return resultobj;
 fail:
@@ -17805,93 +17821,29 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 0) {
-    return _wrap_SKY_coin_UxArray_HasDupes__SWIG_1(self, args);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_UxArray_HasDupes__SWIG_0(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_HasDupes'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_HasDupes(coin_UxOutArray *,GoUint8 *)\n"
-    "    SKY_coin_UxArray_HasDupes(coin__UxArray *,GoUint8 *)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
+  BlockBody__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
-  }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sort")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Sort(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoSlice_ temp1 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
-  GoUint32 result;
-  
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockBody_Bytes",&obj0)) SWIG_fail;
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Len")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Len(arg1,arg2);
+  result = (GoUint32)SKY_coin_BlockBody_Bytes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
-  }
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -17899,52 +17851,38 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Len(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoInt arg2 ;
-  GoInt arg3 ;
-  GoUint8 *arg4 = (GoUint8 *) 0 ;
-  GoSlice_ temp1 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
-  GoUint8 temp4 ;
-  int res4 = SWIG_TMPOBJ ;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  Transaction__Handle arg2 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Less",&obj0,&obj1)) SWIG_fail;
-  ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Less" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Less" "', argument " "3"" of type '" "GoInt""'");
-  } 
-  arg3 = (GoInt)(val3);
-  result = (GoUint32)SKY_coin_UxArray_Less(arg1,arg2,arg3,arg4);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_CreateUnspents",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspents" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+  }
+  arg1 = (coin__BlockHeader *)(argp1);
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
-  if (SWIG_IsTmpObj(res4)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
+  result = (GoUint32)SKY_coin_CreateUnspents(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -17952,194 +17890,147 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less__SWIG_1(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents(PyObject *self, PyObject *args) {
   Py_ssize_t argc;
-  PyObject *argv[4] = {
+  PyObject *argv[3] = {
     0
   };
   Py_ssize_t ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
   argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    {
-      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
       {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
+        _v = PyInt_Check(argv[1]) ? 1 : 0;
       }
       if (_v) {
-        return _wrap_SKY_coin_UxArray_Less__SWIG_1(self, args);
+        return _wrap_SKY_coin_CreateUnspents__SWIG_0(self, args);
       }
     }
   }
-  if (argc == 3) {
+  if (argc == 2) {
     int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
       {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
+        _v = PyInt_Check(argv[1]) ? 1 : 0;
       }
       if (_v) {
-        {
-          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_SKY_coin_UxArray_Less__SWIG_0(self, args);
-        }
+        return _wrap_SKY_coin_CreateUnspents__SWIG_1(self, args);
       }
     }
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Less'.\n"
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_CreateUnspents'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Less(coin_UxOutArray *,GoInt,GoInt,GoUint8 *)\n"
-    "    SKY_coin_UxArray_Less(coin__UxArray *,GoInt,GoInt,GoUint8 *)\n");
+    "    wrap_SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin_UxOutArray *)\n"
+    "    SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin__UxArray *)\n");
   return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoInt arg2 ;
+  coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ;
+  Transaction__Handle arg2 ;
   GoInt arg3 ;
-  GoSlice_ temp1 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  coin__UxOut *arg4 = (coin__UxOut *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   long long val3 ;
   int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_CreateUnspent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspent" "', argument " "1"" of type '" "coin__BlockHeader *""'"); 
+  }
+  arg1 = (coin__BlockHeader *)(argp1);
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Swap",&obj0,&obj1)) SWIG_fail;
-  ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Swap" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3);
+  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Swap" "', argument " "3"" of type '" "GoInt""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_CreateUnspent" "', argument " "3"" of type '" "GoInt""'");
   } 
   arg3 = (GoInt)(val3);
-  result = (GoUint32)SKY_coin_UxArray_Swap(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SKY_coin_CreateUnspent" "', argument " "4"" of type '" "coin__UxOut *""'"); 
   }
+  arg4 = (coin__UxOut *)(argp4);
+  result = (GoUint32)SKY_coin_CreateUnspent(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[4] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Block__Handle arg1 ;
+  coin__Block **arg2 = (coin__Block **) 0 ;
+  coin__Block *temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    temp2 = NULL;
+    arg2 = &temp2;
   }
-  if (argc == 2) {
-    int _v;
-    {
-      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_SKY_coin_UxArray_Swap__SWIG_1(self, args);
-      }
-    }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockObject",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 3) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_SKY_coin_UxArray_Swap__SWIG_0(self, args);
-        }
-      }
-    }
+  result = (GoUint32)SKY_coin_GetBlockObject(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Block, 0 ));
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Swap'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Swap(coin_UxOutArray *,GoInt,GoInt)\n"
-    "    SKY_coin_UxArray_Swap(coin__UxArray *,GoInt,GoInt)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoSlice_ temp1 ;
-  GoUint64 temp2 ;
+  Block__Handle arg1 ;
+  BlockBody__Handle *arg2 = (BlockBody__Handle *) 0 ;
+  Handle temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
-  }
-  {
-    temp2 = 0;
     arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Coins")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Coins(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockBody",&obj0)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
+  result = (GoUint32)SKY_coin_GetBlockBody(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -18147,76 +18038,25 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins__SWIG_1(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 0) {
-    return _wrap_SKY_coin_UxArray_Coins__SWIG_1(self, args);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_UxArray_Coins__SWIG_0(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Coins'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Coins(coin_UxOutArray *,GoUint64 *)\n"
-    "    SKY_coin_UxArray_Coins(coin__UxArray *,GoUint64 *)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewEmptyBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoUint64 arg2 ;
-  GoUint64 *arg3 = (GoUint64 *) 0 ;
-  GoSlice_ temp1 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  GoUint64 temp3 ;
+  Transactions__Handle arg1 ;
+  Block__Handle *arg2 = (Block__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_NewEmptyBlock",&obj0)) SWIG_fail;
   {
-    temp3 = 0;
-    arg3 = &temp3;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_UxArray_CoinHours",&obj0)) SWIG_fail;
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_CoinHours" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_coin_UxArray_CoinHours(arg1,arg2,arg3);
+  result = (GoUint32)SKY_coin_NewEmptyBlock(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -18224,95 +18064,58 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours__SWIG_1(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  App__Handle arg1 ;
+  GoString arg2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_SKY_coin_UxArray_CoinHours__SWIG_1(self, args);
-    }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_App_Run",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_SKY_coin_UxArray_CoinHours__SWIG_0(self, args);
-      }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_App_Run', expecting string");
     }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  
+  result = (GoUint32)SKY_cli_App_Run(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_CoinHours'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_CoinHours(coin_UxOutArray *,GoUint64,GoUint64 *)\n"
-    "    SKY_coin_UxArray_CoinHours(coin__UxArray *,GoUint64,GoUint64 *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetCoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
-  GoSlice_ temp2 ;
-  GoSlice_ temp3 ;
+  Config__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
-  }
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetCoin",&obj0)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sub")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Sub(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cli_Config_GetCoin(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -18320,87 +18123,28 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub__SWIG_1(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 0) {
-    return _wrap_SKY_coin_UxArray_Sub__SWIG_1(self, args);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_UxArray_Sub__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Sub'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Sub(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n"
-    "    SKY_coin_UxArray_Sub(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
-  GoSlice_ temp2 ;
-  GoSlice_ temp3 ;
+  Config__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
-  }
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetRPCAddress",&obj0)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Add")) SWIG_fail;
-  result = (GoUint32)SKY_coin_UxArray_Add(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cli_Config_GetRPCAddress(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -18408,71 +18152,61 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add__SWIG_1(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  App__Handle arg1 ;
+  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
+  Handle temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    arg2 = &temp2;
   }
-  if (argc == 0) {
-    return _wrap_SKY_coin_UxArray_Add__SWIG_1(self, args);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromApp",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_UxArray_Add__SWIG_0(self, args);
-      }
-    }
+  result = (GoUint32)SKY_cli_RPCClientFromApp(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Add'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_UxArray_Add(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n"
-    "    SKY_coin_UxArray_Add(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cli_Getenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  AddressUxOuts_Handle *arg2 = (AddressUxOuts_Handle *) 0 ;
-  GoSlice_ temp1 ;
-  Handle temp2 ;
+  GoString arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Getenv",&obj0)) SWIG_fail;
   {
-    arg2 = &temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Getenv', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_NewAddressUxOuts")) SWIG_fail;
-  result = (GoUint32)SKY_coin_NewAddressUxOuts(arg1,arg2);
+  result = (GoUint32)SKY_cli_Getenv(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -18480,204 +18214,178 @@ SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoString arg1 ;
+  GoString arg2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 0) {
-    return _wrap_SKY_coin_NewAddressUxOuts__SWIG_1(self, args);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_Setenv",&obj0,&obj1)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string");
     }
-    if (_v) {
-      return _wrap_SKY_coin_NewAddressUxOuts__SWIG_0(self, args);
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string");
     }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  
+  result = (GoUint32)SKY_cli_Setenv(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_NewAddressUxOuts'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_NewAddressUxOuts(coin_UxOutArray *,AddressUxOuts_Handle *)\n"
-    "    SKY_coin_NewAddressUxOuts(coin__UxArray *,AddressUxOuts_Handle *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Ripemd160_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  cipher__Ripemd160 *arg1 = (cipher__Ripemd160 *) 0 ;
+  GoSlice arg2 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Ripemd160_Set",&obj0,&obj1)) SWIG_fail;
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
+    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Keys",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_Ripemd160_Set', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_coin_AddressUxOuts_Keys(arg1,arg2);
+  result = (GoUint32)SKY_cipher_Ripemd160_Set((unsigned char (*)[20])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_0(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Keys'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,cipher_Addresses *)\n"
-    "    SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,coin__UxArray *)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  GoSlice arg1 ;
+  cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_HashRipemd160",&obj0,&obj1)) SWIG_fail;
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_HashRipemd160', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Flatten",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
+    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_coin_AddressUxOuts_Flatten(arg1,arg2);
+  result = (GoUint32)SKY_cipher_HashRipemd160(arg1,(unsigned char (*)[20])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  GoSlice arg2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_0(self, args);
-    }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256_Set",&obj0,&obj1)) SWIG_fail;
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(self, args);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256_Set', expecting string");
     }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  
+  result = (GoUint32)SKY_cipher_SHA256_Set((unsigned char (*)[32])arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Flatten'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin_UxOutArray *)\n"
-    "    SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  AddressUxOuts_Handle arg2 ;
-  AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ;
-  Handle temp3 ;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Sub",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Hex",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  result = (GoUint32)SKY_coin_AddressUxOuts_Sub(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SHA256_Hex((unsigned char (*)[32])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -18685,221 +18393,257 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Sub(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  AddressUxOuts_Handle arg2 ;
-  AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ;
-  Handle temp3 ;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SHA256_Xor",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    arg3 = &temp3;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Add",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
   }
-  result = (GoUint32)SKY_coin_AddressUxOuts_Add(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SHA256_Xor((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SumSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  GoSlice_ temp3 ;
+  GoSlice arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SumSHA256",&obj0,&obj1)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SumSHA256', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Get",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Get" "', argument " "2"" of type '" "cipher__Address *""'"); 
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_coin_AddressUxOuts_Get(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_SumSHA256(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_0(self, args);
-      }
+SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256FromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoString arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256FromHex",&obj0,&obj1)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256FromHex', expecting string");
     }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(self, args);
-      }
-    }
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  
+  result = (GoUint32)SKY_cipher_SHA256FromHex(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Get'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n"
-    "    SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  GoUint8 *arg3 = (GoUint8 *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  GoUint8 temp3 ;
-  int res3 = SWIG_TMPOBJ ;
+  GoSlice arg1 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg3 = &temp3;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_HasKey",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DoubleSHA256",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DoubleSHA256', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_HasKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_coin_AddressUxOuts_HasKey(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_DoubleSHA256(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res3)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_GetOutputLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_AddSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  GoInt *arg3 = (GoInt *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  GoInt temp3 ;
-  int res3 = SWIG_TMPOBJ ;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  arg3 = &temp3;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_GetOutputLength",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_AddSHA256",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_GetOutputLength" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_coin_AddressUxOuts_GetOutputLength(arg1,arg2,arg3);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg3 = &p->data;
+  }
+  result = (GoUint32)SKY_cipher_AddSHA256((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res3)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long_long, new_flags));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_Merkle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoSlice *arg1 = (GoSlice *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Merkle",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GoSlice, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Merkle" "', argument " "1"" of type '" "GoSlice *""'"); 
+  }
+  arg1 = (GoSlice *)(argp1);
+  {
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
+  result = (GoUint32)SKY_cipher_Merkle(arg1,(unsigned char (*)[32])arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
+  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoUint8 temp2 ;
   int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Length",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Null",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg1 = &p->data;
   }
-  result = (GoUint32)SKY_coin_AddressUxOuts_Length(arg1,arg2);
+  result = (GoUint32)SKY_cipher_SHA256_Null((unsigned char (*)[32])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
   } else {
     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -18907,213 +18651,198 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  AddressUxOuts_Handle arg1 ;
+  GoString arg1 ;
   cipher__Address *arg2 = (cipher__Address *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
   void *argp2 = 0 ;
   int res2 = 0 ;
-  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58Address",&obj0,&obj1)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Set",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58Address', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Set" "', argument " "2"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58Address" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
   arg2 = (cipher__Address *)(argp2);
-  result = (GoUint32)SKY_coin_AddressUxOuts_Set(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_DecodeBase58Address(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[4] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  GoSlice arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(self, args);
-      }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromBytes",&obj0,&obj1)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_AddressFromBytes', expecting string");
     }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  if (argc == 3) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          _v = PyList_Check(argv[2]) ? 1 : 0;
-        }
-        if (_v) {
-          return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_0(self, args);
-        }
-      }
-    }
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromBytes" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
-  
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_cipher_AddressFromBytes(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Set'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n"
-    "    SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoSlice arg2 ;
-  GoSlice arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoSlice_ temp4 ;
+  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromPubKey",&obj0,&obj1)) SWIG_fail;
   {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg1 = &p->data;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Encrypt",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Encrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromPubKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_cipher_AddressFromPubKey((unsigned char (*)[33])arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
+    cipher_SecKey* p = (cipher_SecKey*)argp;
+    arg1 = &p->data;
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string");
-    }
-    (&arg3)->data = buffer;
-    (&arg3)->len = size - 1;
-    (&arg3)->cap = size;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromSecKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
-  result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Encrypt(arg1,arg2,arg3,arg4);
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_cipher_AddressFromSecKey((unsigned char (*)[32])arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoSlice arg2 ;
-  GoSlice arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  GoSlice_ temp4 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Decrypt",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Null",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Decrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Null" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint32)SKY_cipher_Address_Null(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string");
-    }
-    (&arg3)->data = buffer;
-    (&arg3)->len = size - 1;
-    (&arg3)->cap = size;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Decrypt(arg1,arg2,arg3,arg4);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Bytes",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Bytes" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  }
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint32)SKY_cipher_Address_Bytes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -19121,180 +18850,96 @@ SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt(PyObject *
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_wallet_CreateOptionsHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoUint8 arg4 ;
-  GoString arg5 ;
-  GoString arg6 ;
-  GoUint64 arg7 ;
-  Options__Handle *arg8 = (Options__Handle *) 0 ;
-  unsigned char val4 ;
-  int ecode4 = 0 ;
-  unsigned long long val7 ;
-  int ecode7 = 0 ;
-  Handle temp8 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
-  PyObject * obj6 = 0 ;
   GoUint32 result;
   
-  {
-    arg8 = &temp8;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SKY_wallet_CreateOptionsHandle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
-  }
-  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "4"" of type '" "GoUint8""'");
-  } 
-  arg4 = (GoUint8)(val4);
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
-    }
-    (&arg5)->p = buffer;
-    (&arg5)->n = size - 1;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Verify",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Verify" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
+  arg1 = (cipher__Address *)(argp1);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string");
-    }
-    (&arg6)->p = buffer;
-    (&arg6)->n = size - 1;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
+    cipher_PubKey* p = (cipher_PubKey*)argp;
+    arg2 = &p->data;
   }
-  ecode7 = SWIG_AsVal_unsigned_SS_long_SS_long(obj6, &val7);
-  if (!SWIG_IsOK(ecode7)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "7"" of type '" "GoUint64""'");
-  } 
-  arg7 = (GoUint64)(val7);
-  result = (GoUint32)SKY_wallet_CreateOptionsHandle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+  result = (GoUint32)SKY_cipher_Address_Verify(arg1,(unsigned char (*)[33])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg8));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Wallet__Handle arg1 ;
-  GoString arg2 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_AddPrivateKey",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKey', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_String",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_String" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  result = (GoUint32)SKY_cli_AddPrivateKey(arg1,arg2);
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint32)SKY_cipher_Address_String(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKeyToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString arg2 ;
-  PasswordReader__Handle arg3 ;
-  void *argp3 ;
-  int res3 = 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  cipher__Checksum *arg2 = (cipher__Checksum *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_AddPrivateKeyToFile",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Checksum",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Checksum" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
+  arg1 = (cipher__Address *)(argp1);
   {
-    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle,  0 );
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); 
-    }  
-    if (!argp3) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'");
-    } else {
-      arg3 = *((PasswordReader__Handle *)(argp3));
-    }
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum");
+    cipher_Checksum* p = (cipher_Checksum*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_AddPrivateKeyToFile(arg1,arg2,arg3);
+  result = (GoUint32)SKY_cipher_Address_Checksum(arg1,(unsigned char (*)[4])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -19302,12 +18947,39 @@ SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKeyToFile(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  GoUint64 arg1 ;
+  GoUint64 arg2 ;
+  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchInterruptPanic")) SWIG_fail;
-  result = (GoUint32)SKY_apputil_CatchInterruptPanic();
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalance",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalance" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_NewBalance" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalance" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  }
+  arg3 = (wallet__Balance *)(argp3);
+  result = (GoUint32)SKY_wallet_NewBalance(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -19315,12 +18987,39 @@ SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalanceFromUxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  GoUint64 arg1 ;
+  coin__UxOut *arg2 = (coin__UxOut *) 0 ;
+  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
+  unsigned long long val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchDebug")) SWIG_fail;
-  result = (GoUint32)SKY_apputil_CatchDebug();
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalanceFromUxOut",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "1"" of type '" "GoUint64""'");
+  } 
+  arg1 = (GoUint64)(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "2"" of type '" "coin__UxOut *""'"); 
+  }
+  arg2 = (coin__UxOut *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  }
+  arg3 = (wallet__Balance *)(argp3);
+  result = (GoUint32)SKY_wallet_NewBalanceFromUxOut(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -19328,122 +19027,79 @@ SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_apputil_PrintProgramStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
+  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
+  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
+  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_PrintProgramStatus")) SWIG_fail;
-  result = (GoUint32)SKY_apputil_PrintProgramStatus();
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString arg2 ;
-  GoSlice arg3 ;
-  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg5 = (coin__UxArray *) 0 ;
-  GoSlice_ temp4 ;
-  GoSlice_ temp5 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp4.data = NULL;
-    temp4.len = 0;
-    temp4.cap = 0;
-    arg4 = (coin__UxArray *)&temp4;
-  }
-  {
-    temp5.data = NULL;
-    temp5.len = 0;
-    temp5.cap = 0;
-    arg5 = (coin__UxArray *)&temp5;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_certutil_NewTLSCertPair",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Add",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Add" "', argument " "1"" of type '" "wallet__Balance *""'"); 
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+  arg1 = (wallet__Balance *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Add" "', argument " "2"" of type '" "wallet__Balance *""'"); 
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
-    }
-    (&arg3)->data = buffer;
-    (&arg3)->len = size - 1;
-    (&arg3)->cap = size;
+  arg2 = (wallet__Balance *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Add" "', argument " "3"" of type '" "wallet__Balance *""'"); 
   }
-  result = (GoUint32)SKY_certutil_NewTLSCertPair(arg1,arg2,arg3,arg4,arg5);
+  arg3 = (wallet__Balance *)(argp3);
+  result = (GoUint32)SKY_wallet_Balance_Add(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
-    free( (void*)arg4->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len  ));
-    free( (void*)arg5->data );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoUint64 arg2 ;
-  GoUint32 arg3 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
+  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
+  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
+  wallet__Balance *arg3 = (wallet__Balance *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFee",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Sub",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Sub" "', argument " "1"" of type '" "wallet__Balance *""'"); 
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "3"" of type '" "GoUint32""'");
-  } 
-  arg3 = (GoUint32)(val3);
-  result = (GoUint32)SKY_fee_VerifyTransactionFee(arg1,arg2,arg3);
+  arg1 = (wallet__Balance *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Sub" "', argument " "2"" of type '" "wallet__Balance *""'"); 
+  }
+  arg2 = (wallet__Balance *)(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Sub" "', argument " "3"" of type '" "wallet__Balance *""'"); 
+  }
+  arg3 = (wallet__Balance *)(argp3);
+  result = (GoUint32)SKY_wallet_Balance_Sub(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -19451,79 +19107,72 @@ SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFee(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFeeForHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoUint64 arg2 ;
-  GoUint32 arg3 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
+  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
+  wallet__Balance *arg2 = (wallet__Balance *) 0 ;
+  GoUint8 *arg3 = (GoUint8 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  GoUint8 temp3 ;
+  int res3 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFeeForHours",&obj0,&obj1,&obj2)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "3"" of type '" "GoUint32""'");
-  } 
-  arg3 = (GoUint32)(val3);
-  result = (GoUint32)SKY_fee_VerifyTransactionFeeForHours(arg1,arg2,arg3);
+  arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Balance_Equals",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Equals" "', argument " "1"" of type '" "wallet__Balance *""'"); 
+  }
+  arg1 = (wallet__Balance *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Equals" "', argument " "2"" of type '" "wallet__Balance *""'"); 
+  }
+  arg2 = (wallet__Balance *)(argp2);
+  result = (GoUint32)SKY_wallet_Balance_Equals(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res3)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_IsZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoUint32 arg2 ;
-  GoUint64 *arg3 = (GoUint64 *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  GoUint64 temp3 ;
+  wallet__Balance *arg1 = (wallet__Balance *) 0 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp3 = 0;
-    arg3 = &temp3;
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Balance_IsZero",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_IsZero" "', argument " "1"" of type '" "wallet__Balance *""'"); 
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RequiredFee",&obj0,&obj1)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RequiredFee" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RequiredFee" "', argument " "2"" of type '" "GoUint32""'");
-  } 
-  arg2 = (GoUint32)(val2);
-  result = (GoUint32)SKY_fee_RequiredFee(arg1,arg2,arg3);
+  arg1 = (wallet__Balance *)(argp1);
+  result = (GoUint32)SKY_wallet_Balance_IsZero(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -19531,249 +19180,106 @@ SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), P
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_RemainingHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  GoUint32 arg2 ;
-  GoUint64 *arg3 = (GoUint64 *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  GoUint64 temp3 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp3 = 0;
-    arg3 = &temp3;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RemainingHours",&obj0,&obj1)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RemainingHours" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RemainingHours" "', argument " "2"" of type '" "GoUint32""'");
-  } 
-  arg2 = (GoUint32)(val2);
-  result = (GoUint32)SKY_fee_RemainingHours(arg1,arg2,arg3);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchInterruptPanic")) SWIG_fail;
+  result = (GoUint32)SKY_apputil_CatchInterruptPanic();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoUint64 arg2 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  GoUint64 *arg4 = (GoUint64 *) 0 ;
-  unsigned long long val2 ;
-  int ecode2 = 0 ;
-  GoSlice_ temp3 ;
-  GoUint64 temp4 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
-  }
-  {
-    temp4 = 0;
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_TransactionFee",&obj0,&obj1)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_TransactionFee" "', argument " "2"" of type '" "GoUint64""'");
-  } 
-  arg2 = (GoUint64)(val2);
-  result = (GoUint32)SKY_fee_TransactionFee(arg1,arg2,arg3,arg4);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchDebug")) SWIG_fail;
+  result = (GoUint32)SKY_apputil_CatchDebug();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
-  }
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 ));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[4] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_SKY_fee_TransactionFee__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        {
-          _v = PyList_Check(argv[2]) ? 1 : 0;
-        }
-        if (_v) {
-          return _wrap_SKY_fee_TransactionFee__SWIG_0(self, args);
-        }
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_fee_TransactionFee'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin_UxOutArray *,GoUint64 *)\n"
-    "    SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin__UxArray *,GoUint64 *)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cli_LoadConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_apputil_PrintProgramStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle *arg1 = (Config__Handle *) 0 ;
-  Handle temp1 ;
   GoUint32 result;
   
-  {
-    arg1 = &temp1;
-  }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_LoadConfig")) SWIG_fail;
-  result = (GoUint32)SKY_cli_LoadConfig(arg1);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_PrintProgramStatus")) SWIG_fail;
+  result = (GoUint32)SKY_apputil_PrintProgramStatus();
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullWalletPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  wallet__Entry *arg1 = (wallet__Entry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullWalletPath",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_Verify",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_Verify" "', argument " "1"" of type '" "wallet__Entry *""'"); 
   }
-  result = (GoUint32)SKY_cli_Config_FullWalletPath(arg1,arg2);
+  arg1 = (wallet__Entry *)(argp1);
+  result = (GoUint32)SKY_wallet_Entry_Verify(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullDBPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_VerifyPublic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  wallet__Entry *arg1 = (wallet__Entry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullDBPath",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_VerifyPublic",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_VerifyPublic" "', argument " "1"" of type '" "wallet__Entry *""'"); 
   }
-  result = (GoUint32)SKY_cli_Config_FullDBPath(arg1,arg2);
+  arg1 = (wallet__Entry *)(argp1);
+  result = (GoUint32)SKY_wallet_Entry_VerifyPublic(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Config__Handle arg1 ;
-  App__Handle *arg2 = (App__Handle *) 0 ;
-  Handle temp2 ;
-  PyObject * obj0 = 0 ;
+  GoString_ *arg1 = (GoString_ *) 0 ;
+  GoString temp1 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_NewApp",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp1.p = NULL;
+    temp1.n = 0;
+    arg1 = (GoString_ *)&temp1;
   }
-  result = (GoUint32)SKY_cli_NewApp(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_bip39_NewDefaultMnemomic")) SWIG_fail;
+  result = (GoUint32)SKY_bip39_NewDefaultMnemomic(arg1);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
+    free( (void*)arg1->p );
   }
   return resultobj;
 fail:
@@ -19781,25 +19287,33 @@ SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObje
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Context__Handle arg1 ;
-  WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ;
-  Handle temp2 ;
+  GoInt arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  long long val1 ;
+  int ecode1 = 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromContext",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  result = (GoUint32)SKY_cli_RPCClientFromContext(arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewEntropy",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_bip39_NewEntropy" "', argument " "1"" of type '" "GoInt""'");
+  } 
+  arg1 = (GoInt)(val1);
+  result = (GoUint32)SKY_bip39_NewEntropy(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -19807,25 +19321,36 @@ SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Context__Handle arg1 ;
-  Config__Handle *arg2 = (Config__Handle *) 0 ;
-  Handle temp2 ;
+  GoSlice arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_ConfigFromContext",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewMnemonic",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_NewMnemonic', expecting string");
+    }
+    (&arg1)->data = buffer;
+    (&arg1)->len = size - 1;
+    (&arg1)->cap = size;
   }
-  result = (GoUint32)SKY_cli_ConfigFromContext(arg1,arg2);
+  result = (GoUint32)SKY_bip39_NewMnemonic(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
   }
   return resultobj;
 fail:
@@ -19833,33 +19358,33 @@ SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromBytes_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoString arg1 ;
   coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
   GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
-  }
   {
     temp2.data = NULL;
     temp2.len = 0;
     temp2.cap = 0;
     arg2 = (coin__UxArray *)&temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromBytes_Password")) SWIG_fail;
-  result = (GoUint32)SKY_cli_PasswordFromBytes_Password(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_MnemonicToByteArray",&obj0)) SWIG_fail;
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_MnemonicToByteArray', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
+  result = (GoUint32)SKY_bip39_MnemonicToByteArray(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
     free( (void*)arg2->data );
@@ -19870,24 +19395,34 @@ SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromBytes_Password(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
+  GoString arg1 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_IsMnemonicValid",&obj0)) SWIG_fail;
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_IsMnemonicValid', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromTerm_Password")) SWIG_fail;
-  result = (GoUint32)SKY_cli_PasswordFromTerm_Password(arg1);
+  result = (GoUint32)SKY_bip39_IsMnemonicValid(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -19895,77 +19430,73 @@ SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
+  GoString arg1 ;
   GoString arg2 ;
-  GoString arg3 ;
-  GoSlice arg4 ;
-  PasswordReader__Handle arg5 ;
-  Transaction__Handle *arg6 = (Transaction__Handle *) 0 ;
-  void *argp5 ;
-  int res5 = 0 ;
-  Handle temp6 ;
+  GoSlice arg3 ;
+  coin__UxArray *arg4 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg5 = (coin__UxArray *) 0 ;
+  GoSlice_ temp4 ;
+  GoSlice_ temp5 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
   GoUint32 result;
   
   {
-    arg6 = &temp6;
+    temp4.data = NULL;
+    temp4.len = 0;
+    temp4.cap = 0;
+    arg4 = (coin__UxArray *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_cli_CreateRawTxFromWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp5.data = NULL;
+    temp5.len = 0;
+    temp5.cap = 0;
+    arg5 = (coin__UxArray *)&temp5;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_certutil_NewTLSCertPair",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
     }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string");
     }
-    (&arg4)->data = buffer;
-    (&arg4)->len = size - 1;
-    (&arg4)->cap = size;
+    (&arg3)->data = buffer;
+    (&arg3)->len = size - 1;
+    (&arg3)->cap = size;
   }
+  result = (GoUint32)SKY_certutil_NewTLSCertPair(arg1,arg2,arg3,arg4,arg5);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_PasswordReader__Handle,  0 );
-    if (!SWIG_IsOK(res5)) {
-      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); 
-    }  
-    if (!argp5) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'");
-    } else {
-      arg5 = *((PasswordReader__Handle *)(argp5));
-    }
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len  ));
+    free( (void*)arg4->data );
   }
-  result = (GoUint32)SKY_cli_CreateRawTxFromWallet(arg1,arg2,arg3,arg4,arg5,arg6);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len  ));
+    free( (void*)arg5->data );
   }
   return resultobj;
 fail:
@@ -19973,267 +19504,135 @@ SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoString arg4 ;
-  GoSlice arg5 ;
-  PasswordReader__Handle arg6 ;
-  Transaction__Handle *arg7 = (Transaction__Handle *) 0 ;
-  void *argp6 ;
-  int res6 = 0 ;
-  Handle temp7 ;
+  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
   GoUint32 result;
   
-  {
-    arg7 = &temp7;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTxFromAddress",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
-    }
-    (&arg4)->p = buffer;
-    (&arg4)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string");
-    }
-    (&arg5)->data = buffer;
-    (&arg5)->len = size - 1;
-    (&arg5)->cap = size;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_Hash",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_Hash" "', argument " "1"" of type '" "coin__UxOut *""'"); 
   }
+  arg1 = (coin__UxOut *)(argp1);
   {
-    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_PasswordReader__Handle,  0 );
-    if (!SWIG_IsOK(res6)) {
-      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); 
-    }  
-    if (!argp6) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'");
-    } else {
-      arg6 = *((PasswordReader__Handle *)(argp6));
-    }
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_CreateRawTxFromAddress(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  result = (GoUint32)SKY_coin_UxOut_Hash(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_SnapshotHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  Wallet__Handle arg2 ;
-  GoSlice arg3 ;
-  GoString arg4 ;
-  GoSlice arg5 ;
-  GoSlice arg6 ;
-  Transaction__Handle *arg7 = (Transaction__Handle *) 0 ;
-  Handle temp7 ;
+  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  PyObject * obj4 = 0 ;
-  PyObject * obj5 = 0 ;
   GoUint32 result;
   
-  {
-    arg7 = &temp7;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_SnapshotHash",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_SnapshotHash" "', argument " "1"" of type '" "coin__UxOut *""'"); 
   }
-  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  arg1 = (coin__UxOut *)(argp1);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
-    }
-    (&arg3)->data = buffer;
-    (&arg3)->len = size - 1;
-    (&arg3)->cap = size;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
-    }
-    (&arg4)->p = buffer;
-    (&arg4)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
-    }
-    (&arg5)->data = buffer;
-    (&arg5)->len = size - 1;
-    (&arg5)->cap = size;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string");
-    }
-    (&arg6)->data = buffer;
-    (&arg6)->len = size - 1;
-    (&arg6)->cap = size;
-  }
-  result = (GoUint32)SKY_cli_CreateRawTx(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  result = (GoUint32)SKY_coin_UxOut_SnapshotHash(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_NewTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  GoSlice arg2 ;
-  GoSlice arg3 ;
-  Transaction__Handle *arg4 = (Transaction__Handle *) 0 ;
-  Handle temp4 ;
+  coin__UxBody *arg1 = (coin__UxBody *) 0 ;
+  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  {
-    arg4 = &temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_NewTransaction",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
-    }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxBody_Hash",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxBody, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxBody_Hash" "', argument " "1"" of type '" "coin__UxBody *""'"); 
   }
+  arg1 = (coin__UxBody *)(argp1);
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string");
-    }
-    (&arg3)->data = buffer;
-    (&arg3)->len = size - 1;
-    (&arg3)->cap = size;
+    void *argp = 0;
+    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
+    if (!SWIG_IsOK(res))
+    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
+    cipher_SHA256* p = (cipher_SHA256*)argp;
+    arg2 = &p->data;
   }
-  result = (GoUint32)SKY_cli_NewTransaction(arg1,arg2,arg3,arg4);
+  result = (GoUint32)SKY_coin_UxBody_Hash(arg1,(unsigned char (*)[32])arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
-  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_CoinHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  coin__UxOut *arg1 = (coin__UxOut *) 0 ;
+  GoUint64 arg2 ;
+  GoUint64 *arg3 = (GoUint64 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  GoUint64 temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp3 = 0;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_InitDataDir",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_InitDataDir', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_CoinHours",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "1"" of type '" "coin__UxOut *""'"); 
   }
-  result = (GoUint32)SKY_file_InitDataDir(arg1,arg2);
+  arg1 = (coin__UxOut *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_coin_UxOut_CoinHours(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
   }
   return resultobj;
 fail:
@@ -20241,23 +19640,36 @@ SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString_ *arg1 = (GoString_ *) 0 ;
-  GoString temp1 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoSlice_ temp2 ;
   GoUint32 result;
   
   {
-    temp1.p = NULL;
-    temp1.n = 0;
-    arg1 = (GoString_ *)&temp1;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_file_UserHome")) SWIG_fail;
-  result = (GoUint32)SKY_file_UserHome(arg1);
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Hashes")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Hashes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n  ));
-    free( (void*)arg1->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -20265,95 +19677,68 @@ SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyO
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_file_ResolveResourceDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_ResolveResourceDirectory",&obj0)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_ResolveResourceDirectory', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+  if (argc == 0) {
+    return _wrap_SKY_coin_UxArray_Hashes__SWIG_1(self, args);
   }
-  result = (GoUint32)SKY_file_ResolveResourceDirectory(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_UxArray_Hashes__SWIG_0(self, args);
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Hashes'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Hashes(coin_UxOutArray *,cipher_SHA256s *)\n"
+    "    SKY_coin_UxArray_Hashes(coin__UxArray *,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_file_DetermineResourcePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  GoString arg2 ;
-  GoString arg3 ;
-  GoString_ *arg4 = (GoString_ *) 0 ;
-  GoString temp4 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
-  
-  {
-    temp4.p = NULL;
-    temp4.n = 0;
-    arg4 = (GoString_ *)&temp4;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_file_DetermineResourcePath",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
-  }
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoUint8 *arg2 = (GoUint8 *) 0 ;
+  GoSlice_ temp1 ;
+  GoUint8 temp2 ;
+  int res2 = SWIG_TMPOBJ ;
+  GoUint32 result;
+  
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string");
-    }
-    (&arg3)->p = buffer;
-    (&arg3)->n = size - 1;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  result = (GoUint32)SKY_file_DetermineResourcePath(arg1,arg2,arg3,arg4);
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_HasDupes")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_HasDupes(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
-    free( (void*)arg4->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -20361,129 +19746,146 @@ SWIGINTERN PyObject *_wrap_SKY_file_DetermineResourcePath(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoString arg1 ;
-  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58BitcoinAddress",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58BitcoinAddress', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58BitcoinAddress" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  if (argc == 0) {
+    return _wrap_SKY_coin_UxArray_HasDupes__SWIG_1(self, args);
   }
-  arg2 = (cipher__BitcoinAddress *)(argp2);
-  result = (GoUint32)SKY_cipher_DecodeBase58BitcoinAddress(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_UxArray_HasDupes__SWIG_0(self, args);
+    }
+  }
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_HasDupes'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_HasDupes(coin_UxOutArray *,GoUint8 *)\n"
+    "    SKY_coin_UxArray_HasDupes(coin__UxArray *,GoUint8 *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__PubKey *arg1 = (cipher__PubKey *) 0 ;
-  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromPubKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg1 = &p->data;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromPubKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sort")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Sort(arg1);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
   }
-  arg2 = (cipher__BitcoinAddress *)(argp2);
-  SKY_cipher_BitcoinAddressFromPubKey((unsigned char (*)[33])arg1,arg2);
-  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoInt *arg2 = (GoInt *) 0 ;
+  GoSlice_ temp1 ;
+  GoInt temp2 ;
+  int res2 = SWIG_TMPOBJ ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromSecKey",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
-  }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromSecKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  arg2 = (cipher__BitcoinAddress *)(argp2);
-  result = (GoUint32)SKY_cipher_BitcoinAddressFromSecKey((unsigned char (*)[32])arg1,arg2);
+  arg2 = &temp2;
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Len")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Len(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  if (SWIG_IsTmpObj(res2)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SecKey *arg1 = (cipher__SecKey *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoInt arg2 ;
+  GoInt arg3 ;
+  GoUint8 *arg4 = (GoUint8 *) 0 ;
+  GoSlice_ temp1 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  long long val3 ;
+  int ecode3 = 0 ;
+  GoUint8 temp4 ;
+  int res4 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinWalletImportFormatFromSeckey",&obj0)) SWIG_fail;
+  arg4 = &temp4;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Less",&obj0,&obj1)) SWIG_fail;
+  ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Less" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Less" "', argument " "3"" of type '" "GoInt""'");
+  } 
+  arg3 = (GoInt)(val3);
+  result = (GoUint32)SKY_coin_UxArray_Less(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg1 = &p->data;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
   }
-  SKY_cipher_BitcoinWalletImportFormatFromSeckey((unsigned char (*)[32])arg1,arg2);
-  resultobj = SWIG_Py_Void();
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (SWIG_IsTmpObj(res4)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -20491,457 +19893,527 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey(PyObje
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromBytes",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_BitcoinAddressFromBytes', expecting string");
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  Py_ssize_t ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SKY_coin_UxArray_Less__SWIG_1(self, args);
+      }
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromBytes" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  if (argc == 3) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_SKY_coin_UxArray_Less__SWIG_0(self, args);
+        }
+      }
+    }
   }
-  arg2 = (cipher__BitcoinAddress *)(argp2);
-  result = (GoUint32)SKY_cipher_BitcoinAddressFromBytes(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Less'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Less(coin_UxOutArray *,GoInt,GoInt,GoUint8 *)\n"
+    "    SKY_coin_UxArray_Less(coin__UxArray *,GoInt,GoInt,GoUint8 *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoString arg1 ;
-  cipher__SecKey *arg2 = (cipher__SecKey *) 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoInt arg2 ;
+  GoInt arg3 ;
+  GoSlice_ temp1 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  long long val3 ;
+  int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromBitcoinWalletImportFormat",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromBitcoinWalletImportFormat', expecting string");
-    }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
-  }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey");
-    cipher_SecKey* p = (cipher_SecKey*)argp;
-    arg2 = &p->data;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  result = (GoUint32)SKY_cipher_SecKeyFromBitcoinWalletImportFormat(arg1,(unsigned char (*)[32])arg2);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Swap",&obj0,&obj1)) SWIG_fail;
+  ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Swap" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Swap" "', argument " "3"" of type '" "GoInt""'");
+  } 
+  arg3 = (GoInt)(val3);
+  result = (GoUint32)SKY_coin_UxArray_Swap(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  GoUint8 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Null",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Null" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  result = (GoUint8)SKY_cipher_BitcoinAddress_Null(arg1);
-  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoSlice_ temp2 ;
-  PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Bytes",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Bytes" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SKY_coin_UxArray_Swap__SWIG_1(self, args);
+      }
+    }
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  SKY_cipher_BitcoinAddress_Bytes(arg1,arg2);
-  resultobj = SWIG_Py_Void();
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+  if (argc == 3) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_SKY_coin_UxArray_Swap__SWIG_0(self, args);
+        }
+      }
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Swap'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Swap(coin_UxOutArray *,GoInt,GoInt)\n"
+    "    SKY_coin_UxArray_Swap(coin__UxArray *,GoInt,GoInt)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  cipher__PubKey *arg2 = (cipher__PubKey *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoSlice_ temp1 ;
+  GoUint64 temp2 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Verify",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Verify" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  {
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey");
-    cipher_PubKey* p = (cipher_PubKey*)argp;
-    arg2 = &p->data;
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  result = (GoUint32)SKY_cipher_BitcoinAddress_Verify(arg1,(unsigned char (*)[33])arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Coins")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Coins(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_String",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_String" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  if (argc == 0) {
+    return _wrap_SKY_coin_UxArray_Coins__SWIG_1(self, args);
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  SKY_cipher_BitcoinAddress_String(arg1,arg2);
-  resultobj = SWIG_Py_Void();
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_UxArray_Coins__SWIG_0(self, args);
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Coins'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Coins(coin_UxOutArray *,GoUint64 *)\n"
+    "    SKY_coin_UxArray_Coins(coin__UxArray *,GoUint64 *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  cipher__Checksum *arg2 = (cipher__Checksum *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  GoUint64 arg2 ;
+  GoUint64 *arg3 = (GoUint64 *) 0 ;
+  GoSlice_ temp1 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  GoUint64 temp3 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Checksum",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Checksum" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  {
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum");
-    cipher_Checksum* p = (cipher_Checksum*)argp;
-    arg2 = &p->data;
+    temp3 = 0;
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_UxArray_CoinHours",&obj0)) SWIG_fail;
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_CoinHours" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_coin_UxArray_CoinHours(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
   }
-  SKY_cipher_BitcoinAddress_Checksum(arg1,(unsigned char (*)[4])arg2);
-  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  GoString arg2 ;
-  ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetWalletOutputsFromFile",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetWalletOutputsFromFile', expecting string");
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_SKY_coin_UxArray_CoinHours__SWIG_1(self, args);
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
   }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputsFromFile" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); 
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SKY_coin_UxArray_CoinHours__SWIG_0(self, args);
+      }
+    }
   }
-  arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3);
-  result = (GoUint32)SKY_cli_GetWalletOutputsFromFile(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_CoinHours'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_CoinHours(coin_UxOutArray *,GoUint64,GoUint64 *)\n"
+    "    SKY_coin_UxArray_CoinHours(coin__UxArray *,GoUint64,GoUint64 *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  WebRpcClient__Handle arg1 ;
-  Wallet__Handle *arg2 = (Wallet__Handle *) 0 ;
-  ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ;
-  Handle temp2 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoSlice_ temp2 ;
+  GoSlice_ temp3 ;
   GoUint32 result;
   
   {
-    arg2 = &temp2;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GetWalletOutputs",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputs" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); 
+  {
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3);
-  result = (GoUint32)SKY_cli_GetWalletOutputs(arg1,arg2,arg3);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sub")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Sub(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_testutil_MakeAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_testutil_MakeAddress",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_testutil_MakeAddress" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint32)SKY_testutil_MakeAddress(arg1);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Ripemd160_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__Ripemd160 *arg1 = (cipher__Ripemd160 *) 0 ;
-  GoSlice arg2 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Ripemd160_Set",&obj0,&obj1)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
-    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
-    arg1 = &p->data;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_Ripemd160_Set', expecting string");
+  if (argc == 0) {
+    return _wrap_SKY_coin_UxArray_Sub__SWIG_1(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_UxArray_Sub__SWIG_0(self, args);
+      }
     }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_cipher_Ripemd160_Set((unsigned char (*)[20])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Sub'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Sub(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n"
+    "    SKY_coin_UxArray_Sub(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  GoSlice_ temp1 ;
+  GoSlice_ temp2 ;
+  GoSlice_ temp3 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_HashRipemd160",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_HashRipemd160', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160");
-    cipher_Ripemd160* p = (cipher_Ripemd160*)argp;
-    arg2 = &p->data;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  result = (GoUint32)SKY_cipher_HashRipemd160(arg1,(unsigned char (*)[20])arg2);
+  {
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Add")) SWIG_fail;
+  result = (GoUint32)SKY_coin_UxArray_Add(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  GoSlice arg2 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256_Set",&obj0,&obj1)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256_Set', expecting string");
+  if (argc == 0) {
+    return _wrap_SKY_coin_UxArray_Add__SWIG_1(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = PyList_Check(argv[1]) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_SKY_coin_UxArray_Add__SWIG_0(self, args);
+      }
     }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_cipher_SHA256_Set((unsigned char (*)[32])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Add'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_UxArray_Add(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n"
+    "    SKY_coin_UxArray_Add(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
-  PyObject * obj0 = 0 ;
+  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
+  AddressUxOuts_Handle *arg2 = (AddressUxOuts_Handle *) 0 ;
+  GoSlice_ temp1 ;
+  Handle temp2 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    temp1.data = NULL;
+    temp1.len = 0;
+    temp1.cap = 0;
+    arg1 = (coin__UxArray *)&temp1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Hex",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
+    arg2 = &temp2;
   }
-  result = (GoUint32)SKY_cipher_SHA256_Hex((unsigned char (*)[32])arg1,arg2);
+  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_NewAddressUxOuts")) SWIG_fail;
+  result = (GoUint32)SKY_coin_NewAddressUxOuts(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
+    free( (void*)arg1->data );
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -20949,278 +20421,274 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Hex(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SHA256_Xor",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+  if (argc == 0) {
+    return _wrap_SKY_coin_NewAddressUxOuts__SWIG_1(self, args);
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyList_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_NewAddressUxOuts__SWIG_0(self, args);
+    }
   }
-  result = (GoUint32)SKY_cipher_SHA256_Xor((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_NewAddressUxOuts'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_NewAddressUxOuts(coin_UxOutArray *,AddressUxOuts_Handle *)\n"
+    "    SKY_coin_NewAddressUxOuts(coin__UxArray *,AddressUxOuts_Handle *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SumSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  AddressUxOuts_Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SumSHA256",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SumSHA256', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Keys",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_cipher_SumSHA256(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Keys(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256FromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  GoString arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256FromHex",&obj0,&obj1)) SWIG_fail;
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256FromHex', expecting string");
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_0(self, args);
     }
-    (&arg1)->p = buffer;
-    (&arg1)->n = size - 1;
   }
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(self, args);
+    }
   }
-  result = (GoUint32)SKY_cipher_SHA256FromHex(arg1,(unsigned char (*)[32])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Keys'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,cipher_Addresses *)\n"
+    "    SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  AddressUxOuts_Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DoubleSHA256",&obj0,&obj1)) SWIG_fail;
   {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DoubleSHA256', expecting string");
-    }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Flatten",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_cipher_DoubleSHA256(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Flatten(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_AddSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  Py_ssize_t ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Flatten'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin_UxOutArray *)\n"
+    "    SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin__UxArray *)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
+  AddressUxOuts_Handle arg1 ;
+  AddressUxOuts_Handle arg2 ;
+  AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_AddSHA256",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
+    arg3 = &temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Sub",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+    SWIG_AsVal_long(obj1, (long*)&arg2);
   }
-  result = (GoUint32)SKY_cipher_AddSHA256((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Sub(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_Merkle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice *arg1 = (GoSlice *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  AddressUxOuts_Handle arg1 ;
+  AddressUxOuts_Handle arg2 ;
+  AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Merkle",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GoSlice, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Merkle" "', argument " "1"" of type '" "GoSlice *""'"); 
+  {
+    arg3 = &temp3;
   }
-  arg1 = (GoSlice *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Add",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_cipher_Merkle(arg1,(unsigned char (*)[32])arg2);
+  {
+    SWIG_AsVal_long(obj1, (long*)&arg2);
+  }
+  result = (GoUint32)SKY_coin_AddressUxOuts_Add(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ;
-  GoUint8 *arg2 = (GoUint8 *) 0 ;
-  GoUint8 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  AddressUxOuts_Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Null",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg1 = &p->data;
-  }
-  result = (GoUint32)SKY_cipher_SHA256_Null((unsigned char (*)[32])arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle *arg1 = (Transaction__Handle *) 0 ;
-  Handle temp1 ;
-  GoUint32 result;
-  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Get",&obj0,&obj1)) SWIG_fail;
   {
-    arg1 = &temp1;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transaction")) SWIG_fail;
-  result = (GoUint32)SKY_coin_Create_Transaction(arg1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Get" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  }
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Get(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
   }
   return resultobj;
 fail:
@@ -21228,52 +20696,86 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
-  Handle temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  {
-    arg2 = &temp2;
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Copy",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_0(self, args);
+      }
+    }
   }
-  result = (GoUint32)SKY_coin_Transaction_Copy(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(self, args);
+      }
+    }
   }
-  return resultobj;
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Get'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n"
+    "    SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  coin__Transaction **arg2 = (coin__Transaction **) 0 ;
-  coin__Transaction *temp2 ;
+  AddressUxOuts_Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  GoUint8 *arg3 = (GoUint8 *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  GoUint8 temp3 ;
+  int res3 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  {
-    temp2 = NULL;
-    arg2 = &temp2;
-  }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetTransactionObject",&obj0)) SWIG_fail;
+  arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_HasKey",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_GetTransactionObject(arg1,arg2);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_HasKey" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  }
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_HasKey(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Transaction, 0 ));
+  if (SWIG_IsTmpObj(res3)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
   }
   return resultobj;
 fail:
@@ -21281,36 +20783,46 @@ SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionObject(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetInputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_GetOutputLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  AddressUxOuts_Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  GoInt *arg3 = (GoInt *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  GoInt temp3 ;
+  int res3 = SWIG_TMPOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetInputs",&obj0,&obj1)) SWIG_fail;
+  arg3 = &temp3;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_GetOutputLength",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetInputs" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_coin_Transaction_ResetInputs(arg1,arg2);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_GetOutputLength" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  }
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_GetOutputLength(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  if (SWIG_IsTmpObj(res3)) {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long_long, new_flags));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
+  AddressUxOuts_Handle arg1 ;
   GoInt *arg2 = (GoInt *) 0 ;
   GoInt temp2 ;
   int res2 = SWIG_TMPOBJ ;
@@ -21318,11 +20830,11 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNU
   GoUint32 result;
   
   arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetInputsCount",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Length",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_GetInputsCount(arg1,arg2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Length(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   if (SWIG_IsTmpObj(res2)) {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
@@ -21336,201 +20848,181 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  AddressUxOuts_Handle arg1 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
+  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  GoSlice_ temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetInputAt",&obj0,&obj1,&obj2)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
-  }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetInputAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+    temp3.data = NULL;
+    temp3.len = 0;
+    temp3.cap = 0;
+    arg3 = (coin__UxArray *)&temp3;
   }
-  result = (GoUint32)SKY_coin_Transaction_GetInputAt(arg1,arg2,(unsigned char (*)[32])arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetInputAt",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Set",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetInputAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Set" "', argument " "2"" of type '" "cipher__Address *""'"); 
   }
-  result = (GoUint32)SKY_coin_Transaction_SetInputAt(arg1,arg2,(unsigned char (*)[32])arg3);
+  arg2 = (cipher__Address *)(argp2);
+  result = (GoUint32)SKY_coin_AddressUxOuts_Set(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
+    free( (void*)arg3->data );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  Py_ssize_t ii;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetOutputsCount",&obj0)) SWIG_fail;
-  {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
-  result = (GoUint32)SKY_coin_Transaction_GetOutputsCount(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  if (argc == 2) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(self, args);
+      }
+    }
   }
-  return resultobj;
+  if (argc == 3) {
+    int _v;
+    {
+      _v = PyInt_Check(argv[0]) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = PyList_Check(argv[2]) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
 fail:
-  return NULL;
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Set'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    wrap_SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n"
+    "    SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n");
+  return 0;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  GoString arg1 ;
+  Client__Handle *arg2 = (Client__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewClient",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewClient', expecting string");
+    }
+    (&arg1)->p = buffer;
+    (&arg1)->n = size - 1;
   }
-  arg3 = (coin__TransactionOutput *)(argp3);
-  result = (GoUint32)SKY_coin_Transaction_GetOutputAt(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_NewClient(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  Client__Handle arg1 ;
+  GoString_ *arg2 = (GoString_ *) 0 ;
+  GoString temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp2.p = NULL;
+    temp2.n = 0;
+    arg2 = (GoString_ *)&temp2;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CSRF",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg3 = (coin__TransactionOutput *)(argp3);
-  result = (GoUint32)SKY_coin_Transaction_SetOutputAt(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Client_CSRF(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
+    free( (void*)arg2->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetSignaturesCount",&obj0)) SWIG_fail;
+  {
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Version",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_GetSignaturesCount(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_Version(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -21538,203 +21030,241 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWI
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetSignatureAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Outputs",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg3 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_GetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3);
+  result = (GoUint32)SKY_api_Client_Outputs(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  cipher__Sig *arg3 = (cipher__Sig *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForAddresses",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetSignatureAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg3 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForAddresses', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_coin_Transaction_SetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3);
+  result = (GoUint32)SKY_api_Client_OutputsForAddresses(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushSignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  cipher__Sig *arg2 = (cipher__Sig *) 0 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushSignature",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg3 = &temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForHashes",&obj0,&obj1)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type Sig");
-    cipher_Sig* p = (cipher_Sig*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_PushSignature(arg1,(unsigned char (*)[65])arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForHashes', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_api_Client_OutputsForHashes(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetOutputs",&obj0,&obj1)) SWIG_fail;
+  {
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CoinSupply",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetOutputs" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_coin_Transaction_ResetOutputs(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_CoinSupply(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetSignatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoInt arg2 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetSignatures",&obj0,&obj1)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockByHash",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetSignatures" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_coin_Transaction_ResetSignatures(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_BlockByHash', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_BlockByHash(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
+  Client__Handle arg1 ;
+  GoUint64 arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Verify",&obj0)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockBySeq",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_Verify(arg1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_BlockBySeq" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_api_Client_BlockBySeq(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Blocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_VerifyInput",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Blocks",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_VerifyInput(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Blocks', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_api_Client_Blocks(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -21742,82 +21272,60 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SW
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Client__Handle arg1 ;
+  GoUint64 arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  unsigned long long val2 ;
+  int ecode2 = 0 ;
+  Handle temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    arg3 = &temp3;
   }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(self, args);
-    }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_LastBlocks",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_0(self, args);
-      }
-    }
+  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_LastBlocks" "', argument " "2"" of type '" "GoUint64""'");
+  } 
+  arg2 = (GoUint64)(val2);
+  result = (GoUint32)SKY_api_Client_LastBlocks(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_VerifyInput'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin_UxOutArray *)\n"
-    "    SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  GoUint16 *arg3 = (GoUint16 *) 0 ;
-  GoUint16 temp3 ;
-  int res3 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg3 = &temp3;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushInput",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainMetadata",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_PushInput(arg1,(unsigned char (*)[32])arg2,arg3);
+  result = (GoUint32)SKY_api_Client_BlockchainMetadata(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res3)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -21825,86 +21333,65 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_TransactionOutput_UxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_TransactionOutput_UxID",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_TransactionOutput_UxID" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); 
-  }
-  arg1 = (coin__TransactionOutput *)(argp1);
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainProgress",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_TransactionOutput_UxID(arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3);
+  result = (GoUint32)SKY_api_Client_BlockchainProgress(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Balance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  GoUint64 arg3 ;
-  GoUint64 arg4 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  unsigned long long val3 ;
-  int ecode3 = 0 ;
-  unsigned long long val4 ;
-  int ecode4 = 0 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_Transaction_PushOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_Balance",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Balance', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  arg2 = (cipher__Address *)(argp2);
-  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "3"" of type '" "GoUint64""'");
-  } 
-  arg3 = (GoUint64)(val3);
-  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "4"" of type '" "GoUint64""'");
-  } 
-  arg4 = (GoUint64)(val4);
-  result = (GoUint32)SKY_coin_Transaction_PushOutput(arg1,arg2,arg3,arg4);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_Balance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); 
+  }
+  arg3 = (wallet__BalancePair *)(argp3);
+  result = (GoUint32)SKY_api_Client_Balance(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -21912,15 +21399,20 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushOutput(PyObject *SWIGUNUSEDP
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoSlice arg2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SignInputs",&obj0,&obj1)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UxOut",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
@@ -21929,94 +21421,53 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs__SWIG_1(PyObject *SWI
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_Transaction_SignInputs', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UxOut', expecting string");
     }
-    (&arg2)->data = buffer;
-    (&arg2)->len = size - 1;
-    (&arg2)->cap = size;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transaction_SignInputs(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_UxOut(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        char* buffer = 0;
-        size_t size = 0;
-        int res = SWIG_AsCharPtrAndSize( argv[1], &buffer, &size, 0 );
-        _v = SWIG_IsOK(res) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_Transaction_SignInputs__SWIG_1(self, args);
-      }
-    }
-  }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_Transaction_SignInputs__SWIG_0(self, args);
-      }
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_SignInputs'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_Transaction_SignInputs(Transaction__Handle,cipher_SecKeys *)\n"
-    "    SKY_coin_Transaction_SignInputs(Transaction__Handle,GoSlice)\n");
-  return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Size",&obj0)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressUxOuts",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_Size(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressUxOuts', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_AddressUxOuts(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -22024,65 +21475,63 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Size(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_Hash",&obj0,&obj1)) SWIG_fail;
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Wallet",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Wallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transaction_Hash(arg1,(unsigned char (*)[32])arg2);
+  result = (GoUint32)SKY_api_Client_Wallet(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SizeHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  Wallets__Handle *arg2 = (Wallets__Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SizeHash",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg2 = &temp2;
   }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Wallets",&obj0)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg3 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_SizeHash(arg1,arg2,(unsigned char (*)[32])arg3);
+  result = (GoUint32)SKY_api_Client_Wallets(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -22090,29 +21539,58 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SizeHash(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateUnencryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoInt arg4 ;
+  WalletResponse__Handle *arg5 = (WalletResponse__Handle *) 0 ;
+  long long val4 ;
+  int ecode4 = 0 ;
+  Handle temp5 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg5 = &temp5;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxID",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_CreateUnencryptedWallet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_TxID(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  ecode4 = SWIG_AsVal_long_SS_long(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_CreateUnencryptedWallet" "', argument " "4"" of type '" "GoInt""'");
+  } 
+  arg4 = (GoInt)(val4);
+  result = (GoUint32)SKY_api_Client_CreateUnencryptedWallet(arg1,arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5));
   }
   return resultobj;
 fail:
@@ -22120,104 +21598,129 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxID(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxIDHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoString_ *arg2 = (GoString_ *) 0 ;
-  GoString temp2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoString arg4 ;
+  GoInt arg5 ;
+  WalletResponse__Handle *arg6 = (WalletResponse__Handle *) 0 ;
+  long long val5 ;
+  int ecode5 = 0 ;
+  Handle temp6 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
   GoUint32 result;
   
   {
-    temp2.p = NULL;
-    temp2.n = 0;
-    arg2 = (GoString_ *)&temp2;
+    arg6 = &temp6;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxIDHex",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_api_Client_CreateEncryptedWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_TxIDHex(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n  ));
-    free( (void*)arg2->p );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_UpdateHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_UpdateHeader",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transaction_UpdateHeader(arg1);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string");
+    }
+    (&arg4)->p = buffer;
+    (&arg4)->n = size - 1;
+  }
+  ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SKY_api_Client_CreateEncryptedWallet" "', argument " "5"" of type '" "GoInt""'");
+  } 
+  arg5 = (GoInt)(val5);
+  result = (GoUint32)SKY_api_Client_CreateEncryptedWallet(arg1,arg2,arg3,arg4,arg5,arg6);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_HashInner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NewWalletAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoInt arg3 ;
+  GoString arg4 ;
+  Strings__Handle *arg5 = (Strings__Handle *) 0 ;
+  long long val3 ;
+  int ecode3 = 0 ;
+  Handle temp5 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_HashInner",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg5 = &temp5;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_NewWalletAddress",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   {
-    void *argp = 0;
-    int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0);
-    if (!SWIG_IsOK(res))
-    SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256");
-    cipher_SHA256* p = (cipher_SHA256*)argp;
-    arg2 = &p->data;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transaction_HashInner(arg1,(unsigned char (*)[32])arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
-  PyObject * obj0 = 0 ;
-  GoUint32 result;
-  
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Serialize",&obj0)) SWIG_fail;
+  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_api_Client_NewWalletAddress" "', argument " "3"" of type '" "GoInt""'");
+  } 
+  arg3 = (GoInt)(val3);
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string");
+    }
+    (&arg4)->p = buffer;
+    (&arg4)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transaction_Serialize(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_NewWalletAddress(arg1,arg2,arg3,arg4,arg5);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5));
   }
   return resultobj;
 fail:
@@ -22225,81 +21728,144 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Serialize(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_TransactionDeserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoSlice arg1 ;
-  Transaction__Handle *arg2 = (Transaction__Handle *) 0 ;
-  Handle temp2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletBalance",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    arg2 = &temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_TransactionDeserialize",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_TransactionDeserialize', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletBalance', expecting string");
     }
-    (&arg1)->data = buffer;
-    (&arg1)->len = size - 1;
-    (&arg1)->cap = size;
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_TransactionDeserialize(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_WalletBalance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); 
   }
+  arg3 = (wallet__BalancePair *)(argp3);
+  result = (GoUint32)SKY_api_Client_WalletBalance(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_OutputHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Spend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transaction__Handle arg1 ;
-  GoUint64 *arg2 = (GoUint64 *) 0 ;
-  GoUint64 temp2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoUint64 arg4 ;
+  GoString arg5 ;
+  SpendResult_Handle *arg6 = (SpendResult_Handle *) 0 ;
+  unsigned long long val4 ;
+  int ecode4 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
   GoUint32 result;
   
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_api_Client_Spend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
   {
-    temp2 = 0;
-    arg2 = &temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_OutputHours",&obj0)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transaction_OutputHours(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_Spend" "', argument " "4"" of type '" "GoUint64""'");
+  } 
+  arg4 = (GoUint64)(val4);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string");
+    }
+    (&arg5)->p = buffer;
+    (&arg5)->n = size - 1;
   }
+  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_SpendResult_Handle, 0 |  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_api_Client_Spend" "', argument " "6"" of type '" "SpendResult_Handle *""'"); 
+  }
+  arg6 = (SpendResult_Handle *)(argp6);
+  result = (GoUint32)SKY_api_Client_Spend(arg1,arg2,arg3,arg4,arg5,arg6);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle *arg1 = (Transactions__Handle *) 0 ;
-  Handle temp1 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ;
+  Handle temp2 ;
+  Handle temp3 ;
+  PyObject * obj0 = 0 ;
   GoUint32 result;
   
   {
-    arg1 = &temp1;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transactions")) SWIG_fail;
-  result = (GoUint32)SKY_coin_Create_Transactions(arg1);
+  {
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CreateTransaction",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_api_Client_CreateTransaction(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -22307,26 +21873,41 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionsObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  coin__UxArray **arg2 = (coin__UxArray **) 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_GetTransactionsObject",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_UpdateWallet",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GoSlice_, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_GetTransactionsObject" "', argument " "2"" of type '" "coin__UxArray **""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  arg2 = (coin__UxArray **)(argp2);
-  result = (GoUint32)SKY_coin_GetTransactionsObject(arg1,arg2);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_UpdateWallet(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
@@ -22334,27 +21915,25 @@ SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionsObject(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Length",&obj0)) SWIG_fail;
+  {
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_WalletFolderName",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transactions_Length(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_WalletFolderName(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -22362,58 +21941,90 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NewSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  Transaction__Handle arg2 ;
+  Client__Handle arg1 ;
+  GoInt arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Add",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NewSeed",&obj0,&obj1)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj1, (long*)&arg2);
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transactions_Add(arg1,arg2);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_NewSeed" "', argument " "2"" of type '" "GoInt""'");
+  } 
+  arg2 = (GoInt)(val2);
+  result = (GoUint32)SKY_api_Client_NewSeed(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
-  GoUint64 *arg3 = (GoUint64 *) 0 ;
-  FeeCalculator temp2 ;
-  GoUint64 temp3 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  GoString_ *arg4 = (GoString_ *) 0 ;
+  GoString temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
   GoUint32 result;
   
   {
-    temp3 = 0;
-    arg3 = &temp3;
+    temp4.p = NULL;
+    temp4.n = 0;
+    arg4 = (GoString_ *)&temp4;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Fees",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletSeed",&obj0,&obj1,&obj2)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    if (!PyCallable_Check(obj1)) SWIG_fail;
-    temp2.callback = _WrapperFeeCalculator;
-    temp2.context = obj1;
-    arg2 = &temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_Transactions_Fees(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_WalletSeed(arg1,arg2,arg3,arg4);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 ));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n  ));
+    free( (void*)arg4->p );
   }
   return resultobj;
 fail:
@@ -22421,13 +22032,11 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  GoInt arg2 ;
-  Transaction__Handle *arg3 = (Transaction__Handle *) 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
   Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
@@ -22436,16 +22045,21 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(
   {
     arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_GetAt",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnection",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_GetAt" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  result = (GoUint32)SKY_coin_Transactions_GetAt(arg1,arg2,arg3);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NetworkConnection', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_NetworkConnection(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
@@ -22456,25 +22070,60 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp2 ;
+  Client__Handle arg1 ;
+  api__NetworkConnectionsFilter *arg2 = (api__NetworkConnectionsFilter *) 0 ;
+  Handle *arg3 = (Handle *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Hashes",&obj0)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnections",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transactions_Hashes(arg1,arg2);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_NetworkConnections" "', argument " "2"" of type '" "api__NetworkConnectionsFilter *""'"); 
+  }
+  arg2 = (api__NetworkConnectionsFilter *)(argp2);
+  result = (GoUint32)SKY_api_Client_NetworkConnections(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkDefaultPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Client__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
+  
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkDefaultPeers",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_api_Client_NetworkDefaultPeers(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
@@ -22486,67 +22135,59 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUN
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[2] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Client__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
   }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_Transactions_Hashes__SWIG_0(self, args);
-    }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkTrustedPeers",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 1) {
-    int _v;
-    {
-      _v = PyInt_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      return _wrap_SKY_coin_Transactions_Hashes__SWIG_1(self, args);
-    }
+  result = (GoUint32)SKY_api_Client_NetworkTrustedPeers(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transactions_Hashes'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_Transactions_Hashes(Transactions__Handle,cipher_SHA256s *)\n"
-    "    SKY_coin_Transactions_Hashes(Transactions__Handle,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkExchangedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  GoUint32 *arg2 = (GoUint32 *) 0 ;
-  GoUint32 temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Size",&obj0)) SWIG_fail;
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkExchangedPeers",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  result = (GoUint32)SKY_coin_Transactions_Size(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_NetworkExchangedPeers(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
   return resultobj;
 fail:
@@ -22554,34 +22195,25 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Size(PyObject *SWIGUNUSEDPARM(s
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_TruncateBytesTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_PendingTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  GoUint32 arg2 ;
-  Transactions__Handle *arg3 = (Transactions__Handle *) 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  Handle temp3 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    arg3 = &temp3;
+    arg2 = &temp2;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_TruncateBytesTo",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_PendingTransactions",&obj0)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_TruncateBytesTo" "', argument " "2"" of type '" "GoUint32""'");
-  } 
-  arg2 = (GoUint32)(val2);
-  result = (GoUint32)SKY_coin_Transactions_TruncateBytesTo(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Client_PendingTransactions(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
   return resultobj;
 fail:
@@ -22589,12 +22221,11 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_TruncateBytesTo(PyObject *SWIGU
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
-  Transactions__Handle *arg3 = (Transactions__Handle *) 0 ;
-  FeeCalculator temp2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
   Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
@@ -22603,17 +22234,21 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(se
   {
     arg3 = &temp3;
   }
-  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SortTransactions",&obj0,&obj1)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transaction",&obj0,&obj1)) SWIG_fail;
   {
     SWIG_AsVal_long(obj0, (long*)&arg1);
   }
   {
-    if (!PyCallable_Check(obj1)) SWIG_fail;
-    temp2.callback = _WrapperFeeCalculator;
-    temp2.context = obj1;
-    arg2 = &temp2;
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transaction', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  result = (GoUint32)SKY_coin_SortTransactions(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Client_Transaction(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
@@ -22624,101 +22259,116 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_NewSortableTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  Transactions__Handle arg1 ;
-  FeeCalculator *arg2 = (FeeCalculator *) 0 ;
-  SortableTransactionResult_Handle *arg3 = (SortableTransactionResult_Handle *) 0 ;
-  FeeCalculator temp2 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewSortableTransactions",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    SWIG_AsVal_long(obj0, (long*)&arg1);
+    arg3 = &temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transactions",&obj0,&obj1)) SWIG_fail;
   {
-    if (!PyCallable_Check(obj1)) SWIG_fail;
-    temp2.callback = _WrapperFeeCalculator;
-    temp2.context = obj1;
-    arg2 = &temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_SortableTransactionResult_Handle, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_NewSortableTransactions" "', argument " "3"" of type '" "SortableTransactionResult_Handle *""'"); 
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transactions', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  arg3 = (SortableTransactionResult_Handle *)(argp3);
-  result = (GoUint32)SKY_coin_NewSortableTransactions(arg1,arg2,arg3);
+  result = (GoUint32)SKY_api_Client_Transactions(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_ConfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  SortableTransactionResult_Handle arg1 ;
-  void *argp1 ;
-  int res1 = 0 ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Sort",&obj0)) SWIG_fail;
   {
-    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
-    }  
-    if (!argp1) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
-    } else {
-      arg1 = *((SortableTransactionResult_Handle *)(argp1));
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_ConfirmedTransactions",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_ConfirmedTransactions', expecting string");
     }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_coin_SortableTransactions_Sort(arg1);
+  result = (GoUint32)SKY_api_Client_ConfirmedTransactions(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_UnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  SortableTransactionResult_Handle arg1 ;
-  GoInt *arg2 = (GoInt *) 0 ;
-  void *argp1 ;
-  int res1 = 0 ;
-  GoInt temp2 ;
-  int res2 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  GoSlice arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
-  arg2 = &temp2;
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Len",&obj0)) SWIG_fail;
   {
-    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
-    }  
-    if (!argp1) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
-    } else {
-      arg1 = *((SortableTransactionResult_Handle *)(argp1));
+    arg3 = &temp3;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnconfirmedTransactions",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnconfirmedTransactions', expecting string");
     }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  result = (GoUint32)SKY_coin_SortableTransactions_Len(arg1,arg2);
+  result = (GoUint32)SKY_api_Client_UnconfirmedTransactions(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res2)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -22726,55 +22376,33 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSE
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Less(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  SortableTransactionResult_Handle arg1 ;
-  GoInt arg2 ;
-  GoInt arg3 ;
-  GoUint8 *arg4 = (GoUint8 *) 0 ;
-  void *argp1 ;
-  int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
-  GoUint8 temp4 ;
-  int res4 = SWIG_TMPOBJ ;
+  Client__Handle arg1 ;
+  Transaction__Handle arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString temp3 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  arg4 = &temp4;
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Less",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
-    }  
-    if (!argp1) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
-    } else {
-      arg1 = *((SortableTransactionResult_Handle *)(argp1));
-    }
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "3"" of type '" "GoInt""'");
-  } 
-  arg3 = (GoInt)(val3);
-  result = (GoUint32)SKY_coin_SortableTransactions_Less(arg1,arg2,arg3,arg4);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    SWIG_AsVal_long(obj1, (long*)&arg2);
+  }
+  result = (GoUint32)SKY_api_Client_InjectTransaction(arg1,arg2,arg3);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  if (SWIG_IsTmpObj(res4)) {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
   return resultobj;
 fail:
@@ -22782,82 +22410,66 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Less(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_ResendUnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  SortableTransactionResult_Handle arg1 ;
-  GoInt arg2 ;
-  GoInt arg3 ;
-  void *argp1 ;
-  int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
   GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Swap",&obj0,&obj1,&obj2)) SWIG_fail;
   {
-    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle,  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); 
-    }  
-    if (!argp1) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'");
-    } else {
-      arg1 = *((SortableTransactionResult_Handle *)(argp1));
-    }
+    arg2 = &temp2;
   }
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "2"" of type '" "GoInt""'");
-  } 
-  arg2 = (GoInt)(val2);
-  ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "3"" of type '" "GoInt""'");
-  } 
-  arg3 = (GoInt)(val3);
-  result = (GoUint32)SKY_coin_SortableTransactions_Swap(arg1,arg2,arg3);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_ResendUnconfirmedTransactions",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_api_Client_ResendUnconfirmedTransactions(arg1,arg2);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  coin__UxArray *arg1 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  GoSlice_ temp1 ;
-  GoSlice_ temp2 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString_ *arg3 = (GoString_ *) 0 ;
+  GoString temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp1.data = NULL;
-    temp1.len = 0;
-    temp1.cap = 0;
-    arg1 = (coin__UxArray *)&temp1;
+    temp3.p = NULL;
+    temp3.n = 0;
+    arg3 = (GoString_ *)&temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_RawTransaction",&obj0,&obj1)) SWIG_fail;
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)":SKY_coin_VerifyTransactionCoinsSpending")) SWIG_fail;
-  result = (GoUint32)SKY_coin_VerifyTransactionCoinsSpending(arg1,arg2);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len  ));
-    free( (void*)arg1->data );
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_RawTransaction', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  result = (GoUint32)SKY_api_Client_RawTransaction(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n  ));
+    free( (void*)arg3->p );
   }
   return resultobj;
 fail:
@@ -22865,84 +22477,72 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObj
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[3] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  Handle *arg3 = (Handle *) 0 ;
+  Handle temp3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    arg3 = &temp3;
   }
-  if (argc == 0) {
-    return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(self, args);
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressTransactions",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 2) {
-    int _v;
-    {
-      _v = PyList_Check(argv[0]) ? 1 : 0;
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_0(self, args);
-      }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressTransactions', expecting string");
     }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  
+  result = (GoUint32)SKY_api_Client_AddressTransactions(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
+  }
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionCoinsSpending'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_VerifyTransactionCoinsSpending(coin_UxOutArray *,coin_UxOutArray *)\n"
-    "    SKY_coin_VerifyTransactionCoinsSpending(coin__UxArray *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Richlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  GoUint64 arg1 ;
-  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
-  coin__UxArray *arg3 = (coin__UxArray *) 0 ;
-  unsigned long long val1 ;
-  int ecode1 = 0 ;
-  GoSlice_ temp2 ;
-  GoSlice_ temp3 ;
+  Client__Handle arg1 ;
+  api__RichlistParams *arg2 = (api__RichlistParams *) 0 ;
+  Handle *arg3 = (Handle *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  Handle temp3 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   GoUint32 result;
   
   {
-    temp2.data = NULL;
-    temp2.len = 0;
-    temp2.cap = 0;
-    arg2 = (coin__UxArray *)&temp2;
+    arg3 = &temp3;
   }
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Richlist",&obj0,&obj1)) SWIG_fail;
   {
-    temp3.data = NULL;
-    temp3.len = 0;
-    temp3.cap = 0;
-    arg3 = (coin__UxArray *)&temp3;
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_VerifyTransactionHoursSpending",&obj0)) SWIG_fail;
-  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_VerifyTransactionHoursSpending" "', argument " "1"" of type '" "GoUint64""'");
-  } 
-  arg1 = (GoUint64)(val1);
-  result = (GoUint32)SKY_coin_VerifyTransactionHoursSpending(arg1,arg2,arg3);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
-    free( (void*)arg2->data );
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_Richlist" "', argument " "2"" of type '" "api__RichlistParams *""'"); 
   }
+  arg2 = (api__RichlistParams *)(argp2);
+  result = (GoUint32)SKY_api_Client_Richlist(arg1,arg2,arg3);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   {
-    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len  ));
-    free( (void*)arg3->data );
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3));
   }
   return resultobj;
 fail:
@@ -22950,430 +22550,481 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObj
 }
 
 
-SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
-  PyObject *argv[4] = {
-    0
-  };
-  Py_ssize_t ii;
+SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Client__Handle arg1 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp2 ;
+  PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
-  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  {
+    temp2 = 0;
+    arg2 = &temp2;
   }
-  if (argc == 1) {
-    int _v;
-    {
-      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(self, args);
-    }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_AddressCount",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  if (argc == 3) {
-    int _v;
-    {
-      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
-      _v = SWIG_CheckState(res);
-    }
-    if (_v) {
-      {
-        _v = PyList_Check(argv[1]) ? 1 : 0;
-      }
-      if (_v) {
-        {
-          _v = PyList_Check(argv[2]) ? 1 : 0;
-        }
-        if (_v) {
-          return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_0(self, args);
-        }
-      }
-    }
+  result = (GoUint32)SKY_api_Client_AddressCount(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
-  
+  return resultobj;
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionHoursSpending'.\n"
-    "  Possible C/C++ prototypes are:\n"
-    "    wrap_SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin_UxOutArray *,coin_UxOutArray *)\n"
-    "    SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin__UxArray *,coin__UxArray *)\n");
-  return 0;
+  return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__RichlistParams_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_UnloadWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
-  GoInt_ arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:api__RichlistParams_N_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_N_set" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnloadWallet",&obj0,&obj1)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
   }
-  arg1 = (api__RichlistParams *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "api__RichlistParams_N_set" "', argument " "2"" of type '" "GoInt_""'");
-  } 
-  arg2 = (GoInt_)(val2);
-  if (arg1) (arg1)->N = arg2;
-  resultobj = SWIG_Py_Void();
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnloadWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_UnloadWallet(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__RichlistParams_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_Health(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Client__Handle arg1 ;
+  Handle *arg2 = (Handle *) 0 ;
+  Handle temp2 ;
   PyObject * obj0 = 0 ;
-  GoInt_ result;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:api__RichlistParams_N_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_N_get" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
+  {
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Health",&obj0)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  result = (GoUint32)SKY_api_Client_Health(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2));
   }
-  arg1 = (api__RichlistParams *)(argp1);
-  result = (GoInt_) ((arg1)->N);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__RichlistParams_IncludeDistribution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_EncryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
-  BOOL arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ;
+  Handle temp4 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:api__RichlistParams_IncludeDistribution_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_IncludeDistribution_set" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
+  {
+    arg4 = &temp4;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_EncryptWallet",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_EncryptWallet(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
   }
-  arg1 = (api__RichlistParams *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "api__RichlistParams_IncludeDistribution_set" "', argument " "2"" of type '" "BOOL""'");
-  } 
-  arg2 = (BOOL)(val2);
-  if (arg1) (arg1)->IncludeDistribution = arg2;
-  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__RichlistParams_IncludeDistribution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Client__Handle arg1 ;
+  GoString arg2 ;
+  GoString arg3 ;
+  WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ;
+  Handle temp4 ;
   PyObject * obj0 = 0 ;
-  BOOL result;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:api__RichlistParams_IncludeDistribution_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_IncludeDistribution_get" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
+  {
+    arg4 = &temp4;
   }
-  arg1 = (api__RichlistParams *)(argp1);
-  result =  ((arg1)->IncludeDistribution);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_new_api__RichlistParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  api__RichlistParams *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_api__RichlistParams")) SWIG_fail;
-  result = (api__RichlistParams *)calloc(1, sizeof(api__RichlistParams));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_api__RichlistParams, SWIG_POINTER_NEW |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_delete_api__RichlistParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_api__RichlistParams",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_api__RichlistParams" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_DecryptWallet",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    SWIG_AsVal_long(obj0, (long*)&arg1);
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string");
+    }
+    (&arg3)->p = buffer;
+    (&arg3)->n = size - 1;
+  }
+  result = (GoUint32)SKY_api_Client_DecryptWallet(arg1,arg2,arg3,arg4);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4));
   }
-  arg1 = (api__RichlistParams *)(argp1);
-  free((char *) arg1);
-  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *api__RichlistParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_api__RichlistParams, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_States_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
-  GoString_ arg2 ;
+  httphelper__Address *arg1 = (httphelper__Address *) 0 ;
+  GoSlice arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:api__NetworkConnectionsFilter_States_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:SKY_httphelper_Address_UnmarshalJSON",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_States_set" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_UnmarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); 
   }
-  arg1 = (api__NetworkConnectionsFilter *)(argp1);
+  arg1 = (httphelper__Address *)(argp1);
   {
     char* buffer = 0;
     size_t size = 0;
     int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'api__NetworkConnectionsFilter_States_set', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Address_UnmarshalJSON', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
   }
-  if (arg1) (arg1)->States = arg2;
-  resultobj = SWIG_Py_Void();
+  result = (GoUint32)SKY_httphelper_Address_UnmarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_States_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
+  httphelper__Address *arg1 = (httphelper__Address *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  GoSlice_ temp2 ;
   PyObject * obj0 = 0 ;
-  GoString_ result;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:api__NetworkConnectionsFilter_States_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Address_MarshalJSON",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_States_get" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_MarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); 
+  }
+  arg1 = (httphelper__Address *)(argp1);
+  result = (GoUint32)SKY_httphelper_Address_MarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  arg1 = (api__NetworkConnectionsFilter *)(argp1);
-  result =  ((arg1)->States);
-  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_Direction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
-  GoString_ arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
+  GoSlice arg2 ;
+  GoUint64 temp1 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:api__NetworkConnectionsFilter_Direction_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_Direction_set" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
+  {
+    temp1 = 0;
+    arg1 = &temp1;
   }
-  arg1 = (api__NetworkConnectionsFilter *)(argp1);
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Coins_UnmarshalJSON",&obj0)) SWIG_fail;
   {
     char* buffer = 0;
     size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
     if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'api__NetworkConnectionsFilter_Direction_set', expecting string");
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Coins_UnmarshalJSON', expecting string");
     }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_httphelper_Coins_UnmarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
   }
-  if (arg1) (arg1)->Direction = arg2;
-  resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_Direction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  GoString_ result;
+  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoUint64 temp1 ;
+  GoSlice_ temp2 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:api__NetworkConnectionsFilter_Direction_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_Direction_get" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
+  {
+    temp1 = 0;
+    arg1 = &temp1;
+  }
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_MarshalJSON")) SWIG_fail;
+  result = (GoUint32)SKY_httphelper_Coins_MarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  arg1 = (api__NetworkConnectionsFilter *)(argp1);
-  result =  ((arg1)->Direction);
-  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_api__NetworkConnectionsFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *result = 0 ;
+  httphelper__Coins *arg1 = (httphelper__Coins *) 0 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp1 ;
+  GoUint64 temp2 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_api__NetworkConnectionsFilter")) SWIG_fail;
-  result = (api__NetworkConnectionsFilter *)calloc(1, sizeof(api__NetworkConnectionsFilter));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_POINTER_NEW |  0 );
+  {
+    temp1 = 0;
+    arg1 = &temp1;
+  }
+  {
+    temp2 = 0;
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_Value")) SWIG_fail;
+  result = (GoUint32)SKY_httphelper_Coins_Value(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
+  }
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_api__NetworkConnectionsFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
+  GoSlice arg2 ;
+  GoUint64 temp1 ;
   PyObject * obj0 = 0 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_api__NetworkConnectionsFilter",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_api__NetworkConnectionsFilter" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
+  {
+    temp1 = 0;
+    arg1 = &temp1;
   }
-  arg1 = (api__NetworkConnectionsFilter *)(argp1);
-  free((char *) arg1);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *api__NetworkConnectionsFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_cipher__Address___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  cipher__Address *arg2 = (cipher__Address *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  int result;
+  if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Hours_UnmarshalJSON",&obj0)) SWIG_fail;
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Hours_UnmarshalJSON', expecting string");
+    }
+    (&arg2)->data = buffer;
+    (&arg2)->len = size - 1;
+    (&arg2)->cap = size;
+  }
+  result = (GoUint32)SKY_httphelper_Hours_UnmarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
+  coin__UxArray *arg2 = (coin__UxArray *) 0 ;
+  GoUint64 temp1 ;
+  GoSlice_ temp2 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address___eq__" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    temp1 = 0;
+    arg1 = &temp1;
   }
-  arg1 = (cipher__Address *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__Address___eq__" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  {
+    temp2.data = NULL;
+    temp2.len = 0;
+    temp2.cap = 0;
+    arg2 = (coin__UxArray *)&temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_MarshalJSON")) SWIG_fail;
+  result = (GoUint32)SKY_httphelper_Hours_MarshalJSON(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len  ));
+    free( (void*)arg2->data );
   }
-  arg2 = (cipher__Address *)(argp2);
-  result = (int)cipher__Address___eq__(arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__Address_toStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject *result = 0 ;
+  httphelper__Hours *arg1 = (httphelper__Hours *) 0 ;
+  GoUint64 *arg2 = (GoUint64 *) 0 ;
+  GoUint64 temp1 ;
+  GoUint64 temp2 ;
+  GoUint32 result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_toStr",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_toStr" "', argument " "1"" of type '" "cipher__Address *""'"); 
+  {
+    temp1 = 0;
+    arg1 = &temp1;
+  }
+  {
+    temp2 = 0;
+    arg2 = &temp2;
+  }
+  if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_Value")) SWIG_fail;
+  result = (GoUint32)SKY_httphelper_Hours_Value(arg1,arg2);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 ));
+  }
+  {
+    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 ));
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (PyObject *)cipher__Address_toStr(arg1);
-  resultobj = result;
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__Address_Version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__RichlistParams_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  GoUint8_ arg2 ;
+  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
+  GoInt_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned char val2 ;
+  long long val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address_Version_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:api__RichlistParams_N_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Version_set" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_N_set" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
+  arg1 = (api__RichlistParams *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cipher__Address_Version_set" "', argument " "2"" of type '" "GoUint8_""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "api__RichlistParams_N_set" "', argument " "2"" of type '" "GoInt_""'");
   } 
-  arg2 = (GoUint8_)(val2);
-  if (arg1) (arg1)->Version = arg2;
+  arg2 = (GoInt_)(val2);
+  if (arg1) (arg1)->N = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23381,58 +23032,51 @@ SWIGINTERN PyObject *_wrap_cipher__Address_Version_set(PyObject *SWIGUNUSEDPARM(
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__Address_Version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__RichlistParams_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint8_ result;
+  GoInt_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_Version_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:api__RichlistParams_N_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Version_get" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_N_get" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint8_) ((arg1)->Version);
-  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
+  arg1 = (api__RichlistParams *)(argp1);
+  result = (GoInt_) ((arg1)->N);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__Address_Key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__RichlistParams_IncludeDistribution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
-  GoUint8_ *arg2 ;
+  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
+  BOOL arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address_Key_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:api__RichlistParams_IncludeDistribution_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Key_set" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_IncludeDistribution_set" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__Address_Key_set" "', argument " "2"" of type '" "unsigned char [20]""'"); 
+  arg1 = (api__RichlistParams *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "api__RichlistParams_IncludeDistribution_set" "', argument " "2"" of type '" "BOOL""'");
   } 
-  arg2 = (unsigned char *)(argp2);
-  {
-    if (arg2) {
-      size_t ii = 0;
-      for (; ii < (size_t)20; ++ii) *(unsigned char *)&arg1->Key[ii] = *((unsigned char *)arg2 + ii);
-    } else {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Key""' of type '""unsigned char [20]""'");
-    }
-  }
+  arg2 = (BOOL)(val2);
+  if (arg1) (arg1)->IncludeDistribution = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23440,54 +23084,54 @@ SWIGINTERN PyObject *_wrap_cipher__Address_Key_set(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__Address_Key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__RichlistParams_IncludeDistribution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint8_ *result = 0 ;
+  BOOL result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_Key_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:api__RichlistParams_IncludeDistribution_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Key_get" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__RichlistParams_IncludeDistribution_get" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
-  result = (GoUint8_ *) ((arg1)->Key);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
+  arg1 = (api__RichlistParams *)(argp1);
+  result =  ((arg1)->IncludeDistribution);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_cipher__Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_api__RichlistParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *result = 0 ;
+  api__RichlistParams *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_cipher__Address")) SWIG_fail;
-  result = (cipher__Address *)calloc(1, sizeof(cipher__Address));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cipher__Address, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)":new_api__RichlistParams")) SWIG_fail;
+  result = (api__RichlistParams *)calloc(1, sizeof(api__RichlistParams));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_api__RichlistParams, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_cipher__Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_api__RichlistParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  api__RichlistParams *arg1 = (api__RichlistParams *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_cipher__Address",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_api__RichlistParams",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__RichlistParams, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_cipher__Address" "', argument " "1"" of type '" "cipher__Address *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_api__RichlistParams" "', argument " "1"" of type '" "api__RichlistParams *""'"); 
   }
-  arg1 = (cipher__Address *)(argp1);
+  arg1 = (api__RichlistParams *)(argp1);
   free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -23496,89 +23140,39 @@ SWIGINTERN PyObject *_wrap_delete_cipher__Address(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *cipher__Address_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *api__RichlistParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_cipher__Address, SWIG_NewClientData(obj));
+  SWIG_TypeNewClientData(SWIGTYPE_p_api__RichlistParams, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_States_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
+  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
+  GoString_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
-  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:api__NetworkConnectionsFilter_States_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress___eq__" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_States_set" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__BitcoinAddress___eq__" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  arg1 = (api__NetworkConnectionsFilter *)(argp1);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'api__NetworkConnectionsFilter_States_set', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
-  arg2 = (cipher__BitcoinAddress *)(argp2);
-  result = (int)cipher__BitcoinAddress___eq__(arg1,arg2);
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_toStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_toStr",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_toStr" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
-  }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  result = (PyObject *)cipher__BitcoinAddress_toStr(arg1);
-  resultobj = result;
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  GoUint8_ arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned char val2 ;
-  int ecode2 = 0 ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress_Version_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Version_set" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
-  }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cipher__BitcoinAddress_Version_set" "', argument " "2"" of type '" "GoUint8_""'");
-  } 
-  arg2 = (GoUint8_)(val2);
-  if (arg1) (arg1)->Version = arg2;
+  if (arg1) (arg1)->States = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23586,58 +23180,54 @@ SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Version_set(PyObject *SWIGUNUS
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_States_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint8_ result;
+  GoString_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_Version_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:api__NetworkConnectionsFilter_States_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Version_get" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_States_get" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  result = (GoUint8_) ((arg1)->Version);
-  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
+  arg1 = (api__NetworkConnectionsFilter *)(argp1);
+  result =  ((arg1)->States);
+  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_Direction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
-  GoUint8_ *arg2 ;
+  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
+  GoString_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress_Key_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:api__NetworkConnectionsFilter_Direction_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Key_set" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_Direction_set" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__BitcoinAddress_Key_set" "', argument " "2"" of type '" "unsigned char [20]""'"); 
-  } 
-  arg2 = (unsigned char *)(argp2);
+  arg1 = (api__NetworkConnectionsFilter *)(argp1);
   {
-    if (arg2) {
-      size_t ii = 0;
-      for (; ii < (size_t)20; ++ii) *(unsigned char *)&arg1->Key[ii] = *((unsigned char *)arg2 + ii);
-    } else {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Key""' of type '""unsigned char [20]""'");
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'api__NetworkConnectionsFilter_Direction_set', expecting string");
     }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
   }
+  if (arg1) (arg1)->Direction = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23645,54 +23235,54 @@ SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Key_set(PyObject *SWIGUNUSEDPA
 }
 
 
-SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_api__NetworkConnectionsFilter_Direction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint8_ *result = 0 ;
+  GoString_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_Key_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:api__NetworkConnectionsFilter_Direction_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Key_get" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "api__NetworkConnectionsFilter_Direction_get" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
-  result = (GoUint8_ *) ((arg1)->Key);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
+  arg1 = (api__NetworkConnectionsFilter *)(argp1);
+  result =  ((arg1)->Direction);
+  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_cipher__BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_api__NetworkConnectionsFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *result = 0 ;
+  api__NetworkConnectionsFilter *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_cipher__BitcoinAddress")) SWIG_fail;
-  result = (cipher__BitcoinAddress *)calloc(1, sizeof(cipher__BitcoinAddress));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cipher__BitcoinAddress, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)":new_api__NetworkConnectionsFilter")) SWIG_fail;
+  result = (api__NetworkConnectionsFilter *)calloc(1, sizeof(api__NetworkConnectionsFilter));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_cipher__BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_api__NetworkConnectionsFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  api__NetworkConnectionsFilter *arg1 = (api__NetworkConnectionsFilter *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_cipher__BitcoinAddress",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_api__NetworkConnectionsFilter",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_cipher__BitcoinAddress" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_api__NetworkConnectionsFilter" "', argument " "1"" of type '" "api__NetworkConnectionsFilter *""'"); 
   }
-  arg1 = (cipher__BitcoinAddress *)(argp1);
+  arg1 = (api__NetworkConnectionsFilter *)(argp1);
   free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -23701,88 +23291,89 @@ SWIGINTERN PyObject *_wrap_delete_cipher__BitcoinAddress(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *cipher__BitcoinAddress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *api__NetworkConnectionsFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_cipher__BitcoinAddress, SWIG_NewClientData(obj));
+  SWIG_TypeNewClientData(SWIGTYPE_p_api__NetworkConnectionsFilter, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoInt_ arg2 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  cipher__Address *arg2 = (cipher__Address *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_N_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_N_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address___eq__" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_N_set" "', argument " "2"" of type '" "GoInt_""'");
-  } 
-  arg2 = (GoInt_)(val2);
-  if (arg1) (arg1)->N = arg2;
-  resultobj = SWIG_Py_Void();
+  arg1 = (cipher__Address *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__Address___eq__" "', argument " "2"" of type '" "cipher__Address *""'"); 
+  }
+  arg2 = (cipher__Address *)(argp2);
+  result = (int)cipher__Address___eq__(arg1,arg2);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address_toStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoInt_ result;
+  PyObject *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_N_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_toStr",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_N_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_toStr" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  result = (GoInt_) ((arg1)->N);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
+  arg1 = (cipher__Address *)(argp1);
+  result = (PyObject *)cipher__Address_toStr(arg1);
+  resultobj = result;
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_R_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address_Version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoInt_ arg2 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoUint8_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  long long val2 ;
+  unsigned char val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_R_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address_Version_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_R_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Version_set" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  arg1 = (cipher__Address *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_R_set" "', argument " "2"" of type '" "GoInt_""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cipher__Address_Version_set" "', argument " "2"" of type '" "GoUint8_""'");
   } 
-  arg2 = (GoInt_)(val2);
-  if (arg1) (arg1)->R = arg2;
+  arg2 = (GoUint8_)(val2);
+  if (arg1) (arg1)->Version = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23790,51 +23381,58 @@ SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_R_set(PyObject *SWIGU
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_R_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address_Version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoInt_ result;
+  GoUint8_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_R_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_Version_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_R_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Version_get" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  result = (GoInt_) ((arg1)->R);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint8_) ((arg1)->Version);
+  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_P_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address_Key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoInt_ arg2 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
+  GoUint8_ *arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_P_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__Address_Key_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_P_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Key_set" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_P_set" "', argument " "2"" of type '" "GoInt_""'");
+  arg1 = (cipher__Address *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__Address_Key_set" "', argument " "2"" of type '" "unsigned char [20]""'"); 
   } 
-  arg2 = (GoInt_)(val2);
-  if (arg1) (arg1)->P = arg2;
+  arg2 = (unsigned char *)(argp2);
+  {
+    if (arg2) {
+      size_t ii = 0;
+      for (; ii < (size_t)20; ++ii) *(unsigned char *)&arg1->Key[ii] = *((unsigned char *)arg2 + ii);
+    } else {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Key""' of type '""unsigned char [20]""'");
+    }
+  }
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23842,51 +23440,55 @@ SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_P_set(PyObject *SWIGU
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_P_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__Address_Key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoInt_ result;
+  GoUint8_ *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_P_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__Address_Key_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_P_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__Address_Key_get" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  result = (GoInt_) ((arg1)->P);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
+  arg1 = (cipher__Address *)(argp1);
+  result = (GoUint8_ *) ((arg1)->Key);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_KeyLen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_cipher__Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
-  GoInt_ arg2 ;
+  cipher__Address *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_cipher__Address")) SWIG_fail;
+  result = (cipher__Address *)calloc(1, sizeof(cipher__Address));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cipher__Address, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_cipher__Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__Address *arg1 = (cipher__Address *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_KeyLen_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_cipher__Address",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_cipher__Address" "', argument " "1"" of type '" "cipher__Address *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_set" "', argument " "2"" of type '" "GoInt_""'");
-  } 
-  arg2 = (GoInt_)(val2);
-  if (arg1) (arg1)->KeyLen = arg2;
+  arg1 = (cipher__Address *)(argp1);
+  free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23894,55 +23496,89 @@ SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_KeyLen_set(PyObject *
 }
 
 
-SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_KeyLen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *cipher__Address_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_cipher__Address, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
-  GoInt_ result;
+  PyObject * obj1 = 0 ;
+  int result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_KeyLen_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress___eq__" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  result = (GoInt_) ((arg1)->KeyLen);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__BitcoinAddress___eq__" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); 
+  }
+  arg2 = (cipher__BitcoinAddress *)(argp2);
+  result = (int)cipher__BitcoinAddress___eq__(arg1,arg2);
+  resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_encrypt__ScryptChacha20poly1305(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_toStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *result = 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_encrypt__ScryptChacha20poly1305")) SWIG_fail;
-  result = (encrypt__ScryptChacha20poly1305 *)calloc(1, sizeof(encrypt__ScryptChacha20poly1305));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_toStr",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_toStr" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  result = (PyObject *)cipher__BitcoinAddress_toStr(arg1);
+  resultobj = result;
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_encrypt__ScryptChacha20poly1305(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  GoUint8_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned char val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_encrypt__ScryptChacha20poly1305",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress_Version_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_encrypt__ScryptChacha20poly1305" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Version_set" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
-  free((char *) arg1);
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cipher__BitcoinAddress_Version_set" "', argument " "2"" of type '" "GoUint8_""'");
+  } 
+  arg2 = (GoUint8_)(val2);
+  if (arg1) (arg1)->Version = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -23950,17 +23586,32 @@ SWIGINTERN PyObject *_wrap_delete_encrypt__ScryptChacha20poly1305(PyObject *SWIG
 }
 
 
-SWIGINTERN PyObject *encrypt__ScryptChacha20poly1305_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_NewClientData(obj));
-  return SWIG_Py_Void();
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  GoUint8_ result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_Version_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Version_get" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
+  }
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  result = (GoUint8_) ((arg1)->Version);
+  resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
+  return resultobj;
+fail:
+  return NULL;
 }
 
-SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
-  GoUint32_ *arg2 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
+  GoUint8_ *arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -23968,23 +23619,23 @@ SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_set(PyObject *SWIGUNUSEDPARM(sel
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__Field_n_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:cipher__BitcoinAddress_Key_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__Field_n_set" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Key_set" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (secp256k1go__Field *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__Field_n_set" "', argument " "2"" of type '" "GoUint32_ [10]""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cipher__BitcoinAddress_Key_set" "', argument " "2"" of type '" "unsigned char [20]""'"); 
   } 
-  arg2 = (GoUint32_ *)(argp2);
+  arg2 = (unsigned char *)(argp2);
   {
     if (arg2) {
       size_t ii = 0;
-      for (; ii < (size_t)10; ++ii) *(GoUint32_ *)&arg1->n[ii] = *((GoUint32_ *)arg2 + ii);
+      for (; ii < (size_t)20; ++ii) *(unsigned char *)&arg1->Key[ii] = *((unsigned char *)arg2 + ii);
     } else {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""n""' of type '""GoUint32_ [10]""'");
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Key""' of type '""unsigned char [20]""'");
     }
   }
   resultobj = SWIG_Py_Void();
@@ -23994,54 +23645,54 @@ SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_set(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cipher__BitcoinAddress_Key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoUint32_ *result = 0 ;
+  GoUint8_ *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__Field_n_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:cipher__BitcoinAddress_Key_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__Field_n_get" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cipher__BitcoinAddress_Key_get" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (secp256k1go__Field *)(argp1);
-  result = (GoUint32_ *)(GoUint32_ *) ((arg1)->n);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  arg1 = (cipher__BitcoinAddress *)(argp1);
+  result = (GoUint8_ *) ((arg1)->Key);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_secp256k1go__Field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_cipher__BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__Field *result = 0 ;
+  cipher__BitcoinAddress *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__Field")) SWIG_fail;
-  result = (secp256k1go__Field *)calloc(1, sizeof(secp256k1go__Field));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)":new_cipher__BitcoinAddress")) SWIG_fail;
+  result = (cipher__BitcoinAddress *)calloc(1, sizeof(cipher__BitcoinAddress));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cipher__BitcoinAddress, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_secp256k1go__Field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_cipher__BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
+  cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__Field",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_cipher__BitcoinAddress",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__Field" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_cipher__BitcoinAddress" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); 
   }
-  arg1 = (secp256k1go__Field *)(argp1);
+  arg1 = (cipher__BitcoinAddress *)(argp1);
   free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -24050,36 +23701,36 @@ SWIGINTERN PyObject *_wrap_delete_secp256k1go__Field(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *secp256k1go__Field_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *cipher__BitcoinAddress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__Field, SWIG_NewClientData(obj));
+  SWIG_TypeNewClientData(SWIGTYPE_p_cipher__BitcoinAddress, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_N_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
-  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoInt_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_X_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_X_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
-  }
-  arg1 = (secp256k1go__XY *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XY_X_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_N_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_N_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg2 = (secp256k1go__Field *)(argp2);
-  if (arg1) (arg1)->X = *arg2;
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_N_set" "', argument " "2"" of type '" "GoInt_""'");
+  } 
+  arg2 = (GoInt_)(val2);
+  if (arg1) (arg1)->N = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24087,51 +23738,103 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XY_X_set(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_N_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  secp256k1go__Field *result = 0 ;
+  GoInt_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_X_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_N_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_X_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_N_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
-  result = (secp256k1go__Field *)& ((arg1)->X);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  result = (GoInt_) ((arg1)->N);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_Y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_R_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
-  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoInt_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_Y_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_R_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Y_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_R_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XY_Y_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_R_set" "', argument " "2"" of type '" "GoInt_""'");
+  } 
+  arg2 = (GoInt_)(val2);
+  if (arg1) (arg1)->R = arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_R_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  GoInt_ result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_R_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_R_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg2 = (secp256k1go__Field *)(argp2);
-  if (arg1) (arg1)->Y = *arg2;
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  result = (GoInt_) ((arg1)->R);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_P_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoInt_ arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_P_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_P_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
+  }
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_P_set" "', argument " "2"" of type '" "GoInt_""'");
+  } 
+  arg2 = (GoInt_)(val2);
+  if (arg1) (arg1)->P = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24139,51 +23842,51 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XY_Y_set(PyObject *SWIGUNUSEDPARM(self),
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_Y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_P_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  secp256k1go__Field *result = 0 ;
+  GoInt_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_Y_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_P_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Y_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_P_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
-  result = (secp256k1go__Field *)& ((arg1)->Y);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  result = (GoInt_) ((arg1)->P);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_Infinity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_KeyLen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
-  BOOL arg2 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
+  GoInt_ arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int val2 ;
+  long long val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_Infinity_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:encrypt__ScryptChacha20poly1305_KeyLen_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Infinity_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_set" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "secp256k1go__XY_Infinity_set" "', argument " "2"" of type '" "BOOL""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_set" "', argument " "2"" of type '" "GoInt_""'");
   } 
-  arg2 = (BOOL)(val2);
-  if (arg1) (arg1)->Infinity = arg2;
+  arg2 = (GoInt_)(val2);
+  if (arg1) (arg1)->KeyLen = arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24191,54 +23894,54 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XY_Infinity_set(PyObject *SWIGUNUSEDPARM
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XY_Infinity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_encrypt__ScryptChacha20poly1305_KeyLen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  BOOL result;
+  GoInt_ result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_Infinity_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:encrypt__ScryptChacha20poly1305_KeyLen_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Infinity_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encrypt__ScryptChacha20poly1305_KeyLen_get" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
-  result =  ((arg1)->Infinity);
-  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
+  result = (GoInt_) ((arg1)->KeyLen);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_secp256k1go__XY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_encrypt__ScryptChacha20poly1305(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *result = 0 ;
+  encrypt__ScryptChacha20poly1305 *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__XY")) SWIG_fail;
-  result = (secp256k1go__XY *)calloc(1, sizeof(secp256k1go__XY));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__XY, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)":new_encrypt__ScryptChacha20poly1305")) SWIG_fail;
+  result = (encrypt__ScryptChacha20poly1305 *)calloc(1, sizeof(encrypt__ScryptChacha20poly1305));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_secp256k1go__XY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_encrypt__ScryptChacha20poly1305(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
+  encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__XY",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_encrypt__ScryptChacha20poly1305",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__XY" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_encrypt__ScryptChacha20poly1305" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); 
   }
-  arg1 = (secp256k1go__XY *)(argp1);
+  arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1);
   free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -24247,17 +23950,17 @@ SWIGINTERN PyObject *_wrap_delete_secp256k1go__XY(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *secp256k1go__XY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *encrypt__ScryptChacha20poly1305_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__XY, SWIG_NewClientData(obj));
+  SWIG_TypeNewClientData(SWIGTYPE_p_encrypt__ScryptChacha20poly1305, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
-  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
+  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
+  GoUint32_ *arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -24265,18 +23968,25 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_set(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_X_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__Field_n_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_X_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__Field_n_set" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  arg1 = (secp256k1go__Field *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_X_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__Field_n_set" "', argument " "2"" of type '" "GoUint32_ [10]""'"); 
+  } 
+  arg2 = (GoUint32_ *)(argp2);
+  {
+    if (arg2) {
+      size_t ii = 0;
+      for (; ii < (size_t)10; ++ii) *(GoUint32_ *)&arg1->n[ii] = *((GoUint32_ *)arg2 + ii);
+    } else {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""n""' of type '""GoUint32_ [10]""'");
+    }
   }
-  arg2 = (secp256k1go__Field *)(argp2);
-  if (arg1) (arg1)->X = *arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24284,51 +23994,92 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_set(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__Field_n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  secp256k1go__Field *result = 0 ;
+  GoUint32_ *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_X_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__Field_n_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_X_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__Field_n_get" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
-  result = (secp256k1go__Field *)& ((arg1)->X);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  arg1 = (secp256k1go__Field *)(argp1);
+  result = (GoUint32_ *)(GoUint32_ *) ((arg1)->n);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_secp256k1go__Field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
-  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  secp256k1go__Field *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__Field")) SWIG_fail;
+  result = (secp256k1go__Field *)calloc(1, sizeof(secp256k1go__Field));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_secp256k1go__Field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__Field *arg1 = (secp256k1go__Field *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__Field",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__Field, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__Field" "', argument " "1"" of type '" "secp256k1go__Field *""'"); 
+  }
+  arg1 = (secp256k1go__Field *)(argp1);
+  free((char *) arg1);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *secp256k1go__Field_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__Field, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
+  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   void *argp2 = 0 ;
   int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Y_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_X_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Y_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_X_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
+  arg1 = (secp256k1go__XY *)(argp1);
   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_Y_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XY_X_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
   }
   arg2 = (secp256k1go__Field *)(argp2);
-  if (arg1) (arg1)->Y = *arg2;
+  if (arg1) (arg1)->X = *arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24336,21 +24087,21 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_set(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   secp256k1go__Field *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Y_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_X_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Y_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_X_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
-  result = (secp256k1go__Field *)& ((arg1)->Y);
+  arg1 = (secp256k1go__XY *)(argp1);
+  result = (secp256k1go__Field *)& ((arg1)->X);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   return resultobj;
 fail:
@@ -24358,9 +24109,9 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_get(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_Y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -24369,18 +24120,18 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_set(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Z_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_Y_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Z_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Y_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
+  arg1 = (secp256k1go__XY *)(argp1);
   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_Z_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XY_Y_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
   }
   arg2 = (secp256k1go__Field *)(argp2);
-  if (arg1) (arg1)->Z = *arg2;
+  if (arg1) (arg1)->Y = *arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24388,21 +24139,21 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_set(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_Y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   secp256k1go__Field *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Z_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_Y_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Z_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Y_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
-  result = (secp256k1go__Field *)& ((arg1)->Z);
+  arg1 = (secp256k1go__XY *)(argp1);
+  result = (secp256k1go__Field *)& ((arg1)->Y);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   return resultobj;
 fail:
@@ -24410,9 +24161,9 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_get(PyObject *SWIGUNUSEDPARM(self)
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_Infinity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   BOOL arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -24421,15 +24172,15 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_set(PyObject *SWIGUNUSEDPAR
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Infinity_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XY_Infinity_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Infinity_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Infinity_set" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
+  arg1 = (secp256k1go__XY *)(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "secp256k1go__XYZ_Infinity_set" "', argument " "2"" of type '" "BOOL""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "secp256k1go__XY_Infinity_set" "', argument " "2"" of type '" "BOOL""'");
   } 
   arg2 = (BOOL)(val2);
   if (arg1) (arg1)->Infinity = arg2;
@@ -24440,20 +24191,20 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_set(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XY_Infinity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   BOOL result;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Infinity_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XY_Infinity_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Infinity_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XY_Infinity_get" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
+  arg1 = (secp256k1go__XY *)(argp1);
   result =  ((arg1)->Infinity);
   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
   return resultobj;
@@ -24462,32 +24213,32 @@ SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_get(PyObject *SWIGUNUSEDPAR
 }
 
 
-SWIGINTERN PyObject *_wrap_new_secp256k1go__XYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_secp256k1go__XY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *result = 0 ;
+  secp256k1go__XY *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__XYZ")) SWIG_fail;
-  result = (secp256k1go__XYZ *)calloc(1, sizeof(secp256k1go__XYZ));
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__XYZ, SWIG_POINTER_NEW |  0 );
+  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__XY")) SWIG_fail;
+  result = (secp256k1go__XY *)calloc(1, sizeof(secp256k1go__XY));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__XY, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_delete_secp256k1go__XYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_secp256k1go__XY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__XY *arg1 = (secp256k1go__XY *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__XYZ",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, SWIG_POINTER_DISOWN |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__XY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XY, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__XYZ" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__XY" "', argument " "1"" of type '" "secp256k1go__XY *""'"); 
   }
-  arg1 = (secp256k1go__XYZ *)(argp1);
+  arg1 = (secp256k1go__XY *)(argp1);
   free((char *) arg1);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -24496,39 +24247,36 @@ SWIGINTERN PyObject *_wrap_delete_secp256k1go__XYZ(PyObject *SWIGUNUSEDPARM(self
 }
 
 
-SWIGINTERN PyObject *secp256k1go__XYZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *secp256k1go__XY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__XYZ, SWIG_NewClientData(obj));
+  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__XY, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_cli__SendAmount_Addr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
-  GoString_ arg2 ;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cli__SendAmount_Addr_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_X_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Addr_set" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_X_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
   }
-  arg1 = (cli__SendAmount *)(argp1);
-  {
-    char* buffer = 0;
-    size_t size = 0;
-    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
-    if (!SWIG_IsOK(res)) {
-      SWIG_exception_fail(SWIG_TypeError, "in method 'cli__SendAmount_Addr_set', expecting string");
-    }
-    (&arg2)->p = buffer;
-    (&arg2)->n = size - 1;
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_X_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
   }
-  if (arg1) (arg1)->Addr = arg2;
+  arg2 = (secp256k1go__Field *)(argp2);
+  if (arg1) (arg1)->X = *arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24536,51 +24284,51 @@ SWIGINTERN PyObject *_wrap_cli__SendAmount_Addr_set(PyObject *SWIGUNUSEDPARM(sel
 }
 
 
-SWIGINTERN PyObject *_wrap_cli__SendAmount_Addr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoString_ result;
+  secp256k1go__Field *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cli__SendAmount_Addr_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_X_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Addr_get" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_X_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
   }
-  arg1 = (cli__SendAmount *)(argp1);
-  result =  ((arg1)->Addr);
-  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  result = (secp256k1go__Field *)& ((arg1)->X);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_cli__SendAmount_Coins_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
-  GoInt64_ arg2 ;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  long long val2 ;
-  int ecode2 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OO:cli__SendAmount_Coins_set",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Y_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Coins_set" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Y_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
   }
-  arg1 = (cli__SendAmount *)(argp1);
-  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cli__SendAmount_Coins_set" "', argument " "2"" of type '" "GoInt64_""'");
-  } 
-  arg2 = (GoInt64_)(val2);
-  if (arg1) (arg1)->Coins = arg2;
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_Y_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+  }
+  arg2 = (secp256k1go__Field *)(argp2);
+  if (arg1) (arg1)->Y = *arg2;
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -24588,34 +24336,286 @@ SWIGINTERN PyObject *_wrap_cli__SendAmount_Coins_set(PyObject *SWIGUNUSEDPARM(se
 }
 
 
-SWIGINTERN PyObject *_wrap_cli__SendAmount_Coins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
-  GoInt64_ result;
+  secp256k1go__Field *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"O:cli__SendAmount_Coins_get",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Y_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Coins_get" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Y_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
   }
-  arg1 = (cli__SendAmount *)(argp1);
-  result = (GoInt64_) ((arg1)->Coins);
-  resultobj = SWIG_From_long_SS_long((long long)(result));
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  result = (secp256k1go__Field *)& ((arg1)->Y);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_new_cli__SendAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  cli__SendAmount *result = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)":new_cli__SendAmount")) SWIG_fail;
-  result = (cli__SendAmount *)calloc(1, sizeof(cli__SendAmount));
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  secp256k1go__Field *arg2 = (secp256k1go__Field *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Z_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Z_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+  }
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "secp256k1go__XYZ_Z_set" "', argument " "2"" of type '" "secp256k1go__Field *""'"); 
+  }
+  arg2 = (secp256k1go__Field *)(argp2);
+  if (arg1) (arg1)->Z = *arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  secp256k1go__Field *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Z_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Z_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+  }
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  result = (secp256k1go__Field *)& ((arg1)->Z);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__Field, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  BOOL arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:secp256k1go__XYZ_Infinity_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Infinity_set" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+  }
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "secp256k1go__XYZ_Infinity_set" "', argument " "2"" of type '" "BOOL""'");
+  } 
+  arg2 = (BOOL)(val2);
+  if (arg1) (arg1)->Infinity = arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_secp256k1go__XYZ_Infinity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  BOOL result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:secp256k1go__XYZ_Infinity_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "secp256k1go__XYZ_Infinity_get" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+  }
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  result =  ((arg1)->Infinity);
+  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_secp256k1go__XYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XYZ *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_secp256k1go__XYZ")) SWIG_fail;
+  result = (secp256k1go__XYZ *)calloc(1, sizeof(secp256k1go__XYZ));
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_secp256k1go__XYZ, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_secp256k1go__XYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  secp256k1go__XYZ *arg1 = (secp256k1go__XYZ *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_secp256k1go__XYZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_secp256k1go__XYZ, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_secp256k1go__XYZ" "', argument " "1"" of type '" "secp256k1go__XYZ *""'"); 
+  }
+  arg1 = (secp256k1go__XYZ *)(argp1);
+  free((char *) arg1);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *secp256k1go__XYZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_secp256k1go__XYZ, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_cli__SendAmount_Addr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  GoString_ arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:cli__SendAmount_Addr_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Addr_set" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+  }
+  arg1 = (cli__SendAmount *)(argp1);
+  {
+    char* buffer = 0;
+    size_t size = 0;
+    int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 );
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_TypeError, "in method 'cli__SendAmount_Addr_set', expecting string");
+    }
+    (&arg2)->p = buffer;
+    (&arg2)->n = size - 1;
+  }
+  if (arg1) (arg1)->Addr = arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cli__SendAmount_Addr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  GoString_ result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:cli__SendAmount_Addr_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Addr_get" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+  }
+  arg1 = (cli__SendAmount *)(argp1);
+  result =  ((arg1)->Addr);
+  resultobj = SWIG_NewPointerObj((GoString_ *)memcpy((GoString_ *)calloc(1,sizeof(GoString_)),&result,sizeof(GoString_)), SWIGTYPE_p_GoString_, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cli__SendAmount_Coins_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  GoInt64_ arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  long long val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:cli__SendAmount_Coins_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Coins_set" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+  }
+  arg1 = (cli__SendAmount *)(argp1);
+  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cli__SendAmount_Coins_set" "', argument " "2"" of type '" "GoInt64_""'");
+  } 
+  arg2 = (GoInt64_)(val2);
+  if (arg1) (arg1)->Coins = arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cli__SendAmount_Coins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cli__SendAmount *arg1 = (cli__SendAmount *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  GoInt64_ result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:cli__SendAmount_Coins_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cli__SendAmount, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cli__SendAmount_Coins_get" "', argument " "1"" of type '" "cli__SendAmount *""'"); 
+  }
+  arg1 = (cli__SendAmount *)(argp1);
+  result = (GoInt64_) ((arg1)->Coins);
+  resultobj = SWIG_From_long_SS_long((long long)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_cli__SendAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  cli__SendAmount *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_cli__SendAmount")) SWIG_fail;
+  result = (cli__SendAmount *)calloc(1, sizeof(cli__SendAmount));
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cli__SendAmount, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
@@ -28151,88 +28151,104 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"new_GoSlice", _wrap_new_GoSlice, METH_VARARGS, NULL},
 	 { (char *)"delete_GoSlice", _wrap_delete_GoSlice, METH_VARARGS, NULL},
 	 { (char *)"GoSlice_swigregister", GoSlice_swigregister, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_NewBlock", _wrap_SKY_coin_NewBlock, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SignedBlock_VerifySignature", _wrap_SKY_coin_SignedBlock_VerifySignature, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_NewGenesisBlock", _wrap_SKY_coin_NewGenesisBlock, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_HashHeader", _wrap_SKY_coin_Block_HashHeader, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_PreHashHeader", _wrap_SKY_coin_Block_PreHashHeader, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_Time", _wrap_SKY_coin_Block_Time, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_Seq", _wrap_SKY_coin_Block_Seq, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_HashBody", _wrap_SKY_coin_Block_HashBody, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_Size", _wrap_SKY_coin_Block_Size, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_String", _wrap_SKY_coin_Block_String, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Block_GetTransaction", _wrap_SKY_coin_Block_GetTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_NewBlockHeader", _wrap_SKY_coin_NewBlockHeader, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockHeader_Hash", _wrap_SKY_coin_BlockHeader_Hash, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockHeader_Bytes", _wrap_SKY_coin_BlockHeader_Bytes, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockHeader_String", _wrap_SKY_coin_BlockHeader_String, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockBody_Hash", _wrap_SKY_coin_BlockBody_Hash, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockBody_Size", _wrap_SKY_coin_BlockBody_Size, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_BlockBody_Bytes", _wrap_SKY_coin_BlockBody_Bytes, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_CreateUnspents", _wrap_SKY_coin_CreateUnspents, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_CreateUnspent", _wrap_SKY_coin_CreateUnspent, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_GetBlockObject", _wrap_SKY_coin_GetBlockObject, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_GetBlockBody", _wrap_SKY_coin_GetBlockBody, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_NewEmptyBlock", _wrap_SKY_coin_NewEmptyBlock, METH_VARARGS, NULL},
-	 { (char *)"SKY_bip39_NewDefaultMnemomic", _wrap_SKY_bip39_NewDefaultMnemomic, METH_VARARGS, NULL},
-	 { (char *)"SKY_bip39_NewEntropy", _wrap_SKY_bip39_NewEntropy, METH_VARARGS, NULL},
-	 { (char *)"SKY_bip39_NewMnemonic", _wrap_SKY_bip39_NewMnemonic, METH_VARARGS, NULL},
-	 { (char *)"SKY_bip39_MnemonicToByteArray", _wrap_SKY_bip39_MnemonicToByteArray, METH_VARARGS, NULL},
-	 { (char *)"SKY_bip39_IsMnemonicValid", _wrap_SKY_bip39_IsMnemonicValid, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_NewClient", _wrap_SKY_api_NewClient, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_CSRF", _wrap_SKY_api_Client_CSRF, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Version", _wrap_SKY_api_Client_Version, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Outputs", _wrap_SKY_api_Client_Outputs, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_OutputsForAddresses", _wrap_SKY_api_Client_OutputsForAddresses, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_OutputsForHashes", _wrap_SKY_api_Client_OutputsForHashes, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_CoinSupply", _wrap_SKY_api_Client_CoinSupply, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_BlockByHash", _wrap_SKY_api_Client_BlockByHash, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_BlockBySeq", _wrap_SKY_api_Client_BlockBySeq, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Blocks", _wrap_SKY_api_Client_Blocks, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_LastBlocks", _wrap_SKY_api_Client_LastBlocks, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_BlockchainMetadata", _wrap_SKY_api_Client_BlockchainMetadata, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_BlockchainProgress", _wrap_SKY_api_Client_BlockchainProgress, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Balance", _wrap_SKY_api_Client_Balance, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_UxOut", _wrap_SKY_api_Client_UxOut, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_AddressUxOuts", _wrap_SKY_api_Client_AddressUxOuts, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Wallet", _wrap_SKY_api_Client_Wallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Wallets", _wrap_SKY_api_Client_Wallets, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_CreateUnencryptedWallet", _wrap_SKY_api_Client_CreateUnencryptedWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_CreateEncryptedWallet", _wrap_SKY_api_Client_CreateEncryptedWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NewWalletAddress", _wrap_SKY_api_Client_NewWalletAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_WalletBalance", _wrap_SKY_api_Client_WalletBalance, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Spend", _wrap_SKY_api_Client_Spend, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_CreateTransaction", _wrap_SKY_api_Client_CreateTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_UpdateWallet", _wrap_SKY_api_Client_UpdateWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_WalletFolderName", _wrap_SKY_api_Client_WalletFolderName, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NewSeed", _wrap_SKY_api_Client_NewSeed, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_WalletSeed", _wrap_SKY_api_Client_WalletSeed, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NetworkConnection", _wrap_SKY_api_Client_NetworkConnection, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NetworkConnections", _wrap_SKY_api_Client_NetworkConnections, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NetworkDefaultPeers", _wrap_SKY_api_Client_NetworkDefaultPeers, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NetworkTrustedPeers", _wrap_SKY_api_Client_NetworkTrustedPeers, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_NetworkExchangedPeers", _wrap_SKY_api_Client_NetworkExchangedPeers, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_PendingTransactions", _wrap_SKY_api_Client_PendingTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Transaction", _wrap_SKY_api_Client_Transaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Transactions", _wrap_SKY_api_Client_Transactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_ConfirmedTransactions", _wrap_SKY_api_Client_ConfirmedTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_UnconfirmedTransactions", _wrap_SKY_api_Client_UnconfirmedTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_InjectTransaction", _wrap_SKY_api_Client_InjectTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_ResendUnconfirmedTransactions", _wrap_SKY_api_Client_ResendUnconfirmedTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_RawTransaction", _wrap_SKY_api_Client_RawTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_AddressTransactions", _wrap_SKY_api_Client_AddressTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Richlist", _wrap_SKY_api_Client_Richlist, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_AddressCount", _wrap_SKY_api_Client_AddressCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_UnloadWallet", _wrap_SKY_api_Client_UnloadWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_Health", _wrap_SKY_api_Client_Health, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_EncryptWallet", _wrap_SKY_api_Client_EncryptWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Client_DecryptWallet", _wrap_SKY_api_Client_DecryptWallet, METH_VARARGS, NULL},
 	 { (char *)"SKY_api_NewWalletResponse", _wrap_SKY_api_NewWalletResponse, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_NewCreateTransactionResponse", _wrap_SKY_api_NewCreateTransactionResponse, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_NewCreatedTransaction", _wrap_SKY_api_NewCreatedTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_CreatedTransaction_ToTransaction", _wrap_SKY_api_CreatedTransaction_ToTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_NewCreatedTransactionOutput", _wrap_SKY_api_NewCreatedTransactionOutput, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_NewCreatedTransactionInput", _wrap_SKY_api_NewCreatedTransactionInput, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_GenerateAddressesInFile", _wrap_SKY_cli_GenerateAddressesInFile, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_FormatAddressesAsJSON", _wrap_SKY_cli_FormatAddressesAsJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_FormatAddressesAsJoinedArray", _wrap_SKY_cli_FormatAddressesAsJoinedArray, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_AddressesToStrings", _wrap_SKY_cli_AddressesToStrings, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_NewReadableEntry", _wrap_SKY_wallet_NewReadableEntry, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_LoadReadableWallet", _wrap_SKY_wallet_LoadReadableWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_ReadableWallet_Save", _wrap_SKY_wallet_ReadableWallet_Save, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_ReadableWallet_Load", _wrap_SKY_wallet_ReadableWallet_Load, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_ReadableWallet_Erase", _wrap_SKY_wallet_ReadableWallet_Erase, METH_VARARGS, NULL},
+	 { (char *)"SKY_logging_EnableColors", _wrap_SKY_logging_EnableColors, METH_VARARGS, NULL},
+	 { (char *)"SKY_logging_DisableColors", _wrap_SKY_logging_DisableColors, METH_VARARGS, NULL},
+	 { (char *)"SKY_logging_Disable", _wrap_SKY_logging_Disable, METH_VARARGS, NULL},
+	 { (char *)"SKY_fee_VerifyTransactionFee", _wrap_SKY_fee_VerifyTransactionFee, METH_VARARGS, NULL},
+	 { (char *)"SKY_fee_VerifyTransactionFeeForHours", _wrap_SKY_fee_VerifyTransactionFeeForHours, METH_VARARGS, NULL},
+	 { (char *)"SKY_fee_RequiredFee", _wrap_SKY_fee_RequiredFee, METH_VARARGS, NULL},
+	 { (char *)"SKY_fee_RemainingHours", _wrap_SKY_fee_RemainingHours, METH_VARARGS, NULL},
+	 { (char *)"SKY_fee_TransactionFee", _wrap_SKY_fee_TransactionFee, METH_VARARGS, NULL},
+	 { (char *)"SKY_JsonEncode_Handle", _wrap_SKY_JsonEncode_Handle, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Progress_GetCurrent", _wrap_SKY_Handle_Progress_GetCurrent, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Block_GetHeadSeq", _wrap_SKY_Handle_Block_GetHeadSeq, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Block_GetHeadHash", _wrap_SKY_Handle_Block_GetHeadHash, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Block_GetPreviousBlockHash", _wrap_SKY_Handle_Block_GetPreviousBlockHash, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Blocks_GetAt", _wrap_SKY_Handle_Blocks_GetAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Blocks_GetCount", _wrap_SKY_Handle_Blocks_GetCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Connections_GetCount", _wrap_SKY_Handle_Connections_GetCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Strings_GetCount", _wrap_SKY_Handle_Strings_GetCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Strings_Sort", _wrap_SKY_Handle_Strings_Sort, METH_VARARGS, NULL},
+	 { (char *)"SKY_Handle_Strings_GetAt", _wrap_SKY_Handle_Strings_GetAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_Client_GetWalletDir", _wrap_SKY_api_Handle_Client_GetWalletDir, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_Client_GetWalletFileName", _wrap_SKY_api_Handle_Client_GetWalletFileName, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_Client_GetWalletLabel", _wrap_SKY_api_Handle_Client_GetWalletLabel, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_Client_GetWalletFullPath", _wrap_SKY_api_Handle_Client_GetWalletFullPath, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetWalletMeta", _wrap_SKY_api_Handle_GetWalletMeta, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetWalletEntriesCount", _wrap_SKY_api_Handle_GetWalletEntriesCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_Client_GetWalletResponseEntriesCount", _wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletGetEntry", _wrap_SKY_api_Handle_WalletGetEntry, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletResponseGetEntry", _wrap_SKY_api_Handle_WalletResponseGetEntry, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletResponseIsEncrypted", _wrap_SKY_api_Handle_WalletResponseIsEncrypted, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletResponseGetCryptoType", _wrap_SKY_api_Handle_WalletResponseGetCryptoType, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletsResponseGetCount", _wrap_SKY_api_Handle_WalletsResponseGetCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_WalletsResponseGetAt", _wrap_SKY_api_Handle_WalletsResponseGetAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetWalletFolderAddress", _wrap_SKY_api_Handle_GetWalletFolderAddress, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetWalletSeed", _wrap_SKY_api_Handle_GetWalletSeed, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetWalletLastSeed", _wrap_SKY_api_Handle_GetWalletLastSeed, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Handle_GetBuildInfoData", _wrap_SKY_api_Handle_GetBuildInfoData, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_AddPrivateKey", _wrap_SKY_cli_AddPrivateKey, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_AddPrivateKeyToFile", _wrap_SKY_cli_AddPrivateKeyToFile, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Create_Transaction", _wrap_SKY_coin_Create_Transaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_Copy", _wrap_SKY_coin_Transaction_Copy, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_GetTransactionObject", _wrap_SKY_coin_GetTransactionObject, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_ResetInputs", _wrap_SKY_coin_Transaction_ResetInputs, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetInputsCount", _wrap_SKY_coin_Transaction_GetInputsCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetInputAt", _wrap_SKY_coin_Transaction_GetInputAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_SetInputAt", _wrap_SKY_coin_Transaction_SetInputAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetOutputsCount", _wrap_SKY_coin_Transaction_GetOutputsCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetOutputAt", _wrap_SKY_coin_Transaction_GetOutputAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_SetOutputAt", _wrap_SKY_coin_Transaction_SetOutputAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetSignaturesCount", _wrap_SKY_coin_Transaction_GetSignaturesCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_GetSignatureAt", _wrap_SKY_coin_Transaction_GetSignatureAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_SetSignatureAt", _wrap_SKY_coin_Transaction_SetSignatureAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_PushSignature", _wrap_SKY_coin_Transaction_PushSignature, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_ResetOutputs", _wrap_SKY_coin_Transaction_ResetOutputs, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_ResetSignatures", _wrap_SKY_coin_Transaction_ResetSignatures, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_Verify", _wrap_SKY_coin_Transaction_Verify, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_VerifyInput", _wrap_SKY_coin_Transaction_VerifyInput, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_PushInput", _wrap_SKY_coin_Transaction_PushInput, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_TransactionOutput_UxID", _wrap_SKY_coin_TransactionOutput_UxID, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_PushOutput", _wrap_SKY_coin_Transaction_PushOutput, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_SignInputs", _wrap_SKY_coin_Transaction_SignInputs, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_Size", _wrap_SKY_coin_Transaction_Size, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_Hash", _wrap_SKY_coin_Transaction_Hash, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_SizeHash", _wrap_SKY_coin_Transaction_SizeHash, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_TxID", _wrap_SKY_coin_Transaction_TxID, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_TxIDHex", _wrap_SKY_coin_Transaction_TxIDHex, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_UpdateHeader", _wrap_SKY_coin_Transaction_UpdateHeader, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_HashInner", _wrap_SKY_coin_Transaction_HashInner, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_Serialize", _wrap_SKY_coin_Transaction_Serialize, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_TransactionDeserialize", _wrap_SKY_coin_TransactionDeserialize, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transaction_OutputHours", _wrap_SKY_coin_Transaction_OutputHours, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Create_Transactions", _wrap_SKY_coin_Create_Transactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_GetTransactionsObject", _wrap_SKY_coin_GetTransactionsObject, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_Length", _wrap_SKY_coin_Transactions_Length, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_Add", _wrap_SKY_coin_Transactions_Add, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_Fees", _wrap_SKY_coin_Transactions_Fees, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_GetAt", _wrap_SKY_coin_Transactions_GetAt, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_Hashes", _wrap_SKY_coin_Transactions_Hashes, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_Size", _wrap_SKY_coin_Transactions_Size, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Transactions_TruncateBytesTo", _wrap_SKY_coin_Transactions_TruncateBytesTo, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SortTransactions", _wrap_SKY_coin_SortTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_NewSortableTransactions", _wrap_SKY_coin_NewSortableTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SortableTransactions_Sort", _wrap_SKY_coin_SortableTransactions_Sort, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SortableTransactions_Len", _wrap_SKY_coin_SortableTransactions_Len, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SortableTransactions_Less", _wrap_SKY_coin_SortableTransactions_Less, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SortableTransactions_Swap", _wrap_SKY_coin_SortableTransactions_Swap, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_VerifyTransactionCoinsSpending", _wrap_SKY_coin_VerifyTransactionCoinsSpending, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_VerifyTransactionHoursSpending", _wrap_SKY_coin_VerifyTransactionHoursSpending, METH_VARARGS, NULL},
+	 { (char *)"SKY_testutil_MakeAddress", _wrap_SKY_testutil_MakeAddress, METH_VARARGS, NULL},
 	 { (char *)"SKY_wallet_NewError", _wrap_SKY_wallet_NewError, METH_VARARGS, NULL},
 	 { (char *)"SKY_wallet_NewWallet", _wrap_SKY_wallet_NewWallet, METH_VARARGS, NULL},
 	 { (char *)"SKY_wallet_Wallet_Lock", _wrap_SKY_wallet_Wallet_Lock, METH_VARARGS, NULL},
@@ -28255,45 +28271,47 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"SKY_wallet_NewUxBalance", _wrap_SKY_wallet_NewUxBalance, METH_VARARGS, NULL},
 	 { (char *)"SKY_wallet_ChooseSpendsMinimizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts, METH_VARARGS, NULL},
 	 { (char *)"SKY_wallet_ChooseSpendsMaximizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_CreateOptionsHandle", _wrap_SKY_wallet_CreateOptionsHandle, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_CreateRawTxFromWallet", _wrap_SKY_cli_CreateRawTxFromWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_CreateRawTxFromAddress", _wrap_SKY_cli_CreateRawTxFromAddress, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_CreateRawTx", _wrap_SKY_cli_CreateRawTx, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_NewTransaction", _wrap_SKY_cli_NewTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_encrypt_ScryptChacha20poly1305_Encrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt, METH_VARARGS, NULL},
+	 { (char *)"SKY_encrypt_ScryptChacha20poly1305_Decrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt, METH_VARARGS, NULL},
 	 { (char *)"SKY_cli_CheckWalletBalance", _wrap_SKY_cli_CheckWalletBalance, METH_VARARGS, NULL},
 	 { (char *)"SKY_cli_GetBalanceOfAddresses", _wrap_SKY_cli_GetBalanceOfAddresses, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_NewReadableEntry", _wrap_SKY_wallet_NewReadableEntry, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_LoadReadableWallet", _wrap_SKY_wallet_LoadReadableWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_ReadableWallet_Save", _wrap_SKY_wallet_ReadableWallet_Save, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_ReadableWallet_Load", _wrap_SKY_wallet_ReadableWallet_Load, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_ReadableWallet_Erase", _wrap_SKY_wallet_ReadableWallet_Erase, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_String2Hex", _wrap_SKY_base58_String2Hex, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Base58_ToInt", _wrap_SKY_base58_Base58_ToInt, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Base58_ToHex", _wrap_SKY_base58_Base58_ToHex, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Base58_Base582Int", _wrap_SKY_base58_Base58_Base582Int, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Base582Hex", _wrap_SKY_base58_Base582Hex, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Base58_BitHex", _wrap_SKY_base58_Base58_BitHex, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Int2Base58", _wrap_SKY_base58_Int2Base58, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Hex2Base58", _wrap_SKY_base58_Hex2Base58, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Hex2Base58String", _wrap_SKY_base58_Hex2Base58String, METH_VARARGS, NULL},
-	 { (char *)"SKY_base58_Hex2Base58Str", _wrap_SKY_base58_Hex2Base58Str, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_GenerateWallet", _wrap_SKY_cli_GenerateWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_MakeAlphanumericSeed", _wrap_SKY_cli_MakeAlphanumericSeed, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_NewClient", _wrap_SKY_webrpc_NewClient, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_CSRF", _wrap_SKY_webrpc_Client_CSRF, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_InjectTransaction", _wrap_SKY_webrpc_Client_InjectTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetStatus", _wrap_SKY_webrpc_Client_GetStatus, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetTransactionByID", _wrap_SKY_webrpc_Client_GetTransactionByID, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetAddressUxOuts", _wrap_SKY_webrpc_Client_GetAddressUxOuts, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetBlocksInRange", _wrap_SKY_webrpc_Client_GetBlocksInRange, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetBlocksBySeq", _wrap_SKY_webrpc_Client_GetBlocksBySeq, METH_VARARGS, NULL},
-	 { (char *)"SKY_webrpc_Client_GetLastBlocks", _wrap_SKY_webrpc_Client_GetLastBlocks, METH_VARARGS, NULL},
-	 { (char *)"SKY_iputil_LocalhostIP", _wrap_SKY_iputil_LocalhostIP, METH_VARARGS, NULL},
-	 { (char *)"SKY_iputil_IsLocalhost", _wrap_SKY_iputil_IsLocalhost, METH_VARARGS, NULL},
-	 { (char *)"SKY_iputil_SplitAddr", _wrap_SKY_iputil_SplitAddr, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_GenerateAddressesInFile", _wrap_SKY_cli_GenerateAddressesInFile, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_FormatAddressesAsJSON", _wrap_SKY_cli_FormatAddressesAsJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_FormatAddressesAsJoinedArray", _wrap_SKY_cli_FormatAddressesAsJoinedArray, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_AddressesToStrings", _wrap_SKY_cli_AddressesToStrings, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_GetWalletOutputsFromFile", _wrap_SKY_cli_GetWalletOutputsFromFile, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_GetWalletOutputs", _wrap_SKY_cli_GetWalletOutputs, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_AddUint64", _wrap_SKY_coin_AddUint64, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_Uint64ToInt64", _wrap_SKY_coin_Uint64ToInt64, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_Int64ToUint64", _wrap_SKY_coin_Int64ToUint64, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_IntToUint32", _wrap_SKY_coin_IntToUint32, METH_VARARGS, NULL},
+	 { (char *)"SKY_handle_close", _wrap_SKY_handle_close, METH_VARARGS, NULL},
+	 { (char *)"SKY_handle_copy", _wrap_SKY_handle_copy, METH_VARARGS, NULL},
+	 { (char *)"SKY_file_InitDataDir", _wrap_SKY_file_InitDataDir, METH_VARARGS, NULL},
+	 { (char *)"SKY_file_UserHome", _wrap_SKY_file_UserHome, METH_VARARGS, NULL},
+	 { (char *)"SKY_file_ResolveResourceDirectory", _wrap_SKY_file_ResolveResourceDirectory, METH_VARARGS, NULL},
+	 { (char *)"SKY_file_DetermineResourcePath", _wrap_SKY_file_DetermineResourcePath, METH_VARARGS, NULL},
+	 { (char *)"SKY_iputil_LocalhostIP", _wrap_SKY_iputil_LocalhostIP, METH_VARARGS, NULL},
+	 { (char *)"SKY_iputil_IsLocalhost", _wrap_SKY_iputil_IsLocalhost, METH_VARARGS, NULL},
+	 { (char *)"SKY_iputil_SplitAddr", _wrap_SKY_iputil_SplitAddr, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_DecodeBase58BitcoinAddress", _wrap_SKY_cipher_DecodeBase58BitcoinAddress, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddressFromPubKey", _wrap_SKY_cipher_BitcoinAddressFromPubKey, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddressFromSecKey", _wrap_SKY_cipher_BitcoinAddressFromSecKey, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinWalletImportFormatFromSeckey", _wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddressFromBytes", _wrap_SKY_cipher_BitcoinAddressFromBytes, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SecKeyFromBitcoinWalletImportFormat", _wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddress_Null", _wrap_SKY_cipher_BitcoinAddress_Null, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddress_Bytes", _wrap_SKY_cipher_BitcoinAddress_Bytes, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddress_Verify", _wrap_SKY_cipher_BitcoinAddress_Verify, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddress_String", _wrap_SKY_cipher_BitcoinAddress_String, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_BitcoinAddress_Checksum", _wrap_SKY_cipher_BitcoinAddress_Checksum, METH_VARARGS, NULL},
+	 { (char *)"SKY_map_Get", _wrap_SKY_map_Get, METH_VARARGS, NULL},
+	 { (char *)"SKY_map_HasKey", _wrap_SKY_map_HasKey, METH_VARARGS, NULL},
+	 { (char *)"SKY_map_Close", _wrap_SKY_map_Close, METH_VARARGS, NULL},
+	 { (char *)"SKY_droplet_FromString", _wrap_SKY_droplet_FromString, METH_VARARGS, NULL},
+	 { (char *)"SKY_droplet_ToString", _wrap_SKY_droplet_ToString, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_CryptoTypeFromString", _wrap_SKY_wallet_CryptoTypeFromString, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_RandByte", _wrap_SKY_cipher_RandByte, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_NewPubKey", _wrap_SKY_cipher_NewPubKey, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_PubKeyFromHex", _wrap_SKY_cipher_PubKeyFromHex, METH_VARARGS, NULL},
@@ -28321,39 +28339,80 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"SKY_cipher_GenerateDeterministicKeyPairsSeed", _wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_CheckSecKey", _wrap_SKY_cipher_CheckSecKey, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_CheckSecKeyHash", _wrap_SKY_cipher_CheckSecKeyHash, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_App_Run", _wrap_SKY_cli_App_Run, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Config_GetCoin", _wrap_SKY_cli_Config_GetCoin, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Config_GetRPCAddress", _wrap_SKY_cli_Config_GetRPCAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_RPCClientFromApp", _wrap_SKY_cli_RPCClientFromApp, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Getenv", _wrap_SKY_cli_Getenv, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Setenv", _wrap_SKY_cli_Setenv, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_NewBalance", _wrap_SKY_wallet_NewBalance, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_NewBalanceFromUxOut", _wrap_SKY_wallet_NewBalanceFromUxOut, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Balance_Add", _wrap_SKY_wallet_Balance_Add, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Balance_Sub", _wrap_SKY_wallet_Balance_Sub, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Balance_Equals", _wrap_SKY_wallet_Balance_Equals, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Balance_IsZero", _wrap_SKY_wallet_Balance_IsZero, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Address_UnmarshalJSON", _wrap_SKY_httphelper_Address_UnmarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Address_MarshalJSON", _wrap_SKY_httphelper_Address_MarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Coins_UnmarshalJSON", _wrap_SKY_httphelper_Coins_UnmarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Coins_MarshalJSON", _wrap_SKY_httphelper_Coins_MarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Coins_Value", _wrap_SKY_httphelper_Coins_Value, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Hours_UnmarshalJSON", _wrap_SKY_httphelper_Hours_UnmarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Hours_MarshalJSON", _wrap_SKY_httphelper_Hours_MarshalJSON, METH_VARARGS, NULL},
-	 { (char *)"SKY_httphelper_Hours_Value", _wrap_SKY_httphelper_Hours_Value, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Entry_Verify", _wrap_SKY_wallet_Entry_Verify, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_Entry_VerifyPublic", _wrap_SKY_wallet_Entry_VerifyPublic, METH_VARARGS, NULL},
-	 { (char *)"SKY_droplet_FromString", _wrap_SKY_droplet_FromString, METH_VARARGS, NULL},
-	 { (char *)"SKY_droplet_ToString", _wrap_SKY_droplet_ToString, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_CryptoTypeFromString", _wrap_SKY_wallet_CryptoTypeFromString, METH_VARARGS, NULL},
-	 { (char *)"SKY_handle_close", _wrap_SKY_handle_close, METH_VARARGS, NULL},
-	 { (char *)"SKY_handle_copy", _wrap_SKY_handle_copy, METH_VARARGS, NULL},
-	 { (char *)"SKY_logging_EnableColors", _wrap_SKY_logging_EnableColors, METH_VARARGS, NULL},
-	 { (char *)"SKY_logging_DisableColors", _wrap_SKY_logging_DisableColors, METH_VARARGS, NULL},
-	 { (char *)"SKY_logging_Disable", _wrap_SKY_logging_Disable, METH_VARARGS, NULL},
-	 { (char *)"SKY_map_Get", _wrap_SKY_map_Get, METH_VARARGS, NULL},
-	 { (char *)"SKY_map_HasKey", _wrap_SKY_map_HasKey, METH_VARARGS, NULL},
-	 { (char *)"SKY_map_Close", _wrap_SKY_map_Close, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_NewCreateTransactionResponse", _wrap_SKY_api_NewCreateTransactionResponse, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_NewCreatedTransaction", _wrap_SKY_api_NewCreatedTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_CreatedTransaction_ToTransaction", _wrap_SKY_api_CreatedTransaction_ToTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_NewCreatedTransactionOutput", _wrap_SKY_api_NewCreatedTransactionOutput, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_NewCreatedTransactionInput", _wrap_SKY_api_NewCreatedTransactionInput, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_String2Hex", _wrap_SKY_base58_String2Hex, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Base58_ToInt", _wrap_SKY_base58_Base58_ToInt, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Base58_ToHex", _wrap_SKY_base58_Base58_ToHex, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Base58_Base582Int", _wrap_SKY_base58_Base58_Base582Int, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Base582Hex", _wrap_SKY_base58_Base582Hex, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Base58_BitHex", _wrap_SKY_base58_Base58_BitHex, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Int2Base58", _wrap_SKY_base58_Int2Base58, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Hex2Base58", _wrap_SKY_base58_Hex2Base58, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Hex2Base58String", _wrap_SKY_base58_Hex2Base58String, METH_VARARGS, NULL},
+	 { (char *)"SKY_base58_Hex2Base58Str", _wrap_SKY_base58_Hex2Base58Str, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_NewClient", _wrap_SKY_webrpc_NewClient, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_CSRF", _wrap_SKY_webrpc_Client_CSRF, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_InjectTransaction", _wrap_SKY_webrpc_Client_InjectTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetStatus", _wrap_SKY_webrpc_Client_GetStatus, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetTransactionByID", _wrap_SKY_webrpc_Client_GetTransactionByID, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetAddressUxOuts", _wrap_SKY_webrpc_Client_GetAddressUxOuts, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetBlocksInRange", _wrap_SKY_webrpc_Client_GetBlocksInRange, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetBlocksBySeq", _wrap_SKY_webrpc_Client_GetBlocksBySeq, METH_VARARGS, NULL},
+	 { (char *)"SKY_webrpc_Client_GetLastBlocks", _wrap_SKY_webrpc_Client_GetLastBlocks, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_LoadConfig", _wrap_SKY_cli_LoadConfig, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Config_FullWalletPath", _wrap_SKY_cli_Config_FullWalletPath, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Config_FullDBPath", _wrap_SKY_cli_Config_FullDBPath, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_NewApp", _wrap_SKY_cli_NewApp, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_RPCClientFromContext", _wrap_SKY_cli_RPCClientFromContext, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_ConfigFromContext", _wrap_SKY_cli_ConfigFromContext, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_PasswordFromBytes_Password", _wrap_SKY_cli_PasswordFromBytes_Password, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_PasswordFromTerm_Password", _wrap_SKY_cli_PasswordFromTerm_Password, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_GenerateWallet", _wrap_SKY_cli_GenerateWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_MakeAlphanumericSeed", _wrap_SKY_cli_MakeAlphanumericSeed, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_NewBlock", _wrap_SKY_coin_NewBlock, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_SignedBlock_VerifySignature", _wrap_SKY_coin_SignedBlock_VerifySignature, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_NewGenesisBlock", _wrap_SKY_coin_NewGenesisBlock, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_HashHeader", _wrap_SKY_coin_Block_HashHeader, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_PreHashHeader", _wrap_SKY_coin_Block_PreHashHeader, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_Time", _wrap_SKY_coin_Block_Time, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_Seq", _wrap_SKY_coin_Block_Seq, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_HashBody", _wrap_SKY_coin_Block_HashBody, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_Size", _wrap_SKY_coin_Block_Size, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_String", _wrap_SKY_coin_Block_String, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_Block_GetTransaction", _wrap_SKY_coin_Block_GetTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_NewBlockHeader", _wrap_SKY_coin_NewBlockHeader, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockHeader_Hash", _wrap_SKY_coin_BlockHeader_Hash, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockHeader_Bytes", _wrap_SKY_coin_BlockHeader_Bytes, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockHeader_String", _wrap_SKY_coin_BlockHeader_String, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockBody_Hash", _wrap_SKY_coin_BlockBody_Hash, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockBody_Size", _wrap_SKY_coin_BlockBody_Size, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_BlockBody_Bytes", _wrap_SKY_coin_BlockBody_Bytes, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_CreateUnspents", _wrap_SKY_coin_CreateUnspents, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_CreateUnspent", _wrap_SKY_coin_CreateUnspent, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_GetBlockObject", _wrap_SKY_coin_GetBlockObject, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_GetBlockBody", _wrap_SKY_coin_GetBlockBody, METH_VARARGS, NULL},
+	 { (char *)"SKY_coin_NewEmptyBlock", _wrap_SKY_coin_NewEmptyBlock, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_App_Run", _wrap_SKY_cli_App_Run, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Config_GetCoin", _wrap_SKY_cli_Config_GetCoin, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Config_GetRPCAddress", _wrap_SKY_cli_Config_GetRPCAddress, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_RPCClientFromApp", _wrap_SKY_cli_RPCClientFromApp, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Getenv", _wrap_SKY_cli_Getenv, METH_VARARGS, NULL},
+	 { (char *)"SKY_cli_Setenv", _wrap_SKY_cli_Setenv, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_Ripemd160_Set", _wrap_SKY_cipher_Ripemd160_Set, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_HashRipemd160", _wrap_SKY_cipher_HashRipemd160, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SHA256_Set", _wrap_SKY_cipher_SHA256_Set, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SHA256_Hex", _wrap_SKY_cipher_SHA256_Hex, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SHA256_Xor", _wrap_SKY_cipher_SHA256_Xor, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SumSHA256", _wrap_SKY_cipher_SumSHA256, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SHA256FromHex", _wrap_SKY_cipher_SHA256FromHex, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_DoubleSHA256", _wrap_SKY_cipher_DoubleSHA256, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_AddSHA256", _wrap_SKY_cipher_AddSHA256, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_Merkle", _wrap_SKY_cipher_Merkle, METH_VARARGS, NULL},
+	 { (char *)"SKY_cipher_SHA256_Null", _wrap_SKY_cipher_SHA256_Null, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_DecodeBase58Address", _wrap_SKY_cipher_DecodeBase58Address, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_AddressFromBytes", _wrap_SKY_cipher_AddressFromBytes, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_AddressFromPubKey", _wrap_SKY_cipher_AddressFromPubKey, METH_VARARGS, NULL},
@@ -28363,34 +28422,23 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"SKY_cipher_Address_Verify", _wrap_SKY_cipher_Address_Verify, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_Address_String", _wrap_SKY_cipher_Address_String, METH_VARARGS, NULL},
 	 { (char *)"SKY_cipher_Address_Checksum", _wrap_SKY_cipher_Address_Checksum, METH_VARARGS, NULL},
-	 { (char *)"SKY_JsonEncode_Handle", _wrap_SKY_JsonEncode_Handle, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Progress_GetCurrent", _wrap_SKY_Handle_Progress_GetCurrent, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Block_GetHeadSeq", _wrap_SKY_Handle_Block_GetHeadSeq, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Block_GetHeadHash", _wrap_SKY_Handle_Block_GetHeadHash, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Block_GetPreviousBlockHash", _wrap_SKY_Handle_Block_GetPreviousBlockHash, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Blocks_GetAt", _wrap_SKY_Handle_Blocks_GetAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Blocks_GetCount", _wrap_SKY_Handle_Blocks_GetCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Connections_GetCount", _wrap_SKY_Handle_Connections_GetCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Strings_GetCount", _wrap_SKY_Handle_Strings_GetCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Strings_Sort", _wrap_SKY_Handle_Strings_Sort, METH_VARARGS, NULL},
-	 { (char *)"SKY_Handle_Strings_GetAt", _wrap_SKY_Handle_Strings_GetAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_Client_GetWalletDir", _wrap_SKY_api_Handle_Client_GetWalletDir, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_Client_GetWalletFileName", _wrap_SKY_api_Handle_Client_GetWalletFileName, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_Client_GetWalletLabel", _wrap_SKY_api_Handle_Client_GetWalletLabel, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_Client_GetWalletFullPath", _wrap_SKY_api_Handle_Client_GetWalletFullPath, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetWalletMeta", _wrap_SKY_api_Handle_GetWalletMeta, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetWalletEntriesCount", _wrap_SKY_api_Handle_GetWalletEntriesCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_Client_GetWalletResponseEntriesCount", _wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletGetEntry", _wrap_SKY_api_Handle_WalletGetEntry, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletResponseGetEntry", _wrap_SKY_api_Handle_WalletResponseGetEntry, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletResponseIsEncrypted", _wrap_SKY_api_Handle_WalletResponseIsEncrypted, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletResponseGetCryptoType", _wrap_SKY_api_Handle_WalletResponseGetCryptoType, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletsResponseGetCount", _wrap_SKY_api_Handle_WalletsResponseGetCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_WalletsResponseGetAt", _wrap_SKY_api_Handle_WalletsResponseGetAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetWalletFolderAddress", _wrap_SKY_api_Handle_GetWalletFolderAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetWalletSeed", _wrap_SKY_api_Handle_GetWalletSeed, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetWalletLastSeed", _wrap_SKY_api_Handle_GetWalletLastSeed, METH_VARARGS, NULL},
-	 { (char *)"SKY_api_Handle_GetBuildInfoData", _wrap_SKY_api_Handle_GetBuildInfoData, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_NewBalance", _wrap_SKY_wallet_NewBalance, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_NewBalanceFromUxOut", _wrap_SKY_wallet_NewBalanceFromUxOut, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Balance_Add", _wrap_SKY_wallet_Balance_Add, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Balance_Sub", _wrap_SKY_wallet_Balance_Sub, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Balance_Equals", _wrap_SKY_wallet_Balance_Equals, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Balance_IsZero", _wrap_SKY_wallet_Balance_IsZero, METH_VARARGS, NULL},
+	 { (char *)"SKY_apputil_CatchInterruptPanic", _wrap_SKY_apputil_CatchInterruptPanic, METH_VARARGS, NULL},
+	 { (char *)"SKY_apputil_CatchDebug", _wrap_SKY_apputil_CatchDebug, METH_VARARGS, NULL},
+	 { (char *)"SKY_apputil_PrintProgramStatus", _wrap_SKY_apputil_PrintProgramStatus, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Entry_Verify", _wrap_SKY_wallet_Entry_Verify, METH_VARARGS, NULL},
+	 { (char *)"SKY_wallet_Entry_VerifyPublic", _wrap_SKY_wallet_Entry_VerifyPublic, METH_VARARGS, NULL},
+	 { (char *)"SKY_bip39_NewDefaultMnemomic", _wrap_SKY_bip39_NewDefaultMnemomic, METH_VARARGS, NULL},
+	 { (char *)"SKY_bip39_NewEntropy", _wrap_SKY_bip39_NewEntropy, METH_VARARGS, NULL},
+	 { (char *)"SKY_bip39_NewMnemonic", _wrap_SKY_bip39_NewMnemonic, METH_VARARGS, NULL},
+	 { (char *)"SKY_bip39_MnemonicToByteArray", _wrap_SKY_bip39_MnemonicToByteArray, METH_VARARGS, NULL},
+	 { (char *)"SKY_bip39_IsMnemonicValid", _wrap_SKY_bip39_IsMnemonicValid, METH_VARARGS, NULL},
+	 { (char *)"SKY_certutil_NewTLSCertPair", _wrap_SKY_certutil_NewTLSCertPair, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_UxOut_Hash", _wrap_SKY_coin_UxOut_Hash, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_UxOut_SnapshotHash", _wrap_SKY_coin_UxOut_SnapshotHash, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_UxBody_Hash", _wrap_SKY_coin_UxBody_Hash, METH_VARARGS, NULL},
@@ -28415,110 +28463,62 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"SKY_coin_AddressUxOuts_GetOutputLength", _wrap_SKY_coin_AddressUxOuts_GetOutputLength, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_AddressUxOuts_Length", _wrap_SKY_coin_AddressUxOuts_Length, METH_VARARGS, NULL},
 	 { (char *)"SKY_coin_AddressUxOuts_Set", _wrap_SKY_coin_AddressUxOuts_Set, METH_VARARGS, NULL},
-	 { (char *)"SKY_encrypt_ScryptChacha20poly1305_Encrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt, METH_VARARGS, NULL},
-	 { (char *)"SKY_encrypt_ScryptChacha20poly1305_Decrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt, METH_VARARGS, NULL},
-	 { (char *)"SKY_wallet_CreateOptionsHandle", _wrap_SKY_wallet_CreateOptionsHandle, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_AddPrivateKey", _wrap_SKY_cli_AddPrivateKey, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_AddPrivateKeyToFile", _wrap_SKY_cli_AddPrivateKeyToFile, METH_VARARGS, NULL},
-	 { (char *)"SKY_apputil_CatchInterruptPanic", _wrap_SKY_apputil_CatchInterruptPanic, METH_VARARGS, NULL},
-	 { (char *)"SKY_apputil_CatchDebug", _wrap_SKY_apputil_CatchDebug, METH_VARARGS, NULL},
-	 { (char *)"SKY_apputil_PrintProgramStatus", _wrap_SKY_apputil_PrintProgramStatus, METH_VARARGS, NULL},
-	 { (char *)"SKY_certutil_NewTLSCertPair", _wrap_SKY_certutil_NewTLSCertPair, METH_VARARGS, NULL},
-	 { (char *)"SKY_fee_VerifyTransactionFee", _wrap_SKY_fee_VerifyTransactionFee, METH_VARARGS, NULL},
-	 { (char *)"SKY_fee_VerifyTransactionFeeForHours", _wrap_SKY_fee_VerifyTransactionFeeForHours, METH_VARARGS, NULL},
-	 { (char *)"SKY_fee_RequiredFee", _wrap_SKY_fee_RequiredFee, METH_VARARGS, NULL},
-	 { (char *)"SKY_fee_RemainingHours", _wrap_SKY_fee_RemainingHours, METH_VARARGS, NULL},
-	 { (char *)"SKY_fee_TransactionFee", _wrap_SKY_fee_TransactionFee, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_LoadConfig", _wrap_SKY_cli_LoadConfig, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Config_FullWalletPath", _wrap_SKY_cli_Config_FullWalletPath, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_Config_FullDBPath", _wrap_SKY_cli_Config_FullDBPath, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_NewApp", _wrap_SKY_cli_NewApp, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_RPCClientFromContext", _wrap_SKY_cli_RPCClientFromContext, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_ConfigFromContext", _wrap_SKY_cli_ConfigFromContext, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_PasswordFromBytes_Password", _wrap_SKY_cli_PasswordFromBytes_Password, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_PasswordFromTerm_Password", _wrap_SKY_cli_PasswordFromTerm_Password, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_CreateRawTxFromWallet", _wrap_SKY_cli_CreateRawTxFromWallet, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_CreateRawTxFromAddress", _wrap_SKY_cli_CreateRawTxFromAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_CreateRawTx", _wrap_SKY_cli_CreateRawTx, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_NewTransaction", _wrap_SKY_cli_NewTransaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_file_InitDataDir", _wrap_SKY_file_InitDataDir, METH_VARARGS, NULL},
-	 { (char *)"SKY_file_UserHome", _wrap_SKY_file_UserHome, METH_VARARGS, NULL},
-	 { (char *)"SKY_file_ResolveResourceDirectory", _wrap_SKY_file_ResolveResourceDirectory, METH_VARARGS, NULL},
-	 { (char *)"SKY_file_DetermineResourcePath", _wrap_SKY_file_DetermineResourcePath, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_DecodeBase58BitcoinAddress", _wrap_SKY_cipher_DecodeBase58BitcoinAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddressFromPubKey", _wrap_SKY_cipher_BitcoinAddressFromPubKey, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddressFromSecKey", _wrap_SKY_cipher_BitcoinAddressFromSecKey, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinWalletImportFormatFromSeckey", _wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddressFromBytes", _wrap_SKY_cipher_BitcoinAddressFromBytes, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SecKeyFromBitcoinWalletImportFormat", _wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddress_Null", _wrap_SKY_cipher_BitcoinAddress_Null, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddress_Bytes", _wrap_SKY_cipher_BitcoinAddress_Bytes, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddress_Verify", _wrap_SKY_cipher_BitcoinAddress_Verify, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddress_String", _wrap_SKY_cipher_BitcoinAddress_String, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_BitcoinAddress_Checksum", _wrap_SKY_cipher_BitcoinAddress_Checksum, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_GetWalletOutputsFromFile", _wrap_SKY_cli_GetWalletOutputsFromFile, METH_VARARGS, NULL},
-	 { (char *)"SKY_cli_GetWalletOutputs", _wrap_SKY_cli_GetWalletOutputs, METH_VARARGS, NULL},
-	 { (char *)"SKY_testutil_MakeAddress", _wrap_SKY_testutil_MakeAddress, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_Ripemd160_Set", _wrap_SKY_cipher_Ripemd160_Set, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_HashRipemd160", _wrap_SKY_cipher_HashRipemd160, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SHA256_Set", _wrap_SKY_cipher_SHA256_Set, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SHA256_Hex", _wrap_SKY_cipher_SHA256_Hex, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SHA256_Xor", _wrap_SKY_cipher_SHA256_Xor, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SumSHA256", _wrap_SKY_cipher_SumSHA256, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SHA256FromHex", _wrap_SKY_cipher_SHA256FromHex, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_DoubleSHA256", _wrap_SKY_cipher_DoubleSHA256, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_AddSHA256", _wrap_SKY_cipher_AddSHA256, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_Merkle", _wrap_SKY_cipher_Merkle, METH_VARARGS, NULL},
-	 { (char *)"SKY_cipher_SHA256_Null", _wrap_SKY_cipher_SHA256_Null, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Create_Transaction", _wrap_SKY_coin_Create_Transaction, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_Copy", _wrap_SKY_coin_Transaction_Copy, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_GetTransactionObject", _wrap_SKY_coin_GetTransactionObject, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_ResetInputs", _wrap_SKY_coin_Transaction_ResetInputs, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetInputsCount", _wrap_SKY_coin_Transaction_GetInputsCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetInputAt", _wrap_SKY_coin_Transaction_GetInputAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_SetInputAt", _wrap_SKY_coin_Transaction_SetInputAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetOutputsCount", _wrap_SKY_coin_Transaction_GetOutputsCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetOutputAt", _wrap_SKY_coin_Transaction_GetOutputAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_SetOutputAt", _wrap_SKY_coin_Transaction_SetOutputAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetSignaturesCount", _wrap_SKY_coin_Transaction_GetSignaturesCount, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_GetSignatureAt", _wrap_SKY_coin_Transaction_GetSignatureAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_SetSignatureAt", _wrap_SKY_coin_Transaction_SetSignatureAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_PushSignature", _wrap_SKY_coin_Transaction_PushSignature, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_ResetOutputs", _wrap_SKY_coin_Transaction_ResetOutputs, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_ResetSignatures", _wrap_SKY_coin_Transaction_ResetSignatures, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_Verify", _wrap_SKY_coin_Transaction_Verify, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_VerifyInput", _wrap_SKY_coin_Transaction_VerifyInput, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_PushInput", _wrap_SKY_coin_Transaction_PushInput, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_TransactionOutput_UxID", _wrap_SKY_coin_TransactionOutput_UxID, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_PushOutput", _wrap_SKY_coin_Transaction_PushOutput, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_SignInputs", _wrap_SKY_coin_Transaction_SignInputs, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_Size", _wrap_SKY_coin_Transaction_Size, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_Hash", _wrap_SKY_coin_Transaction_Hash, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_SizeHash", _wrap_SKY_coin_Transaction_SizeHash, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_TxID", _wrap_SKY_coin_Transaction_TxID, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_TxIDHex", _wrap_SKY_coin_Transaction_TxIDHex, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_UpdateHeader", _wrap_SKY_coin_Transaction_UpdateHeader, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_HashInner", _wrap_SKY_coin_Transaction_HashInner, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_Serialize", _wrap_SKY_coin_Transaction_Serialize, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_TransactionDeserialize", _wrap_SKY_coin_TransactionDeserialize, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transaction_OutputHours", _wrap_SKY_coin_Transaction_OutputHours, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Create_Transactions", _wrap_SKY_coin_Create_Transactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_GetTransactionsObject", _wrap_SKY_coin_GetTransactionsObject, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_Length", _wrap_SKY_coin_Transactions_Length, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_Add", _wrap_SKY_coin_Transactions_Add, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_Fees", _wrap_SKY_coin_Transactions_Fees, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_GetAt", _wrap_SKY_coin_Transactions_GetAt, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_Hashes", _wrap_SKY_coin_Transactions_Hashes, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_Size", _wrap_SKY_coin_Transactions_Size, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_Transactions_TruncateBytesTo", _wrap_SKY_coin_Transactions_TruncateBytesTo, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SortTransactions", _wrap_SKY_coin_SortTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_NewSortableTransactions", _wrap_SKY_coin_NewSortableTransactions, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SortableTransactions_Sort", _wrap_SKY_coin_SortableTransactions_Sort, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SortableTransactions_Len", _wrap_SKY_coin_SortableTransactions_Len, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SortableTransactions_Less", _wrap_SKY_coin_SortableTransactions_Less, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_SortableTransactions_Swap", _wrap_SKY_coin_SortableTransactions_Swap, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_VerifyTransactionCoinsSpending", _wrap_SKY_coin_VerifyTransactionCoinsSpending, METH_VARARGS, NULL},
-	 { (char *)"SKY_coin_VerifyTransactionHoursSpending", _wrap_SKY_coin_VerifyTransactionHoursSpending, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_NewClient", _wrap_SKY_api_NewClient, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_CSRF", _wrap_SKY_api_Client_CSRF, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Version", _wrap_SKY_api_Client_Version, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Outputs", _wrap_SKY_api_Client_Outputs, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_OutputsForAddresses", _wrap_SKY_api_Client_OutputsForAddresses, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_OutputsForHashes", _wrap_SKY_api_Client_OutputsForHashes, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_CoinSupply", _wrap_SKY_api_Client_CoinSupply, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_BlockByHash", _wrap_SKY_api_Client_BlockByHash, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_BlockBySeq", _wrap_SKY_api_Client_BlockBySeq, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Blocks", _wrap_SKY_api_Client_Blocks, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_LastBlocks", _wrap_SKY_api_Client_LastBlocks, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_BlockchainMetadata", _wrap_SKY_api_Client_BlockchainMetadata, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_BlockchainProgress", _wrap_SKY_api_Client_BlockchainProgress, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Balance", _wrap_SKY_api_Client_Balance, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_UxOut", _wrap_SKY_api_Client_UxOut, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_AddressUxOuts", _wrap_SKY_api_Client_AddressUxOuts, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Wallet", _wrap_SKY_api_Client_Wallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Wallets", _wrap_SKY_api_Client_Wallets, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_CreateUnencryptedWallet", _wrap_SKY_api_Client_CreateUnencryptedWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_CreateEncryptedWallet", _wrap_SKY_api_Client_CreateEncryptedWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NewWalletAddress", _wrap_SKY_api_Client_NewWalletAddress, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_WalletBalance", _wrap_SKY_api_Client_WalletBalance, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Spend", _wrap_SKY_api_Client_Spend, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_CreateTransaction", _wrap_SKY_api_Client_CreateTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_UpdateWallet", _wrap_SKY_api_Client_UpdateWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_WalletFolderName", _wrap_SKY_api_Client_WalletFolderName, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NewSeed", _wrap_SKY_api_Client_NewSeed, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_WalletSeed", _wrap_SKY_api_Client_WalletSeed, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NetworkConnection", _wrap_SKY_api_Client_NetworkConnection, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NetworkConnections", _wrap_SKY_api_Client_NetworkConnections, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NetworkDefaultPeers", _wrap_SKY_api_Client_NetworkDefaultPeers, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NetworkTrustedPeers", _wrap_SKY_api_Client_NetworkTrustedPeers, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_NetworkExchangedPeers", _wrap_SKY_api_Client_NetworkExchangedPeers, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_PendingTransactions", _wrap_SKY_api_Client_PendingTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Transaction", _wrap_SKY_api_Client_Transaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Transactions", _wrap_SKY_api_Client_Transactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_ConfirmedTransactions", _wrap_SKY_api_Client_ConfirmedTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_UnconfirmedTransactions", _wrap_SKY_api_Client_UnconfirmedTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_InjectTransaction", _wrap_SKY_api_Client_InjectTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_ResendUnconfirmedTransactions", _wrap_SKY_api_Client_ResendUnconfirmedTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_RawTransaction", _wrap_SKY_api_Client_RawTransaction, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_AddressTransactions", _wrap_SKY_api_Client_AddressTransactions, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Richlist", _wrap_SKY_api_Client_Richlist, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_AddressCount", _wrap_SKY_api_Client_AddressCount, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_UnloadWallet", _wrap_SKY_api_Client_UnloadWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_Health", _wrap_SKY_api_Client_Health, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_EncryptWallet", _wrap_SKY_api_Client_EncryptWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_api_Client_DecryptWallet", _wrap_SKY_api_Client_DecryptWallet, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Address_UnmarshalJSON", _wrap_SKY_httphelper_Address_UnmarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Address_MarshalJSON", _wrap_SKY_httphelper_Address_MarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Coins_UnmarshalJSON", _wrap_SKY_httphelper_Coins_UnmarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Coins_MarshalJSON", _wrap_SKY_httphelper_Coins_MarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Coins_Value", _wrap_SKY_httphelper_Coins_Value, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Hours_UnmarshalJSON", _wrap_SKY_httphelper_Hours_UnmarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Hours_MarshalJSON", _wrap_SKY_httphelper_Hours_MarshalJSON, METH_VARARGS, NULL},
+	 { (char *)"SKY_httphelper_Hours_Value", _wrap_SKY_httphelper_Hours_Value, METH_VARARGS, NULL},
 	 { (char *)"api__RichlistParams_N_set", _wrap_api__RichlistParams_N_set, METH_VARARGS, NULL},
 	 { (char *)"api__RichlistParams_N_get", _wrap_api__RichlistParams_N_get, METH_VARARGS, NULL},
 	 { (char *)"api__RichlistParams_IncludeDistribution_set", _wrap_api__RichlistParams_IncludeDistribution_set, METH_VARARGS, NULL},
diff --git a/tests/test_cipher_crypto.py b/tests/test_cipher_crypto.py
index ddf8d963..0f3b3e78 100644
--- a/tests/test_cipher_crypto.py
+++ b/tests/test_cipher_crypto.py
@@ -201,7 +201,7 @@ def test_TestPubKeyFromSig():
     assert skycoin.SKY_cipher_PubKeyFromSig(sig_1, sha_sum, public_key_2) == skycoin.SKY_OK
     assert public_key == public_key_2
     sig_2 = skycoin.cipher_Sig()
-    assert skycoin.SKY_cipher_PubKeyFromSig(sig_2, sha_sum, public_key_2) == skycoin.SKY_ErrInvalidSigForPubKey
+    assert skycoin.SKY_cipher_PubKeyFromSig(sig_2, sha_sum, public_key_2) == skycoin.SKY_ErrInvalidSigPubKeyRecovery