@staticmethod
def __fromjson__(obj):
p = KDFParams(
salt=obj["salt"],
digest=obj["digest"],
)
p.iterations = obj["iterations"]
p.hashName = obj["hashName"]
p.kdfFunc = obj["kdfFunc"]
return p
def __repr__(self):
return repr(self.__tojson__())
tinyjson.register(KDFParams)
class ScryptParams(object):
"""
A set of scrypt parameters. Can be stored and retreived in plain text to
regenerate encryption keys.
"""
def __init__(self, salt, digest, n, r, p):
"""
Args:
salt (ByteArray): A randomized salt.
digest: Key hash used as a checksum.
n (int): Scrypt iteration count, N.
r (int): Scrypt memory factor, r.
p (int): Scrypt parallelization factor, p.
Args:
value int: The amount to send, in atoms.
address str: The base-58 encoded pubkey hash.
Returns:
MsgTx: The newly created transaction on success, `False` on failure.
"""
acct = self.openAccount
keysource = KeySource(
priv=self.getKey,
change=acct.getChangeAddress,
)
tx, spentUTXOs, newUTXOs = self.blockchain.sendToAddress(
value, address, keysource, self.getUTXOs, feeRate)
acct.addMempoolTx(tx)
acct.spendUTXOs(spentUTXOs)
for utxo in newUTXOs:
acct.addUTXO(utxo)
self.signals.balance(acct.calcBalance(self.blockchain.tip["height"]))
self.save()
return tx
tinyjson.register(Wallet)
class TestWallet(unittest.TestCase):
def test_tx_to_outputs(self):
pass
def littleEndian(self):
return ByteArray(reversed(self.b))
def copy(self):
return ByteArray(self.b)
def pop(self, n):
""" Remove n bytes from the beginning of the ByteArray, returning the bytes."""
b = self[:n]
self.b = self.b[n:]
return b
# register the ByteArray class with the json encoder/decoder.
tinyjson.register(ByteArray)
class TestByteArray(unittest.TestCase):
def test_operators(self):
makeA = lambda: ByteArray(bytearray([0, 0, 255]))
makeB = lambda: ByteArray(bytearray([0, 255, 0]))
makeC = lambda: ByteArray(bytearray([255, 0, 0]))
zero = ByteArray(bytearray([0, 0, 0]))
a = makeA()
b = makeB()
a |= b
self.assertEqual(a, bytearray([0, 255, 255]))
c = makeC()
def __tojson__(self):
return {
"total": self.total,
"available": self.available,
}
@staticmethod
def __fromjson__(obj):
return Balance(total=obj["total"], available=obj["available"])
def __repr__(self):
return ("Balance(total=%.8f, available=%.8f)" %
(self.total * 1e-8, self.available * 1e-8))
tinyjson.register(Balance)
UTXO = api.UTXO
class Account(object):
"""
A BIP0044 account. Keys are stored as encrypted strings. The account is
JSON-serializable with the tinyjson module. Unencoded keys will not be
serialized.
"""
def __init__(self, pubKeyEncrypted, privKeyEncrypted, name, coinID, netID):
"""
Args:
pubKeyEncrypted (str): The encrypted public key bytes.
privKeyEncrypted (str): The encrypted private key bytes.
self.ts = block.timestamp
def isSpendable(self, tipHeight):
if self.maturity:
return self.maturity <= tipHeight
return True
def key(self):
return UTXO.makeKey(self.txid, self.vout)
@staticmethod
def makeKey(txid, vout):
return txid + "#" + str(vout)
tinyjson.register(UTXO)
def makeOutputs(
pairs, chain
): #pairs map[string]dcrutil.Amount, chainParams *chaincfg.Params) ([]*wire.TxOut, error) {
"""
makeOutputs creates a slice of transaction outputs from a pair of address
strings to amounts. This is used to create the outputs to include in newly
created transactions from a JSON object describing the output destinations
and amounts.
Args:
pairs (tuple(str, int)): Base58-encoded address strings and atoms to
send to the address.
chain obj: Network parameters.