Merge pull request #1090 from KvngMikey/feat/send-locktime-flag

feat(cli): add --timelock/-t option to send command

Author: a1denvalu3

cashu/wallet/cli/cli.py

@@ -821,6 +821,13 @@ async def balance(ctx: Context, verbose):
     help="Force swap token.",
     type=bool,
 )
+@click.option(
+    "--timelock",
+    "-t",
+    default=None,
+    help="Locktime in seconds after which the refund pubkey can claim the tokens.",
+    type=int,
+)
 @click.pass_context
 @coro
 @init_auth_wallet
@@ -835,6 +842,7 @@ async def send_command(
     offline: bool,
     include_fees: bool,
     force_swap: bool,
+    timelock: Optional[int],
 ):
     wallet: Wallet = ctx.obj["WALLET"]
     amount = int(
@@ -850,6 +858,7 @@ async def send_command(
         memo=memo,
         force_swap=force_swap,
         refund_pubkeys=list(refund) if refund else None,
+        timelock_seconds=timelock,
     )
     await print_balance(ctx)
 
@@ -1196,6 +1205,8 @@ async def lock_p2pk(ctx: Context, timelock: Optional[int], refund: tuple):
         print("")
 
     send_cmd = f"cashu send <amount> --lock {lock_str}"
+    if timelock:
+        send_cmd += f" --timelock {timelock}"
     if refund:
         for r in refund:
             send_cmd += f" --refund {r}"

cashu/wallet/helpers.py

@@ -141,6 +141,7 @@ async def send(
     memo: Optional[str] = None,
     force_swap: bool = False,
     refund_pubkeys: Optional[List[str]] = None,
+    timelock_seconds: Optional[int] = None,
 ):
     """
     Prints token to send to stdout.
@@ -151,20 +152,23 @@ async def send(
         assert len(lock) > 21, Exception(
             "Error: lock has to be at least 22 characters long."
         )
-        # we add a time lock to the P2PK lock by appending the current unix time + 14 days
+        locktime_seconds = (
+            timelock_seconds
+            if timelock_seconds is not None
+            else settings.locktime_delta_seconds
+        )
+        # we add a time lock by appending the current unix time + locktime_seconds
         if lock.startswith("P2PK:") or lock.startswith("P2PK-SIGALL:"):
             sigall = lock.startswith("P2PK-SIGALL:")
             logger.debug(f"Locking token to: {lock}")
-            logger.debug(
-                f"Adding a time lock of {settings.locktime_delta_seconds} seconds."
-            )
+            logger.debug(f"Adding a time lock of {locktime_seconds} seconds.")
             tags = None
             if refund_pubkeys:
                 tags = Tags()
                 tags["refund"] = refund_pubkeys
             secret_lock = await wallet.create_p2pk_lock(
                 lock.split(":")[1],
-                locktime_seconds=settings.locktime_delta_seconds,
+                locktime_seconds=locktime_seconds,
                 sig_all=sigall,
                 n_sigs=1,
                 tags=tags,
@@ -173,16 +177,14 @@ async def send(
         elif lock.startswith("P2BK:") or lock.startswith("P2BK-SIGALL:"):
             sigall = lock.startswith("P2BK-SIGALL:")
             logger.debug(f"Locking token with P2BK to: {lock}")
-            logger.debug(
-                f"Adding a time lock of {settings.locktime_delta_seconds} seconds."
-            )
+            logger.debug(f"Adding a time lock of {locktime_seconds} seconds.")
             tags = None
             if refund_pubkeys:
                 tags = Tags()
                 tags["refund"] = refund_pubkeys
             secret_lock, p2pk_e = await wallet.create_p2bk_lock(
                 lock.split(":")[1],
-                locktime_seconds=settings.locktime_delta_seconds,
+                locktime_seconds=locktime_seconds,
                 sig_all=sigall,
                 n_sigs=1,
                 tags=tags,

tests/wallet/test_wallet_cli.py

@@ -1,11 +1,13 @@
 import asyncio
+import time
 from typing import Tuple
 
 import bolt11
 import pytest
 from click.testing import CliRunner
 
 from cashu.core.base import TokenV4
+from cashu.core.p2pk import P2PKSecret
 from cashu.core.settings import settings
 from cashu.wallet.cli.cli import cli
 from cashu.wallet.wallet import Wallet
@@ -687,6 +689,74 @@ def test_send_with_lock_and_refund(mint, cli_prefix):
     assert fake_refund_pubkey in token.token[0].proofs[0].secret
 
 
+def test_send_with_lock_and_timelock(mint, cli_prefix):
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        [*cli_prefix, "locks"],
+    )
+    assert result.exception is None
+    lock = None
+    for word in result.output.split(" "):
+        word = word.strip()
+        if word.startswith("P2PK:"):
+            lock = word
+            break
+    assert lock is not None, "no lock found"
+
+    before = int(time.time())
+    result = runner.invoke(
+        cli,
+        [*cli_prefix, "send", "10", "--lock", lock, "--timelock", "5"],
+    )
+    after = int(time.time())
+    assert result.exception is None
+    print("test_send_with_lock_and_timelock", result.output)
+    token_str = result.output.split("\n")[0]
+    assert "cashuB" in token_str, "output does not have a token"
+    token = TokenV4.deserialize(token_str).to_tokenv3()
+    secret = P2PKSecret.deserialize(token.token[0].proofs[0].secret)
+    assert secret.locktime is not None
+    assert before + 5 <= secret.locktime <= after + 5
+
+
+def test_send_with_lock_uses_locktime_delta_seconds_by_default(mint, cli_prefix):
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        [*cli_prefix, "locks"],
+    )
+    assert result.exception is None
+    lock = None
+    for word in result.output.split(" "):
+        word = word.strip()
+        if word.startswith("P2PK:"):
+            lock = word
+            break
+    assert lock is not None, "no lock found"
+
+    before = int(time.time())
+    result = runner.invoke(
+        cli,
+        [*cli_prefix, "send", "10", "--lock", lock],
+    )
+    after = int(time.time())
+    assert result.exception is None
+    print(
+        "test_send_with_lock_uses_locktime_delta_seconds_by_default", result.output
+    )
+    token_str = result.output.split("\n")[0]
+    assert "cashuB" in token_str, "output does not have a token"
+    token = TokenV4.deserialize(token_str).to_tokenv3()
+    secret = P2PKSecret.deserialize(token.token[0].proofs[0].secret)
+    assert secret.locktime is not None
+    assert (
+        before + settings.locktime_delta_seconds
+        <= secret.locktime
+        <= after + settings.locktime_delta_seconds
+    )
+
+
 def mint_tokens(runner, cli_prefix, amount: str):
     result = runner.invoke(
         cli,