lukechilds
/
lightning
mirror of https://github.com/lukechilds/lightning.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

pylightning: Reorder LightningRpc methods alphabetically

htlc_accepted_hook
darosior 6 years ago
committed by Christian Decker
parent
b4e7b198e6
commit
efecd64bf3
1 changed files with 223 additions and 223 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 446
      contrib/pylightning/lightning/lightning.py

446
contrib/pylightning/lightning/lightning.py
View File

@ -284,145 +284,180 @@ class LightningRpc(UnixDomainSocketRpc):
def __init__(self, socket_path, executor=None, logger=logging): def __init__(self, socket_path, executor=None, logger=logging):
super().__init__(socket_path, executor, logging, self.LightningJSONEncoder, self.LightningJSONDecoder()) super().__init__(socket_path, executor, logging, self.LightningJSONEncoder, self.LightningJSONDecoder())
def getpeer(self, peer_id, level=None): def close(self, peer_id, force=None, timeout=None):
""" """
Show peer with {peer_id}, if {level} is set, include {log}s Close the channel with peer {id}, forcing a unilateral
close if {force} is True, and timing out with {timeout}
seconds.
""" """
payload = { payload = {
"id": peer_id, "id": peer_id,
"level": level "force": force,
"timeout": timeout
} }
res = self.call("listpeers", payload) return self.call("close", payload)
return res.get("peers") and res["peers"][0] or None
def listnodes(self, node_id=None): def connect(self, peer_id, host=None, port=None):
""" """
Show all nodes in our local network view, filter on node {id} Connect to {peer_id} at {host} and {port}
if provided
""" """
payload = { payload = {
"id": node_id "id": peer_id,
"host": host,
"port": port
} }
return self.call("listnodes", payload) return self.call("connect", payload)
def getroute(self, node_id, msatoshi, riskfactor, cltv=9, fromid=None, fuzzpercent=None, exclude=[], maxhops=20): def decodepay(self, bolt11, description=None):
""" """
Show route to {id} for {msatoshi}, using {riskfactor} and optional Decode {bolt11}, using {description} if necessary
{cltv} (default 9). If specified search from {fromid} otherwise use
this node as source. Randomize the route with up to {fuzzpercent}
(0.0 -> 100.0, default 5.0). {exclude} is an optional array of
scid/direction to exclude. Limit the number of hops in the route to
{maxhops}.
""" """
payload = { payload = {
"id": node_id, "bolt11": bolt11,
"msatoshi": msatoshi, "description": description
"riskfactor": riskfactor,
"cltv": cltv,
"fromid": fromid,
"fuzzpercent": fuzzpercent,
"exclude": exclude,
"maxhops": maxhops
} }
return self.call("getroute", payload) return self.call("decodepay", payload)
def listchannels(self, short_channel_id=None, source=None): def delexpiredinvoice(self, maxexpirytime=None):
""" """
Show all known channels, accept optional {short_channel_id} or {source} Delete all invoices that have expired on or before the given {maxexpirytime}
""" """
payload = { payload = {
"short_channel_id": short_channel_id, "maxexpirytime": maxexpirytime
"source": source
} }
return self.call("listchannels", payload) return self.call("delexpiredinvoice", payload)
def invoice(self, msatoshi, label, description, expiry=None, fallbacks=None, preimage=None, exposeprivatechannels=None): def delinvoice(self, label, status):
""" """
Create an invoice for {msatoshi} with {label} and {description} with Delete unpaid invoice {label} with {status}
optional {expiry} seconds (default 1 hour)
""" """
payload = { payload = {
"msatoshi": msatoshi,
"label": label, "label": label,
"description": description, "status": status
"expiry": expiry,
"fallbacks": fallbacks,
"preimage": preimage,
"exposeprivatechannels": exposeprivatechannels
} }
return self.call("invoice", payload) return self.call("delinvoice", payload)
def listinvoices(self, label=None): def dev_crash(self):
""" """
Show invoice {label} (or all, if no {label)) Crash lightningd by calling fatal()
"""
return self.call("dev-crash")
def dev_fail(self, peer_id):
"""
Fail with peer {peer_id}
""" """
payload = { payload = {
"label": label "id": peer_id
} }
return self.call("listinvoices", payload) return self.call("dev-fail", payload)
def delinvoice(self, label, status): def dev_forget_channel(self, peerid, force=False):
""" Forget the channel with id=peerid
""" """
Delete unpaid invoice {label} with {status} return self.call(
"dev-forget-channel",
payload={"id": peerid, "force": force}
)
def dev_memdump(self):
"""
Show memory objects currently in use
"""
return self.call("dev-memdump")
def dev_memleak(self):
"""
Show unreferenced memory objects
"""
return self.call("dev-memleak")
def dev_query_scids(self, id, scids):
"""
Ask peer for a particular set of scids
""" """
payload = { payload = {
"label": label, "id": id,
"status": status "scids": scids
} }
return self.call("delinvoice", payload) return self.call("dev-query-scids", payload)
def delexpiredinvoice(self, maxexpirytime=None): def dev_reenable_commit(self, peer_id):
""" """
Delete all invoices that have expired on or before the given {maxexpirytime} Re-enable the commit timer on peer {id}
""" """
payload = { payload = {
"maxexpirytime": maxexpirytime "id": peer_id
} }
return self.call("delexpiredinvoice", payload) return self.call("dev-reenable-commit", payload)
def waitanyinvoice(self, lastpay_index=None): def dev_rescan_outputs(self):
""" """
Wait for the next invoice to be paid, after {lastpay_index} Synchronize the state of our funds with bitcoind
(if supplied) """
return self.call("dev-rescan-outputs")
def dev_rhash(self, secret):
"""
Show SHA256 of {secret}
""" """
payload = { payload = {
"lastpay_index": lastpay_index "secret": secret
} }
return self.call("waitanyinvoice", payload) return self.call("dev-rhash", payload)
def waitinvoice(self, label): def dev_sign_last_tx(self, peer_id):
""" """
Wait for an incoming payment matching the invoice with {label} Sign and show the last commitment transaction with peer {id}
""" """
payload = { payload = {
"label": label "id": peer_id
} }
return self.call("waitinvoice", payload) return self.call("dev-sign-last-tx", payload)
def decodepay(self, bolt11, description=None): def disconnect(self, peer_id, force=False):
""" """
Decode {bolt11}, using {description} if necessary Disconnect from peer with {peer_id}, optional {force} even if has active channel
""" """
payload = { payload = {
"bolt11": bolt11, "id": peer_id,
"description": description "force": force,
} }
return self.call("decodepay", payload) return self.call("disconnect", payload)
def help(self, command=None): def feerates(self, style, urgent=None, normal=None, slow=None):
""" """
Show available commands, or just {command} if supplied. Supply feerate estimates manually.
""" """
payload = { payload = {
"command": command, "style": style,
"urgent": urgent,
"normal": normal,
"slow": slow
} }
return self.call("help", payload) return self.call("feerates", payload)
def stop(self): def fundchannel(self, node_id, satoshi, feerate=None, announce=True, minconf=None):
""" """
Shut down the lightningd process Fund channel with {id} using {satoshi} satoshis
with feerate of {feerate} (uses default feerate if unset).
If {announce} is False, don't send channel announcements.
Only select outputs with {minconf} confirmations
""" """
return self.call("stop") payload = {
"id": node_id,
"satoshi": satoshi,
"feerate": feerate,
"announce": announce,
"minconf": minconf,
}
return self.call("fundchannel", payload)
def getinfo(self):
"""
Show information about this node
"""
return self.call("getinfo")
def getlog(self, level=None): def getlog(self, level=None):
""" """
@ -433,74 +468,102 @@ class LightningRpc(UnixDomainSocketRpc):
} }
return self.call("getlog", payload) return self.call("getlog", payload)
def dev_rhash(self, secret): def getpeer(self, peer_id, level=None):
""" """
Show SHA256 of {secret} Show peer with {peer_id}, if {level} is set, include {log}s
""" """
payload = { payload = {
"secret": secret "id": peer_id,
"level": level
} }
return self.call("dev-rhash", payload) res = self.call("listpeers", payload)
return res.get("peers") and res["peers"][0] or None
def dev_crash(self): def getroute(self, node_id, msatoshi, riskfactor, cltv=9, fromid=None, fuzzpercent=None, exclude=[], maxhops=20):
""" """
Crash lightningd by calling fatal() Show route to {id} for {msatoshi}, using {riskfactor} and optional
{cltv} (default 9). If specified search from {fromid} otherwise use
this node as source. Randomize the route with up to {fuzzpercent}
(0.0 -> 100.0, default 5.0). {exclude} is an optional array of
scid/direction to exclude. Limit the number of hops in the route to
{maxhops}.
""" """
return self.call("dev-crash") payload = {
"id": node_id,
"msatoshi": msatoshi,
"riskfactor": riskfactor,
"cltv": cltv,
"fromid": fromid,
"fuzzpercent": fuzzpercent,
"exclude": exclude,
"maxhops": maxhops
}
return self.call("getroute", payload)
def dev_query_scids(self, id, scids): def help(self, command=None):
""" """
Ask peer for a particular set of scids Show available commands, or just {command} if supplied.
""" """
payload = { payload = {
"id": id, "command": command,
"scids": scids
} }
return self.call("dev-query-scids", payload) return self.call("help", payload)
def getinfo(self): def invoice(self, msatoshi, label, description, expiry=None, fallbacks=None, preimage=None, exposeprivatechannels=None):
""" """
Show information about this node Create an invoice for {msatoshi} with {label} and {description} with
optional {expiry} seconds (default 1 hour)
""" """
return self.call("getinfo") payload = {
"msatoshi": msatoshi,
"label": label,
"description": description,
"expiry": expiry,
"fallbacks": fallbacks,
"preimage": preimage,
"exposeprivatechannels": exposeprivatechannels
}
return self.call("invoice", payload)
def sendpay(self, route, payment_hash, description=None, msatoshi=None): def listchannels(self, short_channel_id=None, source=None):
""" """
Send along {route} in return for preimage of {payment_hash} Show all known channels, accept optional {short_channel_id} or {source}
""" """
payload = { payload = {
"route": route, "short_channel_id": short_channel_id,
"payment_hash": payment_hash, "source": source
"description": description,
"msatoshi": msatoshi,
} }
return self.call("sendpay", payload) return self.call("listchannels", payload)
def waitsendpay(self, payment_hash, timeout=None): def listforwards(self):
"""List all forwarded payments and their information
""" """
Wait for payment for preimage of {payment_hash} to complete return self.call("listforwards")
def listfunds(self):
"""
Show funds available for opening channels
"""
return self.call("listfunds")
def listinvoices(self, label=None):
"""
Show invoice {label} (or all, if no {label))
""" """
payload = { payload = {
"payment_hash": payment_hash, "label": label
"timeout": timeout
} }
return self.call("waitsendpay", payload) return self.call("listinvoices", payload)
def pay(self, bolt11, msatoshi=None, label=None, riskfactor=None, description=None): def listnodes(self, node_id=None):
""" """
Send payment specified by {bolt11} with {msatoshi} Show all nodes in our local network view, filter on node {id}
(ignored if {bolt11} has an amount), optional {label} if provided
and {riskfactor} (default 1.0)
""" """
payload = { payload = {
"bolt11": bolt11, "id": node_id
"msatoshi": msatoshi,
"label": label,
"riskfactor": riskfactor,
# Deprecated.
"description": description,
} }
return self.call("pay", payload) return self.call("listnodes", payload)
def listpayments(self, bolt11=None, payment_hash=None): def listpayments(self, bolt11=None, payment_hash=None):
""" """
@ -514,17 +577,6 @@ class LightningRpc(UnixDomainSocketRpc):
} }
return self.call("listpayments", payload) return self.call("listpayments", payload)
def connect(self, peer_id, host=None, port=None):
"""
Connect to {peer_id} at {host} and {port}
"""
payload = {
"id": peer_id,
"host": host,
"port": port
}
return self.call("connect", payload)
def listpeers(self, peerid=None, level=None): def listpeers(self, peerid=None, level=None):
""" """
Show current peers, if {level} is set, include {log}s" Show current peers, if {level} is set, include {log}s"
@ -535,84 +587,84 @@ class LightningRpc(UnixDomainSocketRpc):
} }
return self.call("listpeers", payload) return self.call("listpeers", payload)
def fundchannel(self, node_id, satoshi, feerate=None, announce=True, minconf=None): def newaddr(self, addresstype=None):
"""Get a new address of type {addresstype} of the internal wallet.
""" """
Fund channel with {id} using {satoshi} satoshis return self.call("newaddr", {"addresstype": addresstype})
with feerate of {feerate} (uses default feerate if unset).
If {announce} is False, don't send channel announcements. def pay(self, bolt11, msatoshi=None, label=None, riskfactor=None, description=None):
Only select outputs with {minconf} confirmations """
Send payment specified by {bolt11} with {msatoshi}
(ignored if {bolt11} has an amount), optional {label}
and {riskfactor} (default 1.0)
""" """
payload = { payload = {
"id": node_id, "bolt11": bolt11,
"satoshi": satoshi, "msatoshi": msatoshi,
"feerate": feerate, "label": label,
"announce": announce, "riskfactor": riskfactor,
"minconf": minconf, # Deprecated.
"description": description,
} }
return self.call("fundchannel", payload) return self.call("pay", payload)
def close(self, peer_id, force=None, timeout=None): def ping(self, peer_id, length=128, pongbytes=128):
""" """
Close the channel with peer {id}, forcing a unilateral Send {peer_id} a ping of length {len} asking for {pongbytes}"
close if {force} is True, and timing out with {timeout}
seconds.
""" """
payload = { payload = {
"id": peer_id, "id": peer_id,
"force": force, "len": length,
"timeout": timeout "pongbytes": pongbytes
} }
return self.call("close", payload) return self.call("ping", payload)
def dev_sign_last_tx(self, peer_id): def sendpay(self, route, payment_hash, description=None, msatoshi=None):
""" """
Sign and show the last commitment transaction with peer {id} Send along {route} in return for preimage of {payment_hash}
""" """
payload = { payload = {
"id": peer_id "route": route,
"payment_hash": payment_hash,
"description": description,
"msatoshi": msatoshi,
} }
return self.call("dev-sign-last-tx", payload) return self.call("sendpay", payload)
def dev_fail(self, peer_id): def stop(self):
""" """
Fail with peer {peer_id} Shut down the lightningd process
""" """
payload = { return self.call("stop")
"id": peer_id
}
return self.call("dev-fail", payload)
def dev_reenable_commit(self, peer_id): def waitanyinvoice(self, lastpay_index=None):
""" """
Re-enable the commit timer on peer {id} Wait for the next invoice to be paid, after {lastpay_index}
(if supplied)
""" """
payload = { payload = {
"id": peer_id "lastpay_index": lastpay_index
} }
return self.call("dev-reenable-commit", payload) return self.call("waitanyinvoice", payload)
def ping(self, peer_id, length=128, pongbytes=128): def waitinvoice(self, label):
""" """
Send {peer_id} a ping of length {len} asking for {pongbytes}" Wait for an incoming payment matching the invoice with {label}
""" """
payload = { payload = {
"id": peer_id, "label": label
"len": length,
"pongbytes": pongbytes
} }
return self.call("ping", payload) return self.call("waitinvoice", payload)
def dev_memdump(self):
"""
Show memory objects currently in use
"""
return self.call("dev-memdump")
def dev_memleak(self): def waitsendpay(self, payment_hash, timeout=None):
""" """
Show unreferenced memory objects Wait for payment for preimage of {payment_hash} to complete
""" """
return self.call("dev-memleak") payload = {
"payment_hash": payment_hash,
"timeout": timeout
}
return self.call("waitsendpay", payload)
def withdraw(self, destination, satoshi, feerate=None, minconf=None): def withdraw(self, destination, satoshi, feerate=None, minconf=None):
""" """
@ -627,55 +679,3 @@ class LightningRpc(UnixDomainSocketRpc):
"minconf": minconf, "minconf": minconf,
} }
return self.call("withdraw", payload) return self.call("withdraw", payload)
def newaddr(self, addresstype=None):
"""Get a new address of type {addresstype} of the internal wallet.
"""
return self.call("newaddr", {"addresstype": addresstype})
def listfunds(self):
"""
Show funds available for opening channels
"""
return self.call("listfunds")
def listforwards(self):
"""List all forwarded payments and their information
"""
return self.call("listforwards")
def dev_rescan_outputs(self):
"""
Synchronize the state of our funds with bitcoind
"""
return self.call("dev-rescan-outputs")
def dev_forget_channel(self, peerid, force=False):
""" Forget the channel with id=peerid
"""
return self.call(
"dev-forget-channel",
payload={"id": peerid, "force": force}
)
def disconnect(self, peer_id, force=False):
"""
Disconnect from peer with {peer_id}, optional {force} even if has active channel
"""
payload = {
"id": peer_id,
"force": force,
}
return self.call("disconnect", payload)
def feerates(self, style, urgent=None, normal=None, slow=None):
"""
Supply feerate estimates manually.
"""
payload = {
"style": style,
"urgent": urgent,
"normal": normal,
"slow": slow
}
return self.call("feerates", payload)

Write Preview
Loading…
Cancel
Save